Wenn wir mit Microframeworks als Flask arbeiten , ist es standardmäßig nicht erforderlich, die Ansicht mit zusätzlichen Elementen anzuzeigen. Nur durch die Rückgabe des entsprechenden HTML- Codes können wir kohärente Daten erzielen.
Das Problem tritt auf, wenn unsere Anwendung zu wachsen beginnt und wir mehrere Ansichten haben. Die Wiederholung des Codes füllt unsere Anwendung mit Elementen, die wir wiederverwenden könnten, und das manuelle Ausführen bedeutet eine größere Arbeit. Um dieses Problem zu vermeiden, verfügen wir über Template-Engines , mit deren Hilfe wir HTML- Dateien wiederverwenden und dadurch die Codemenge reduzieren und die Lesbarkeit unseres Programms verbessern können.
Jinja2
Jinja2 ist eine vollständig in Python geschriebene Template-Engine, die nach dem Vorbild der Django- Template-Engine erstellt wurde. Auf diese Weise können wir Teile des HTML- Codes und den eigenen Code der Engine so platzieren, dass Beschriftungen eingefügt werden, die dann durch Daten aus unserer Anwendung ersetzt werden.
In der neuesten Version von Flask ist dieser Motor in der Installation enthalten, so dass seine Verwendung einfacher und schneller ist.
Erstellen Sie eine Ansicht auf die alte Art
Wir hatten darüber gesprochen, dass das Erstellen einer Ansicht in Flask so einfach wie das Drucken des HTML- Codes in der Funktion der gewünschten Route ist. Für diejenigen, die mit diesem Framework noch nicht vertraut sind, mag dies jedoch sehr verwirrend klingen.
Im folgenden Beispiel erstellen wir eine Ansicht, in der wir einen Parameter erhalten und im Ergebnis ausgeben. Das Interessante ist, dass dieser Parameter vom Benutzer eingegeben werden kann. Die Ansicht ist also bis zu einem bestimmten Punkt dynamisch. Lassen Sie uns den Code anzeigen und dann übergeben zur Erklärung:
aus dem Flaschenimport Flaschenapp = Flasche (__ Name __) @ app.route ('/') @ app.route ('/ welcome') @ app.route ('/ welcome / <name>') def welcome (name = None): name = name oder 'User' return '' '<html> <head> <title> Willkommen! </ title> </ head> <body> <h1> Hallo% s! </ h1> <p> Dies ist unser Ansicht in Flask erstellt! </ p> </ body> </ html> '' '% nombreif __name__ ==' __main__ ': app.run ()
Hier machen wir es sehr einfach: Zuerst importieren wir die Bibliotheken, die das Framework enthalten, dann definieren wir drei Schlüsselrouten. Alle führen uns zu derselben Funktion, die als Willkommen bezeichnet wird und einen Parameter erhält, der optional ist, wenn er nicht einfach empfangen wird wird im Programm ignoriert.
Dann erstellen wir in der Funktion unsere return-Anweisung und geben hier an, dass eine Zeichenfolge zurückgegeben wird , die den HTML-Code für die Ansicht enthält. Wenn wir dieses Programm ausprobieren, erhalten wir im Browser ein akzeptables Ergebnis.
Viele mögen sagen, dass dies sehr funktional ist, aber was passiert, wenn wir anstelle dieser leeren Seite CSS-Stile, JavaScript-Effekte oder andere Dinge integrieren möchten. Dann würde unser HTML-Code mehr Code benötigen und daher wäre alles zu kompliziert, was unsere Anwendung zur Hölle macht.
Erstellen Sie eine Ansicht mit Jinja2
Jetzt erstellen wir dieselbe Ansicht, verwenden jedoch die zu Beginn des Tutorials beschriebene Template-Engine. Um das Beispiel zu erreichen, müssen wir einige Vorbereitungen treffen. Diese haben mit der Struktur unseres Projekts zu tun, da wir Vorlagendateien verwenden müssen Es ist am besten, sie von der Anwendung in anderen Ordnern zu trennen und dabei unsere visuelle Schicht von der logischen Schicht und den Geschäftsregeln zu trennen.
Wenn wir dies wissen, müssen wir einen Ordner für unsere Vorlagen erstellen. Aus Konventionsgründen werden wir Vorlagen aufrufen. Wir müssen jedoch auch andere Dinge haben. Beispielsweise müssen wir einen Ordner haben, der als Modul dient, und wir werden ihn mit dem Namen der Ansicht aufrufen, die wir erstellen werden. Abgesehen davon, dass wir einige Dateien haben müssen, werden wir im folgenden Bild die vollständige Struktur sehen und dann zum entsprechenden Code gehen, damit alles funktioniert.
run.py
Mit dieser Datei können wir die Anwendung ausführen, daher der Name, den Sie im Allgemeinen auch als run.py bezeichnen können. Für die Zwecke dieses Lernprogramms geben wir jedoch einen Namen ein, der für die spanischsprachige Gemeinschaft verständlicher ist Code:
aus flasko import appapp.run (debug = True)
__init__.py
Dies ist die Datei, die sich im Stammverzeichnis der Anwendung befindet. Um festzustellen, was ausgeführt werden soll und welche Abhängigkeiten es gibt, definieren wir in dieser Datei auch, dass wir die Datei views.py des Willkommensordners verwenden, den wir haben Wie bereits erwähnt , kann dies einen beliebigen Namen haben, aber views.py ist eine Konvention, die uns dabei hilft, eine freundliche Bewerbung zu führen. Hier sollten wir Folgendes einfügen :
from flask import Flaskapp = Flask (__ name __) importiert flasko.bienvenido.views
welcome / __ init__.py
Diese Datei muss leer sein, da sie nur vorhanden sein muss, damit Flask diesen Ordner als Modul unserer Anwendung interpretiert.
Ansicht erstellen
Da wir die Basisdateien unserer Anwendung haben, ist es Zeit, die Ansicht zu erstellen und die Vorlage zu verwenden. Das erste, was wir tun werden, ist unsere Ansicht zu erstellen. Dies wird der vorherigen Ansicht sehr ähnlich sein, aber verbessert. Dazu müssen wir in der Datei views.py arbeiten und Folgendes platzieren:
aus flask import render_template, request von flasko import [email protected] ('/') @ app.route ('/ welcome') def welcome_web (): name = request.args.get ('name', 'User') return render_template ('index.html', name = name)
Das erste, was wir tun, ist, aus dem Framework die Bibliothek zu importieren, mit der wir die Vorlagen anzeigen können, und eine Bibliothek, um die Browseranforderungen zu verarbeiten.
Dann definieren wir die Routen, auf denen diese Ansicht angezeigt werden soll. In diesem Fall ist dies die Wurzel / und auch das Wort welcome .
Schließlich definieren wir unsere Begrüßungsfunktion , die dem Variablennamen die Parameter zuweist, die er von der Browseranforderung erhält, und geben dann die Funktion render_template zurück , die die Vorlage aufruft und als Parameter den Variablennamen übergibt , wo wir auch angeben der Name der Vorlage.
Erstellen Sie die Vorlage
Es ist an der Reihe, die Vorlage zu erstellen. Dies ist im Grunde eine Datei mit HTML- Inhalten und einigen Tags, die uns dabei helfen, Dynamik zu verleihen. Die zu ändernde Datei ist die index.html im Vorlagenordner. Sehen wir uns den Code an, den wir verwenden werden:
<html> <head> <title> Willkommen {{name}} </ title> </ head> <body> <h1> Hallo {{name}}! </ h1> <p> Wir verwenden Flask! </ p > </ body> </ html>
Dieser Code ist einfach, wir erstellen unseren grundlegenden HTML- Code und platzieren dort, wo der in der Ansicht generierte Inhalt angezeigt werden soll, einfach die Doppelschlüssel {{}} und den Namen des Parameters. Wenn die Anwendung ausgeführt wird, wird dieser Wert ersetzt mit dem Inhalt, den wir wollen. Wenn wir in der folgenden Abbildung sehen, werden wir erkennen, wie der Name, den wir als Parameter übergeben haben, durch die URL platziert wird:
Wir können nicht nur Parameter verwenden, sondern auch Python- Wörterbücher mit Daten erstellen, die aus einer Persistenzquelle stammen, z. B. einer Datenbank oder Ähnlichem. Auf diese Weise können wir mehr Daten platzieren.
Nachdem wir dieses Tutorial abgeschlossen haben, haben wir gelernt, die Vorlagen in mit Flask erstellten Anwendungen zu verwenden. Diese Arbeitsweise erspart uns Mühe und die Wiederholung von Code, insbesondere wenn wir uns auf die offizielle Dokumentation von Jinja2 verlassen , um das Beste aus der Vorlagen-Engine herauszuholen . Es ist sehr wichtig, eine Projektstruktur zu erstellen und die verschiedenen Dateitypen zu trennen, da wir auf diese Weise ein benutzerfreundliches Projekt für den Rest unseres Entwicklungsteams aufrechterhalten oder es in ein Code-Netzwerk wie GitHub hochladen möchten, um die Dateien gemeinsam zu nutzen Arbeit mit der Gemeinde gemacht.
