Flask-Projektstruktur

Wir werden mit dieser Erklärung lernen, wie man eine große Flask-Anwendung mit Hilfe des Blueprint-Ansatzes in Flask und Python strukturiert.

Strukturieren Sie eine große Flask-Anwendung mit Hilfe des Blueprint-Ansatzes in Flask und Python

Wir wissen, dass die Flask-Dokumentation über den Flask-Blueprint geschrieben hat. Dennoch ist es für Anfänger manchmal schwierig, die Struktur der Flask-Anwendung zu verstehen, indem sie nur die Flask-Dokumentation lesen.

Deshalb möchten wir es in einfachen Worten aufschlüsseln und erklären, wie man die Flask-Anwendung anhand der Flask-Klasse Blueprint strukturiert.

Um mit der Arbeit zu beginnen, erstellen wir eine virtuelle Umgebung und installieren einen Flask mit den folgenden Befehlen. Nach dem Erstellen der virtuellen Umgebung aktivieren wir diese und installieren das Flask-Paket.

python -m venv our_venv
.\our_venv\Scripts\Activate.ps1
pip install flask

Die Blaupause ermöglicht es uns, verschiedene Instanzen der Flask-Anwendung zu erstellen und einen Teil des Codes in den verschiedenen Paketen wiederzuverwenden, sodass wir sie nicht immer von Grund auf neu schreiben müssen.

Zuerst erstellen wir ein Verzeichnis namens app; Im Verzeichnis root erstellen wir eine Datei namens run.py. Innerhalb des App-Verzeichnisses erstellen wir dieses App-Verzeichnis, um ein Paket in Python zu erstellen und die Datei __init__.py zu erstellen.

Jetzt werden wir fortfahren und in der Datei __init__.py Flask importieren und die Funktion create_app() definieren, die die Anwendung erstellt. Jetzt erstellen wir die Instanz von Flask und speichern sie in der Variablen app wie diese app=Flask(__name__) und geben dann dieses Objekt zurück.

Jetzt müssen wir die Funktion create_app aus der App importieren, und wir möchten die Anwendung ausführen, wenn wir diese run.py-Datei ausführen. Dazu verwenden wir die folgende Syntax.

Beim Erstellen einer Anwendung erstellen wir verschiedene Komponenten, die zusammenarbeiten, um die Anwendung zu erstellen; wir können das innerhalb des app-Verzeichnisses machen. Jetzt erstellen wir im Verzeichnis app ein Verzeichnis namens main, und in diesem Verzeichnis main erstellen wir die Datei __init__.py, die daraus ein Paket macht.

Jetzt erstellen wir eine routes.py-Datei, und in dieser Datei importieren wir die Blueprint-Klasse aus dem Flask-Modul und geben unserem Blueprint einen Namen namens main und übergeben ihn __name__.

Im Grunde genommen können wir auf diese Weise die einfache Flask-Anwendung erstellen, so wie wir die Flask-Anwendung mit der Klasse Flask instanziieren.

main = Blueprint("main", __name__)

Jetzt erstellen wir eine Route für die Routing-Seite, definieren die Funktion Main_Page() und geben dann die Seite zurück.

Jetzt müssen wir in der Datei __init__.py, die sich im Verzeichnis app befindet, den Blueprint registrieren, also importieren wir main aus den app.main.routes, wo wir die Blueprint-Instanz erstellt haben. Dann registrieren wir als nächstes den Blueprint, also main, mit app.register_blueprint().

Wenn wir die Vorlagen in der normalen Flask-Anwendung hinzufügen, könnten wir auf die gleiche Weise ein Verzeichnis namens Vorlagen erstellen und dann HTML-Dateien in diesem Verzeichnis generieren. Wir können auch die Konfiguration der Flask-Anwendung steuern, was sehr einfach ist.

Innerhalb des root-Verzeichnisses können wir eine config.py-Datei erstellen, und innerhalb dieser Datei können wir eine Klasse namens Config erstellen, in der TESTING und dann DEBUG auf False gesetzt sind.

Wir können hier auch eine weitere Klasse namens Development erstellen, die von Config erben und DEBUG mit True überschreiben würde. Wir werden eine weitere Klasse namens TESTING definieren, die ebenfalls von Config erben wird; es wird die Eigenschaft TESTING gleich True haben.

Sie könnten viele Konfigurationen haben, aber wir möchten dies nur einfach machen, damit Sie verstehen, wie die Blueprints-Anwendung mithilfe von Konfigurationen konfiguriert wird.

Jetzt werden wir eine Variable namens config erstellen, die ein Wörterbuch sein wird, und dieses Wörterbuch wird die Klassen Development und TESTING als Wert dieser Schlüssel haben.

class Config(object):
    TESTING = False
    DEBUG = False


class Development(Config):
    DEBUG = True


class TESTING(Config):
    TESTING = True


config = {"development": Development, "testing": TESTING}

Wir gehen zurück in die Datei __init__.py und importieren das config-Wörterbuch aus der Config-Datei. Wir müssen app_config innerhalb der Funktion create_app() übergeben und die Entwicklung an dieses Argument übergeben.

Jetzt müssen wir die Flask-App mit app.config.from_object(config[app_config](/de/howto/python/dotenv-python/)) übergeben und diesen Code in den Funktionsblock schreiben. Jetzt werden wir [das dotenv-Paket] installieren, das nützlich ist, um .env-Dateien und -Variablen einzurichten, da sie in der gesamten Anwendung verwendet und einfach umgeschaltet werden können.

pip install python-dotenv

Jetzt werden wir auch eine .env-Datei erstellen und in dieser Datei die Flask-Umgebung von der Produktion auf die Entwicklung einstellen. Wir müssen dies nur wie den Code FLASK_ENV=development schreiben und speichern.

Wir können so viele Pakete erstellen, wie wir wollen, also können wir jetzt in das App-Verzeichnis gehen und ein auth-Paket erstellen, und anstelle dieses Pakets können Sie Ihre Anmeldungen und Ihre Abmeldung und vieles mehr haben. Wir können auch einen statischen Ordner erstellen und Ihre statischen Asserts wie in der normalen Flask-App in diesem Verzeichnis aufbewahren.

Jetzt führen wir diese ursprünglich erstellte run.py-Datei aus. Wir können sehen, dass sich die Umgebung derzeit eher im Entwicklungsmodus als im Produktionsmodus befindet und die App ordnungsgemäß funktioniert.

Dieser Blueprint-Ansatz hilft uns, die Bewerbung zu strukturieren, um sie viel übersichtlicher zu gestalten und eine umfangreichere Bewerbung zu verfassen.

Der Code der run.py-Datei:

from app import create_app

if __name__ == "__main__":
    create_app().run(debug=True)

Der Code der Datei __init__.py:

from flask import Flask
from config import config


def create_app(app_config="development"):
    app = Flask(__name__)
    app.config.from_object(config[app_config])
    from app.main.routes import main

    app.register_blueprint(main)
    return app

Der Code der routes.py-Datei:

from flask import Blueprint

main = Blueprint("main", __name__)


@main.route("/", methods=["GET"])
def Main_Page():
    return "Hi there!"

Jetzt sieht unsere Flask-Projektstruktur so aus: