Menü

Flaschenvorlage, Formular, Ansicht und Umleitung mit Beispielen

  • Haupt
  • Andere
  • Flaschenvorlage, Formular, Ansicht und Umleitung mit Beispielen

flask template form

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

In diesem Tutorial wird anhand praktischer Beispiele erläutert, was Flaschenvorlage, Formular, Ansicht, Antwort und Umleitung sind:

Im Allgemeinen wird Templating in der Programmierung verwendet, um einen Teil des Textes mit unterschiedlichen Daten wiederzuverwenden. In Bezug auf die Webentwicklung verwenden Designer Vorlagen, um Daten in einer Form anzuzeigen, die für menschliche Leser lesbar und attraktiv ist.

Ein Vorlagendesign beinhaltet im Allgemeinen die Verwendung einer Sprache aufgrund der Komplexität, die durch menschliche Interaktion entsteht.

=> Schauen Sie sich hier den Flask Beginners Guide an

Flaschenvorlagen, Ansichten und Formulare

Was du lernen wirst:

Einführung

Flask verwendet eine Vorlagen-Engine namens Jinja2, die das Verhalten einer Anwendung basierend auf der Interaktionsstufe des Benutzers anzeigt. Eine Jinja-Vorlage verwendet Variablen, Ausdrücke und Tags.

Variablen und Ausdrücke werden zur Laufzeit vor dem Rendern der Seite im Browser durch Werte ersetzt. Jinja-Tags helfen beim Schreiben von Logik und steuern Anweisungen in der Flask-Vorlage.

Kolbenansicht

Der Begriff der Flaschenansicht leitet sich aus einem vorherrschenden Entwurfsmuster für Webanwendungen ab, das als Model-View-Controller bezeichnet wird. Eine Ansicht ist eines der drei miteinander verbundenen Elemente in diesem Paradigma, in dem es um Anwendungslogik geht. Die Ansicht kümmert sich um die Präsentation von Informationen für den Benutzer.

In unserem vorherigen Tutorial haben wir eine Ansicht entworfen, indem wir die BaseView-Klasse des Flask-Appbuilder in Unterklassen unterteilt haben. Im folgenden Teil dieses Tutorials werden wir unser letztes Beispiel erweitern und Möglichkeiten vorstellen, wie Ansichten angepasst werden können.

Flaschenvorlage

Beginnen wir und schreiben unsere erste Vorlage. Erstellen Sie eine Datei mit dem Namen hello.html im Vorlagenverzeichnis.

Schreiben Sie den folgenden Code in diese Datei und speichern Sie ihn.

Hello World!, from Software Testing Help.

{% for item in greetings %} {% if 'Morning' in item %}

{{item}}

{% else %}

{{item}}

{% endif %} {% endfor %}

Vorlage für Schleife

In der obigen Flask-Vorlage haben wir eine for-Schleife verwendet, um die Elemente der Liste zu durchlaufen. In unserem Controller oder Handler haben wir eine Liste mit Begrüßungswerten an die Vorlage übergeben. Innerhalb der Vorlage greifen wir mit der Syntax {{item}} auf jedes Element zu.

Vorlage wenn Block

Notieren Sie sich außerdem die Verwendung einer if-Anweisung. Hier testen wir den Artikel für Morgen und machen ihn fett und kursiv.

Lassen Sie uns nun einen Schritt weiter gehen, um mehr über die Konzepte von Kolbenformen zu erfahren.

Kolbenformen

Einer der wichtigsten Aspekte des Templating besteht darin, Eingaben von den Benutzern zu übernehmen und auf der Grundlage dieser Eingaben eine Backend-Logik zu schreiben. Lassen Sie uns ein Formular erstellen.

Wir verwenden Flask-Appbuilder SimpleFormView, um unser Formular zu rendern. Erstellen wir jedoch zuerst ein Formular. Zusätzlich zur Erstellung eines Formulars müssen wir den Befehl flask fab create-admin verwenden, um einen Administratorbenutzer zu erstellen.

Verwenden Sie daher den Befehl, bevor Sie den Entwicklungsserver starten, damit die anschließend erstellten Ansichten und Formulare mit einem angemeldeten Benutzer überprüft werden können. Wir melden uns mit dem Administrator an und überprüfen weiterhin, ob die erstellten Ansichten unter dem Menü sichtbar sind, wie in den Screenshots gezeigt.

Admin erstellen

Verwenden Sie den folgenden Befehl, um einen Administrator zu erstellen.

flask fab create-admin

Melden Sie sich mit den Administrator-Anmeldeinformationen an

  • Klicken Sie auf Anmelden, nachdem Sie zu http: // localhost: 8080 navigiert haben.
Melden Sie sich als Admin an
Melden Sie sich als Admin an
  • Melden Sie sich mit den im vorherigen Abschnitt erstellten Administratoranmeldeinformationen an.
Klicken Sie auf Login
Klicken Sie auf Anmelden
  • Klicken Sie auf Meine Formulare, um auf Ihre Ansichten zuzugreifen.
Klicken Sie auf das Menü
Klicken Sie auf das Menü

Hinweis: Sie können den letzten Schritt erst ausführen, nachdem Sie die Ansichten zum Standardmenü in der Navigationsleiste hinzugefügt haben.

Lassen Sie uns fortfahren und einige formularbasierte Ansichten erstellen.

Erstellen Sie eine Datei mit dem Namen forms.py im App-Verzeichnis und schreiben Sie den folgenden Code hinein.

from wtforms import Form, StringField from wtforms.validators import DataRequired from flask_appbuilder.fieldwidgets import BS3TextFieldWidget from flask_appbuilder.forms import DynamicForm class GreetingsForm(DynamicForm): greeting1 = StringField(('Morning'), description = ('Your morning Greeting'), validators = (DataRequired()), widget = BS3TextFieldWidget()) greeting2 = StringField(('Afternoon'), description = ('Your Afternoon Greeting'), validators = (DataRequired()), widget = BS3TextFieldWidget()) greeting3 = StringField(('Evening'), description = ('Your Evening Greeting'), widget = BS3TextFieldWidget()) greeting4 = StringField(('Night'), description = ('Your Night Greeting'), widget = BS3TextFieldWidget())

Wir haben ein Formular basierend auf dem DynamicForm von Flask-Appbuilder erstellt. Es gibt vier Textfelder. Wir erweitern unser Grußbeispiel. Von den vier Feldern sind zwei obligatorisch und zwei optional, da wir für die ersten beiden Begrüßungen die Werte für Validatoren erwähnt haben.

Erstellen wir nun eine Ansicht für dieses Formular. Schreiben Sie die folgenden Codezeilen in die Datei views.py.

from flask import render_template, flash from flask_appbuilder import SimpleFormView from app.forms import GreetingsForm class GreetingsView(SimpleFormView): form = GreetingsForm form_title = 'This is a Greetings form' message = 'Your Greetings are submitted' def form_get(self, form): form.greeting1.data = 'Your Morning Greeting' form.greeting2.data = 'Your Afternoon Greeting' form.greeting3.data = 'Your Evening Greeting' form.greeting4.data = 'Your Night Greeting' def form_post(self, form): flash(self.message, 'info') greetings = ( form.greeting1.data, form.greeting2.data, form.greeting3.data, form.greeting4.data, ) session('greetings')=greetings return redirect(url_for('HelloWorld.hello_greetings2'))

In unserer obigen Ansicht haben wir zwei Methoden namens form_get und form_post, um die Standardwerte in die Felder der Formulare zu füllen und die eingegebenen Werte zu lesen, sobald das Formular vom Browser gesendet wurde.

In der Begrüßungsansicht wird das Formular angezeigt (siehe Abbildung unten).

Grüße Form

Wir verwenden auch ein Flask-Sitzungsobjekt, um die Feldwerte in form_post zu speichern, damit wir in der entsprechenden neuen Ansicht, die wir schreiben möchten, darauf zugreifen können.

Ändern wir nun die HelloWorld-Klasse und fügen eine weitere Methode hinzu, um die Begrüßungen anzuzeigen. Wir werden es hello_greetings2 nennen.

class HelloWorld(BaseView): ## other methods @expose('/greetings2') def hello_greetings2(self): greetings = session('greetings') return render_template('hello.html', greetings=greetings)

In dieser Ansicht lesen wir die Werte aus dem Sitzungsobjekt und verwenden die Flask-Rendervorlage, um diese Werte im benutzerbezogenen HTML anzuzeigen. Beachten Sie, dass hello_greetings2 eine alternative Methode ist, um dieselbe Funktionalität wie hello_greetings zu erreichen.

Der einzige Unterschied besteht darin, dass wir mit hello_greetings2 die vom Benutzer eingegebenen Werte anzeigen. In hello_greetings haben wir keine Eingaben vom Benutzer vorgenommen und diese beim Schreiben der der jeweiligen Route zugeordneten Ansicht fest codiert.

Kolbenantwort

Es ist ziemlich selten, dass Sie die explizite Verwendung der Flask-Antwort im Code finden. Die Antwortklasse in Flask ist nur eine Unterklasse der Antwortklasse aus der Antwortklasse von Werkzueg, die wiederum die Klasse ResponseBase unterordnet.

Das Flask Response-Objekt wird intern von Flask gebildet, wenn wir eine return-Anweisung oder eine Methode wie render_template aufrufen.

Darüber hinaus können wir den Antwortcode und den Inhaltstyp bei Bedarf als Teil der return-Anweisung in unseren Ansichten anpassen, wie in der modifizierten HelloWorld-Ansicht unten gezeigt.

class HelloWorld(BaseView): ## other methods @expose('/greetings2') def hello_greetings2(self): greetings = session('greetings') return render_template('hello.json', greetings=greetings), 201, {'Content-Type' : 'application/json'

Die direkte Verwendung der Antwortklasse von Flask kann in einem Anwendungsfall behandelt werden, wenn wir den Inhalt streamen, anstatt den gesamten Inhalt sofort zurückzugeben, da die Dateigröße und die Netzwerkbandbreite Einschränkungen unterliegen.

Wir haben unten ein Beispiel für das Streaming des Inhalts von einer großen CSV gezeigt.

from flask import Response @app.route('https://cdn.softwaretestinghelp.com/largefile.csv') def send_large_csv(): '''A controller to stream the content of a large csv file''' def gen(): for row in iter_all_rows(): yield ','.join(row) + ' ' return Response(gen(), mimetype='text/csv')

Kolbenumleitung

Es ist nicht immer möglich, dass eine Anwendung die Antwort basierend auf den verschiedenen Anforderungen des Clients vordefiniert.

Wir verwenden Flask Redirect in Szenarien, in denen es möglich ist, den Inhalt bereitzustellen, der von den anderen Ansichten oder Speicherorten als Antwort auf eine Anfrage erfüllt werden kann. Wir verwenden Flask Redirect zusammen mit Abbruch mit den Standard-HTTP-Rückkehrcodes.

Zum Beispiel, Im folgenden Code haben wir Redirect mit HTTP-Code 301 verwendet und mit 401 abgebrochen.

from flask import Flask, redirect, url_for, request, abort app = Flask(__name__) @app.route('/') def index(): return render_template('log_in.html') # Log In template @app.route('/login',methods = ('POST', 'GET')) def login(): if request.method == 'POST': if request.form('username') == 'admin' : # if user is admin return redirect(url_for('success')), 301 else: abort(401) # stop processing else: return redirect(url_for('index')) # redirect to another view

Überprüfen Sie außerdem in GreetingsView, wo wir Flask Redirect und url_for verwendet haben, um eine Anforderung intern in eine andere Ansicht umzuleiten, indem Sie die Werte von Begrüßungen im Sitzungsobjekt speichern. Die Flask-Umleitung gibt immer ein Antwortobjekt mit dem Standard- oder dem angegebenen Statuscode an einen anderen Speicherort in der Anwendung zurück.

Flasche Debugtoolbar

Wir haben den interaktiven Debugger von Flask bereits in unserem letzten Tutorial vorgestellt. In diesem Tutorial machen wir einen weiteren Schritt, um das Debuggen der Flask-Anwendung zu vereinfachen. Nach der Installation wird die Flask Debug-Symbolleiste als Overlay über der Flask-Anwendung angezeigt.

Installieren Sie die Flask Debug-Symbolleiste.

pip install flask-debugtoolbar

Um die Debugtoolbar zu aktivieren, öffnen Sie die Datei __init__.py in unserem Projekt und ändern Sie den Code, indem Sie die folgenden Codezeilen hinzufügen.

from flask_debugtoolbar import DebugToolbarExtension app.debug = True toolbar = DebugToolbarExtension(app)

Bitte beachten Sie, dass die Flask-Debug-Symbolleiste nur im Debug-Modus aktiviert ist. Nach der Aktivierung werden Sie beim erneuten Laden Ihrer Anwendung zwei Dinge beachten.

# 1) Die Debug-Symbolleiste wird auf der rechten Seite des Browsers angezeigt. Klicken Sie darauf und erweitern Sie es, um die verschiedenen Funktionen der Symbolleiste anzuzeigen.

Debug-Symbolleistenaktivierung
Debug-Symbolleistenaktivierung

#zwei) Jedes Mal, wenn eine neue POST-Anforderung an die Anwendung gesendet wird, wird sie von der Symbolleiste abgefangen, damit wir die Variablen und die anderen Parameter überprüfen können, die sich auf das Debuggen der Anwendung beziehen.

Debug-Symbolleistenabschnitt
Debug-Symbolleistenabschnitt

Dieser Standardabschnitt kann mit der folgenden Konfiguration deaktiviert werden.

app.config('DEBUG_TB_INTERCEPT_REDIRECTS') = False Pytest Ergebnisse
Debug-Symbolleistenvariablen

Schreiben wir nun einige Tests, um unsere Ansichten auf die zusätzlichen Funktionen zu testen, die wir in der Beispielanwendung eingeführt haben.

Unix befiehlt Interviewfragen und Antworten für erfahrene

Deaktivieren Sie das Debuggen, bevor Sie mit dem Testen fortfahren, wie unten in __init__.py gezeigt. Alternativ können Sie die folgende Zeile auskommentieren.

app.debug = False

Testen der Kolbenanwendungsansichten

Wir müssen den Testcode organisieren, um ihn übersichtlicher zu gestalten. Erstellen Sie eine Datei mit dem Namen conftest.py im Stammverzeichnis und verschieben Sie die unten genannten Zeilen von test_hello.py in diese Datei.

from app import appbuilder import pytest @pytest.fixture def client(): ''' A pytest fixture for test client ''' appbuilder.app.config('TESTING') = True with appbuilder.app.test_client() as client: yield client

Pytest-Vorrichtungen werden zur Laufzeit von Pytest geladen. Diese Geräte sind verfügbar und werden mit allen Tests geteilt. Das Definieren einer conftest.py im Stammpfad eines Projekts wird als bewährte Methode angesehen, da pytest alle Module im Projekt erkennen kann, ohne einen expliziten PYTHONPATH anzugeben.

Fügen Sie einen weiteren Test für die Datei test_hello hinzu. Ein Beispieltest ist unten angegeben. Wir rufen die get-Methode des Client-Objekts auf und bestätigen den erwarteten Wert in den in resp.data gespeicherten Antwortdaten.

Ebenso können Sie weitere Tests schreiben, die auf verschiedene Ansichten verweisen. Wir werden weitere Tests in den folgenden Tutorials schreiben.

def test_greetings(client): ''' A test method to test view hello_greetings''' resp = client.get('/hello/greetings', follow_redirects=True) assert b'Good Morning' in resp.data

Führen Sie die Tests mit dem folgenden Befehl aus dem Stammverzeichnis des Projekts aus.

pytest -v

Der Testlauf erzeugt die Testergebnisse in der Konsole wie folgt:

Fehler im Pytest
Pytest Ergebnisse

Es gibt noch keine Fehler. Lassen Sie uns einen weiteren Test entwerfen, wie unten erwähnt.

def test_greetings2(client): ''' A test method to test view hello_greetings2 ''' resp = client.get('/hello/greetings2', follow_redirects=True) assert b'Good Morning' in resp.data

Dieser Test schlägt fehl, da wir in der HelloWorld-Klasse in der Datei views.py kein Nachrichtenattribut definiert haben.

Sobald Sie Tests mit pytest -v ausführen, werden wieder die Ergebnisse ähnlich dem unten gezeigten Bild auf der Konsole angezeigt.

Fehler im Pytest

Im folgenden Abschnitt werden die Schritte erläutert, die beim Ausführen der Tests auf einer CI / CD-Plattform ausgeführt werden müssen. Wir verwenden Git-Aktionen für dasselbe Projekt.

CI / CD mit Git-Aktionen

Wir speichern jetzt alle Änderungen in den Dateien und erstellen ein Commit, indem wir die Nachricht für dieses Tutorial geben. Nach dem Festschreiben im lokalen Repository ziehen wir Änderungen vom Remote-Ursprung mit dem Flag –rebase ab, um festzustellen, ob Konflikte mit den neuen Änderungen auf der Remote bestehen. Wir stützen uns, um die Geschichte konsistent zu halten.

Verwenden Sie den folgenden Befehl, um die Änderungen vom Remote-Ursprung abzurufen und zusammenzuführen. Übernehmen Sie jedoch Ihre Änderungen, bevor Sie die Änderungen von der Fernbedienung abrufen.

git pull origin master --rebase

Überprüfen Sie nun den lokalen Hauptzweig und führen Sie ihn mit dem Zweig Tutorial-2 zusammen. Veröffentlichen Sie diese Änderungen nach erfolgreicher Zusammenführung im Master des Ursprungs. Diese Aktion ruft die Builds auf Zielplattformen auf. Wir testen diesen Code unter Python3.7 und Python 3.8 unter Ubuntu.

Fazit

In diesem Tutorial haben wir gesehen, wie Vorlagen im Flask-Framework funktionieren. Wir haben die Schritte zum Erstellen und Rendern von Kolbenvorlagen mit benutzerdefinierten Werten unter Verwendung von Variablen und Ausdrücken beschrieben.

Wir haben auch Beispiele für eine vordefinierte Ansicht BaseView des Flask Appbuilder-Plugins gesehen. Diese Ansicht kann von Flask-Entwicklern problemlos in Unterklassen unterteilt werden, um benutzerdefinierte Ansichten zu erstellen.

Bisher behandelte Konzepte helfen den Lesern, mit dem Flask ohne Datenbank-Backend schnell statische und dynamische Websites zu erstellen. Im nächsten Lernprogramm werden wir erklären, wie Sie mit ModelView Daten von und zu den Datenbanken lesen und schreiben, wenn wir das Konzept der Verwendung von Datenbanken mit Flask durchgehen.

=> Lesen Sie die Easy Flask Training Series durch

Literatur-Empfehlungen

^