Inhaltsverzeichnis
2 häufig verwendete Web-Frameworks in Python
3 Verwendung des Flask-Frameworks
3.1 Installation des Flask-Frameworks
3.3.4 Mehrere Routen an eine Ansichtsfunktion binden
3.3.5 Route zum Zugriff auf URL-Parameter
3.3.6 Dynamisches Routing mit Standardwerten
3.3.7 Dynamisches Routing mit unterschiedlichen Datentypen
1 Web-Framework
Ein Web Framework ist eine Reihe von Softwaretools, die den Entwicklungsprozess von Webanwendungen vereinfachen und beschleunigen sollen. Es bietet eine Reihe vorgefertigter Module, Funktionen, Klassen und Tools, um Entwicklern dabei zu helfen, funktionsreiche Webanwendungen einfacher zu erstellen und zu verwalten. Durch die Verwendung eines Web-Frameworks können Entwickler das Schreiben großer Mengen sich wiederholenden Codes von Grund auf vermeiden und sich auf die Geschäftslogik und Kernfunktionalität der Anwendung konzentrieren.
Die Funktionalität eines Webframeworks ist wie folgt:
Routing und URL-Verarbeitung: Web-Frameworks bieten in der Regel Routing-Funktionen, die es Entwicklern ermöglichen, unterschiedliche URLs entsprechenden Verarbeitungsfunktionen oder Ansichten zuzuordnen. Dadurch wird die URL-Struktur übersichtlicher und es können problemlos unterschiedliche Anfragen bearbeitet werden.
Template-Engine: Mit der Template-Engine können Entwickler HTML und dynamische Daten kombinieren, um dynamische Webseiten zu generieren. Sie stellen normalerweise bedingte Anweisungen, Schleifen, Variablenersetzung und andere Funktionen bereit, um Entwicklern dabei zu helfen, Seiteninhalte effektiv zu generieren.
Datenbankinteraktion: Web-Frameworks bieten häufig eine Datenbankabstraktionsschicht, die die Interaktion mit der Datenbank vereinfacht. Dies erleichtert Entwicklern die Durchführung von Datenbankabfragen, Einfügungen, Aktualisierungen und Löschvorgängen.
Formularverarbeitung: Webanwendungen müssen häufig von Benutzern übermittelte Formulardaten verarbeiten. Web-Frameworks bieten in der Regel Mechanismen zur Validierung von Formulardaten, zur Bearbeitung von Übermittlungen und zur Generierung von Antworten.
Sitzungsverwaltung: Viele Webanwendungen müssen den Sitzungsstatus des Benutzers verfolgen. Web-Frameworks bieten in der Regel Sitzungsverwaltungsfunktionen, sodass Entwickler Benutzersitzungen und -status einfach verwalten können.
Fördern Sie die Wiederverwendung von Code
2 häufig verwendete Web-Frameworks in Python
In Python stehen viele häufig verwendete Web-Frameworks zur Auswahl. Hier sind einige gängige Python-Web-Frameworks:
1. Flask: Flask ist ein flexibles Mikro-Webframework mit prägnanter Syntax und leistungsstarken Erweiterungsmöglichkeiten. Es eignet sich hervorragend zum Erstellen kleiner, leichter Anwendungen.
2. Django: Django ist ein Web-Framework mit vollem Funktionsumfang, das viele sofort einsatzbereite Funktionen wie Datenbank-ORM, Benutzerauthentifizierung, Caching usw. bietet. Das Designkonzept von Django besteht aus „lose gekoppelten“ Komponenten, wodurch der Entwicklungsprozess effizienter wird.
3. Pyramid: Pyramid ist ein leichtes Web-Framework, das auf Flexibilität und Skalierbarkeit setzt. Es verwendet einen Plug-in-ähnlichen Mechanismus, der es Entwicklern ermöglicht, dem Framework gezielt Funktionen hinzuzufügen oder daraus zu entfernen.
4. Bottle: Bottle ist ein kleines und benutzerfreundliches Webframework mit minimalen Abhängigkeiten und einer einzigen Quelldatei. Die Flasche eignet sich hervorragend zum Erstellen kleiner, schneller Anwendungen.
5. Tornado: Tornado ist ein leistungsstarkes Web-Framework, das nicht blockierende E/A und ereignisgesteuerte Methoden zur Bearbeitung von Anfragen verwendet. Tornado eignet sich für den Umgang mit Situationen mit hoher Parallelität, wie z. B. Chat-Anwendungen und Echtzeit-Daten-Push.
3 Verwendung des Flask-Frameworks
3.1 Installation des Flask-Frameworks
Flask basiert auf zwei externen Bibliotheken: Werkzeug und Jinja2. Werkzeug ist ein WSGI-Toolset und Jinja2 ist für das Rendern von Vorlagen verantwortlich. Dieser Artikel wird mit dem folgenden Befehl in der von Anconda erstellten virtuellen Umgebung installiert:
pip install flask
wie folgt
(venv) PS D:\python365> pip install flask
Collecting flask
Downloading flask-2.3.3-py3-none-any.whl (96 kB)
---------------------------------------- 96.1/96.1 kB 365.4 kB/s eta 0:00:00
Collecting importlib-metadata>=3.6.0
Downloading importlib_metadata-6.8.0-py3-none-any.whl (22 kB)
Requirement already satisfied: Jinja2>=3.1.2 in d:\python365\venv\lib\site-packages (from flask) (3.1.2)
Collecting colorama
Downloading colorama-0.4.6-py2.py3-none-any.whl (25 kB)
Requirement already satisfied: zipp>=0.5 in d:\python365\venv\lib\site-packages (from importlib-metadata>=3.6.0->flask) (3.16.2)
Requirement already satisfied: MarkupSafe>=2.0 in d:\python365\venv\lib\site-packages (from Jinja2>=3.1.2->flask) (2.1.3)
Installing collected packages: Werkzeug, itsdangerous, importlib-metadata, colorama, blinker, click, flask
Successfully installed Werkzeug-2.3.7 blinker-1.6.2 click-8.1.7 colorama-0.4.6 flask-2.3.3 importlib-metadata-6.8.0 itsdangerous-2.1.2
[notice] A new release of pip available: 22.3.1 -> 23.2.1
[notice] To update, run: python.exe -m pip install --upgrade pip
(venv) PS D:\python365>
3.2 Das erste Flask-Programm
Schreiben Sie nach Abschluss der Installation Ihr erstes Flask-Programm. Hier ist ein einfaches Flask-Programmbeispiel, das eine einfache Webanwendung erstellt und eine „Hallo, Flask!“-Nachricht zurückgibt, wenn auf eine bestimmte URL zugegriffen wird:
from flask import Flask
# 创建 Flask 应用实例
app = Flask(__name__)
# 定义路由和视图函数
@app.route('/')
def hello():
return "Hello, Flask!"
# 如果这个文件是作为主程序运行，则执行下面的代码
if __name__ == '__main__':
app.run(debug=True)
Die Ausgabe ist wie folgt:
Geben Sie im Browser die URL http://127.0.0.1:5000 wie folgt ein:
Der obige Code verwendet das Flask-Framework von Python, um eine einfache Webanwendung zu erstellen.
Zuerst müssen Sie die Flask-Bibliothek importieren. Erstellen Sie dann eine Flask-Anwendungsinstanz mit dem Namen des aktuellen Moduls als Parameter, d. h.
__name__.Als nächstes verwenden Sie den Dekorator,
@app.route('/')um die Route zu definieren, dh den URL-Pfad anzugeben. In diesem Beispiel stellt der Stammpfad „/“ die Standardseite der Anwendung dar.Definieren Sie dann eine Ansichtsfunktion
hello(), die aufgerufen wird, wenn der Benutzer auf den Stammpfad zugreift. Diese Funktion gibt eine Zeichenfolge „Hello, Flask!“ als Antwort an den Benutzer zurück.Führen Sie abschließend
app.run()die Anwendung über die Methode aus, starten Sie einen lokalen Server, warten Sie auf HTTP-Anfragen und geben Sie entsprechende Ergebnisse zurück. Einstellungendebug=Truekönnen den Debug-Modus aktivieren.Wenn Sie diese Datei als Hauptprogramm ausführen,
app.run()wird die Anweisung ausgeführt, die Anwendung gestartet und Debugging-Informationen an das Terminal ausgegeben.
3.3 Routenführung
In Flask wird Routing verwendet, um einen bestimmten URL-Pfad der entsprechenden Ansichtsfunktion zuzuordnen. Das Routing bestimmt, welche Ansichtsfunktion ausgeführt werden soll, um die Anfrage zu verarbeiten, wenn der Benutzer auf verschiedene URLs zugreift. Routen können mithilfe von Dekoratoren definiert werden @app.route().
Hier sind einige Beispiele für Routendefinitionen für verschiedene Situationen:
3.3.1 Grundlegendes Routing
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return "Welcome to the homepage!"
Wenn der Benutzer in diesem Beispiel auf den Stammpfad zugreift
/, wird die genannte Ansichtsfunktion aufgerufenindex()und gibt die Meldung „Willkommen auf der Homepage!“ zurück.
3.3.2 Dynamisches Routing
Sie können variable Abschnitte in Ihren Routen verwenden, um unterschiedliche Werte in der URL zu erfassen. Diese Variablen werden als Parameter an die Ansichtsfunktion übergeben.
@app.route('/user/<username>')
def show_user_profile(username):
return f"User: {username}"Wenn der Benutzer in diesem Beispiel auf /user/johndoeeinen Pfad wie zugreift, show_user_profile()wird die Ansichtsfunktion aufgerufen und die Parameter usernameerhalten Werte "johndoe".
3.3.3 HTTP-Methoden
Sie können unterschiedliche Anfragen verarbeiten, indem Sie unterschiedliche HTTP-Methoden angeben, z. B. GET, POST, PUT, DELETE usw.
@app.route('/submit', methods=['POST'])
def submit_form():
return "Form submitted successfully!"
In diesem Beispiel
/submitwird die Ansichtsfunktion nur aufgerufen, wenn der Benutzer mit der POST-Methode auf den Pfad zugreiftsubmit_form().
Gängige HTTP-Methoden und Anweisungen:
3.3.4 Mehrere Routen an eine Ansichtsfunktion binden
Sie können mehrere unterschiedliche Pfade an dieselbe Ansichtsfunktion binden, um noch mehr Zugriffsmöglichkeiten bereitzustellen.
@app.route('/')
@app.route('/home')
@app.route('/index')
def homepage():
return "Welcome to the homepage!"
Hier wird die Ansichtsfunktion unabhängig davon aufgerufen , ob der Benutzer auf den Root-Pfad oder
/zugreift ./home/indexhomepage()
3.3.5 Route zum Zugriff auf URL-Parameter
Sie können in der Ansichtsfunktion auf URL-Parameter zugreifen. Diese Parameter werden von Flask automatisch analysiert und an die Ansichtsfunktion übergeben.
from flask import request
@app.route('/profile')
def user_profile():
username = request.args.get('username')
return f"User profile: {username}"
Der Beispielcode definiert eine Route
/profile, die eine benannte Ansichtsfunktion aufruft, wenn ein Benutzer auf den Pfad zugreiftuser_profile(). In dieser Ansichtsfunktionrequestwird ein Objekt verwendet, umusernameden Wert des URL-Parameters abzurufen, und gibt dann eine Nachricht mit dem Benutzernamen zurück.
3.3.6 Dynamisches Routing mit Standardwerten
@app.route('/user/<username>/<int:age>')
def user_profile(username, age=18):
return f"User: {username}, Age: {age}"
In diesem Beispiel
agehat der Parameter den Standardwert 18. Das bedeutet, dass Sie/user/johndoeüber und nicht nur darauf zugreifen können/user/johndoe/25.
3.3.7 Dynamisches Routing mit unterschiedlichen Datentypen
@app.route('/item/<int:item_id>')
def get_item(item_id):
return f"Item ID: {item_id}"
Hier werden nur Werte vom Typ Ganzzahl abgeglichen
item_idund bei Zugriff als Ganzzahl 123 übergeben./item/123item_id
Dies sind einige Beispiele für Routendefinitionen für häufige Situationen. Durch die richtige Definition von Routen können Sie Webanwendungen erstellen, die logisch klar und leicht zugänglich sind. Beachten Sie, dass die Routendefinition @app.route()direkt unter dem Dekorator platziert werden sollte, gefolgt von der entsprechenden Ansichtsfunktionsdefinition.
3.4 Statische Dateien
In Flask beziehen sich statische Dateien auf Ressourcen, die nicht dynamisch generiert werden müssen, wie z. B. Stylesheets, JavaScript-Dateien, Bilder usw. Diese Dateien werden nicht bei jeder Anfrage vom Server generiert, sondern direkt an den Client-Browser zurückgegeben. Flask bietet spezielles Routing und Konfiguration für die Verarbeitung statischer Dateien.
staticStandardmäßig erstellt Flask einen Ordner mit dem Namen im Stammverzeichnis der Anwendung , um statische Dateien zu speichern. Sie können darin Unterordner erstellen, um verschiedene Arten statischer Ressourcen wie static/cssStylesheets und static/jsJavaScript-Dateien zu organisieren.
Hier sind die grundlegenden Schritte zum Umgang mit statischen Dateien in Flask:
staticErstellen Sie einen Ordner im Projektstammverzeichnis, um statische Dateien zu speichern. Darin können Sie Unterordner erstellen, um verschiedene Arten statischer Ressourcen zu organisieren, zum Beispielstatic/css,static/js.Verwenden Sie
url_for()die Funktion, um URLs für statische Dateien zu generieren. Diese Funktion generiert die richtige URL entsprechend der Konfiguration, um sicherzustellen, dass auf die statischen Dateien korrekt zugegriffen wird.
Hier ist ein einfaches Beispiel, das zeigt, wie mit statischen Dateien in Flask umgegangen wird:
from flask import Flask, render_template, url_for
app = Flask(__name__)
@app.route('/')
def index():
return render_template('index.html')
if __name__ == '__main__':
app.run()
In diesem Beispiel render_template('index.html')wird die Funktion zum Rendern einer Vorlage verwendet und möglicherweise müssen statische Dateien in die Vorlage geladen werden. Um beispielsweise ein Stylesheet in eine Vorlage zu laden:
<!DOCTYPE html>
<html>
<head>
<title>Flask Static Files</title>
<link rel="stylesheet" href="{
{ url_for('static', filename='css/style.css') }}">
</head>
<body>
<h1>Hello, Flask!</h1>
</body>
</html>
In diesem Beispiel
url_for('static', filename='css/style.css')wird die korrekte statische Datei-URL generiert.'static'Ist das standardmäßige statische Dateiverzeichnis in Flask'css/style.css'und ein Pfad relativ zu diesem Verzeichnis.Stellen Sie sicher, dass Sie in der Vorlage
url_for()URLs für statische Dateien generieren, damit in verschiedenen Umgebungen korrekt auf sie zugegriffen werden kann. Auf diese Weise können Sie statische Dateien effizient in Ihrer Flask-Anwendung bereitstellen.
3.5 Vorlage
In Flask werden Vorlagen verwendet, um dynamische Daten in HTML-Seiten zu rendern und so eine dynamische Generierung von Seiteninhalten zu erreichen. Flask integriert die Jinja2-Vorlagen-Engine, sodass Sie Python-Code in HTML einbetten können, um Daten darzustellen. Dieser Ansatz trennt die Geschäftslogik von der Schnittstelle und verbessert die Wartbarkeit des Codes.
Hier sind die grundlegenden Schritte zur Verwendung von Vorlagen in Flask:
Erstellen Sie im Stammverzeichnis des Projekts einen
templatesOrdner mit dem Namen, um Vorlagendateien zu speichern. Diese Vorlagendateien können die Jinja2-Syntax verwenden.Verwenden Sie die Funktion in der Ansichtsfunktion
render_template(), um die Vorlage zu rendern und die Daten zu übergeben.Verwenden Sie die Jinja2-Syntax, um dynamische Inhalte und Kontrollstrukturen in Vorlagen einzubetten.
Hier ist ein einfaches Beispiel, das zeigt, wie Vorlagen in Flask verwendet werden:
- Erstellen Sie einen
templatesOrdner mit dem Namen und eineindex.htmldarin benannte Vorlagendatei.
templates/index.htmlDokumentinhalt:
<!DOCTYPE html>
<html>
<head>
<title>Flask Template Example</title>
</head>
<body>
<h1>Hello, {
{ name }}!</h1>
<p>Today is {
{ date }}</p>
</body>
</html>
Erstellen Sie eine Flask-Anwendung, die render_template()Funktionen zum Rendern von Vorlagen und Übergeben von Daten verwendet.
from flask import Flask, render_template
import datetime
app = Flask(__name__)
@app.route('/')
def index():
current_date = datetime.datetime.now()
return render_template('index.html', name='Flask User', date=current_date)
if __name__ == '__main__':
app.run()
In diesem Beispiel
render_template('index.html', name='Flask User', date=current_date)wird die Vorlage gerendert und die Variablen undindex.htmlübergeben . In Vorlagen können Sie dynamische Inhalte einfügen. Besuchen Sie den Stammpfad Ihrer Anwendung in Ihrem Browser und Sie sollten die Seite mit der Aufschrift „Hallo, Flask-Benutzer!“ und dem aktuellen Datum sehen.namedate{ { variable_name }}Dies ist nur ein einfaches Beispiel für eine Flask-Vorlage. Sie können weitere Jinja2-Funktionen in der Vorlage verwenden, z. B. bedingte Anweisungen, Schleifen, Filter usw., um komplexere dynamische Seiten zu erstellen.