Python Language
Flasche

Einführung

Syntax

• @ app.route ("/ urlpath", method = ["GET", "POST", "DELETE", "PUTS", "HEAD", "OPTIONS"])
• @ app.route ("/ urlpath / <param>", method = ["GET", "POST", "DELETE", "PUTS", "HEAD", "OPTIONS"])

Die Grundlagen

Das folgende Beispiel ist ein Beispiel für einen Basis-Server:

# Imports the Flask class
from flask import Flask
# Creates an app and checks if its the main or imported
app = Flask(__name__)

# Specifies what URL triggers hello_world()
@app.route('/')
# The function run on the index route
def hello_world():
    # Returns the text to be displayed
    return "Hello World!"

# If this script isn't an import
if __name__ == "__main__":
    # Run the app until stopped
    app.run()

Beim Ausführen dieses Skripts (mit allen richtigen Abhängigkeiten installiert) sollte ein lokaler Server gestartet werden. Der Host ist 127.0.0.1 allgemein als localhost bezeichnet . Dieser Server wird standardmäßig auf Port 5000 ausgeführt . Um auf Ihren Webserver zuzugreifen, öffnen Sie einen Webbrowser und geben Sie die URL localhost:5000 oder 127.0.0.1:5000 (kein Unterschied). Derzeit kann nur Ihr Computer auf den Webserver zugreifen.

app.run() verfügt über die drei Parameter host , port und debug . Der Host ist standardmäßig 127.0.0.1 0.0.0.0 Sie diesen 0.0.0.0 auf 0.0.0.0 wird Ihr Webserver von jedem Gerät in Ihrem Netzwerk aus über Ihre private IP-Adresse in der URL erreichbar. Der Port ist standardmäßig 5000, aber wenn der Parameter auf Port 80 , müssen Benutzer keine Portnummer angeben, da Browser standardmäßig Port 80 verwenden. Bei der Debug-Option ist es hilfreich, diesen Parameter während des Entwicklungsprozesses (niemals in Produktion) auf "True" zu setzen, da Ihr Server neu startet, wenn Änderungen an Ihrem Flask-Projekt vorgenommen werden.

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=80, debug=True)

Routing-URLs

Mit Flask wird das URL-Routing traditionell mit Dekoratoren durchgeführt. Diese Dekoratoren können für statisches Routing sowie für Routing-URLs mit Parametern verwendet werden. Stellen Sie sich für das folgende Beispiel vor, dass dieses Flask-Skript die Website www.example.com .

@app.route("/")
def index():
    return "You went to www.example.com"

@app.route("/about")
def about():
    return "You went to www.example.com/about"

@app.route("/users/guido-van-rossum")
    return "You went to www.example.com/guido-van-rossum"

Mit dieser letzten Route können Sie feststellen, dass bei Angabe einer URL mit / users / und dem Profilnamen ein Profil zurückgegeben werden kann. Da es @app.route() ineffizient und chaotisch wäre, für jeden Benutzer ein @app.route() , bietet Flask an, Parameter aus der URL zu übernehmen:

@app.route("/users/<username>")
def profile(username):
    return "Welcome to the profile of " + username

cities = ["OMAHA", "MELBOURNE", "NEPAL", "STUTTGART", "LIMA", "CAIRO", "SHANGHAI"]

@app.route("/stores/locations/<city>")
def storefronts(city):
    if city in cities:
        return "Yes! We are located in " + city
    else:
        return "No. We are not located in " + city

HTTP-Methoden

Die zwei häufigsten HTTP-Methoden sind GET und POST . Flask kann abhängig von der verwendeten HTTP-Methode unterschiedlichen Code von derselben URL ausführen. In einem Webservice mit Konten ist es zum Beispiel am bequemsten, die Anmeldeseite und den Anmeldevorgang über dieselbe URL weiterzuleiten. Eine GET-Anforderung, die auch beim Öffnen einer URL in Ihrem Browser erfolgt, sollte das Anmeldeformular anzeigen, während eine POST-Anforderung (mit Anmeldedaten) separat verarbeitet werden soll. Eine Route wird auch erstellt, um die HTTP-Methode DELETE und PUT zu verarbeiten.

@app.route("/login", methods=["GET"])
def login_form():
    return "This is the login form"
@app.route("/login", methods=["POST"])
def login_auth():
    return "Processing your data"
@app.route("/login", methods=["DELETE", "PUT"])
def deny():
    return "This method is not allowed"

Um den Code etwas zu vereinfachen, können wir das request aus der Flasche importieren.

from flask import request

@app.route("/login", methods=["GET", "POST", "DELETE", "PUT"])
def login():
    if request.method == "DELETE" or request.method == "PUT":
        return "This method is not allowed"
    elif request.method == "GET":
        return "This is the login forum"
    elif request.method == "POST":
        return "Processing your data"

Um Daten aus der POST-Anforderung abzurufen, müssen wir das request :

from flask import request
@app.route("/login", methods=["GET", "POST", "DELETE", "PUT"])
def login():
    if request.method == "DELETE" or request.method == "PUT":
        return "This method is not allowed"
    elif request.method == "GET":
        return "This is the login forum"
    elif request.method == "POST":
        return "Username was " + request.form["username"] + " and password was " + request.form["password"]

Dateien und Vorlagen

Anstatt unser HTML-Markup in die return-Anweisungen render_template() , können Sie die Funktion render_template() verwenden:

from flask import Flask
from flask import render_template
app = Flask(__name__)

@app.route("/about")
def about():
    return render_template("about-us.html")

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=80, debug=True)

Dazu wird unsere Vorlagendatei about-us.html . Um sicherzustellen, dass unsere Anwendung diese Datei finden kann, müssen wir unser Verzeichnis in folgendem Format organisieren:

- application.py
/templates
    - about-us.html
    - login-form.html
/static
    /styles
        - about-style.css
        - login-style.css
    /scripts
        - about-script.js
        - login-script.js

Am wichtigsten ist, dass Verweise auf diese Dateien im HTML-Code folgendermaßen aussehen:

<link rel="stylesheet" type="text/css", href="{{url_for('static', filename='styles/about-style.css')}}">

about-style.css wird die Anwendung about-style.css im about-style.css unter dem statischen Ordner nach " about-style.css zu suchen. Das gleiche Pfadformat gilt für alle Verweise auf Bilder, Stile, Skripts oder Dateien.

Jinja Templating

Ähnlich wie Meteor.js lässt sich Flask gut in Front-End-Templating-Services integrieren. Flask verwendet standardmäßig Jinja Templating. Mithilfe von Vorlagen können kleine Codefragmente in der HTML-Datei verwendet werden, z. B. Bedingungen oder Schleifen.

Wenn wir eine Vorlage rendern, werden alle Parameter außerhalb des Vorlagendateinamens an den HTML-Vorlagendienst übergeben. Die folgende Route wird den Benutzernamen und das Verbindungsdatum (von einer anderen Stelle) an den HTML-Code übergeben.

@app.route("/users/<username>)
def profile(username):
    joinedDate = get_joined_date(username) # This function's code is irrelevant
    awards = get_awards(username) # This function's code is irrelevant
    # The joinDate is a string and awards is an array of strings
    return render_template("profile.html", username=username, joinDate=joinDate, awards=awards)

Wenn diese Vorlage gerendert wird, kann sie die von der Funktion render_template() an sie übergebenen Variablen verwenden. Hier sind die Inhalte von profile.html :

<!DOCTYPE html>
<html>
    <head>
        # if username
            <title>Profile of {{ username }}</title>
        # else
            <title>No User Found</title>
        # endif
    <head>
    <body>
        {% if username %}
            <h1>{{ username }} joined on the date {{ date }}</h1>
            {% if len(awards) > 0 %}
                <h3>{{ username }} has the following awards:</h3>
                <ul>
                {% for award in awards %}
                    <li>{{award}}</li>
                {% endfor %}
                </ul>
            {% else %}
                <h3>{{ username }} has no awards</h3>
            {% endif %}
        {% else %}
            <h1>No user was found under that username</h1>
        {% endif %}
        {# This is a comment and doesn't affect the output #}
    </body>
</html>

Die folgenden Trennzeichen werden für verschiedene Interpretationen verwendet:

• {% ... %} bezeichnet eine Aussage
• {{ ... }} bezeichnet einen Ausdruck, in dem eine Vorlage ausgegeben wird
• {# ... #} kennzeichnet einen Kommentar (nicht in der Vorlagenausgabe enthalten)
• {# ... ## impliziert, dass der Rest der Zeile als Anweisung interpretiert werden soll

Das Anforderungsobjekt

Das request liefert Informationen zu der Anforderung, die an die Route gestellt wurde. Um dieses Objekt verwenden zu können, muss es aus dem Flaschenmodul importiert werden:

from flask import request

URL-Parameter

In vorherigen Beispielen wurden request.method und request.form verwendet. Wir können jedoch auch die Eigenschaft request.args , um ein Wörterbuch der Schlüssel / Werte in den URL-Parametern abzurufen.

@app.route("/api/users/<username>")
def user_api(username):
    try:
        token = request.args.get("key")
        if key == "pA55w0Rd":
            if isUser(username): # The code of this method is irrelevant
                joined = joinDate(username) # The code of this method is irrelevant
                return "User " + username + " joined on " + joined
            else:
                return "User not found"
        else:
            return "Incorrect key"
    # If there is no key parameter
    except KeyError:
        return "No key provided"

Um sich in diesem Zusammenhang korrekt zu authentifizieren, ist die folgende URL erforderlich (Ersetzung des Benutzernamens durch einen beliebigen Benutzernamen):

www.example.com/api/users/guido-van-rossum?key=pa55w0Rd

Datei-Uploads

Wenn ein Dateiupload Teil des übermittelten Formulars in einer POST-Anforderung war, können die Dateien mit dem request werden:

@app.route("/upload", methods=["POST"])
def upload_file():
    f = request.files["wordlist-upload"]
    f.save("/var/www/uploads/" + f.filename) # Store with the original filename

Kekse

Die Anfrage kann auch Cookies in einem Wörterbuch enthalten, die den URL-Parametern ähneln.

@app.route("/home")
def home():
    try:
        username = request.cookies.get("username")
        return "Your stored username is " + username
    except KeyError:
        return "No username cookies was found")