Python Language
Flaska

Introduktion

Syntax

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

Det grundläggande

Följande exempel är ett exempel på en basserver:

# 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()

Att köra detta skript (med alla rätt beroenden installerade) bör starta en lokal server. Värden är 127.0.0.1 allmänt känd som localhost . Denna server körs som standard på port 5000 . Öppna din webserver genom att öppna en webbläsare och ange URL: n localhost:5000 eller 127.0.0.1:5000 (ingen skillnad). För närvarande är det bara din dator som har åtkomst till webbservern.

app.run() har tre parametrar, värd , port och felsökning . Värdet är som standard 127.0.0.1 , men om du ställer in detta till 0.0.0.0 gör din webbserver tillgänglig från alla enheter i ditt nätverk med din privata IP-adress i URL: n. porten är som standard 5000 men om parametern är inställd på port 80 kommer användare inte att behöva ange ett portnummer eftersom webbläsare använder port 80 som standard. När det gäller felsökningsalternativet hjälper det under utvecklingsprocessen (aldrig i produktion) att ställa in denna parameter till True, eftersom din server kommer att starta om när ändringar görs i ditt Flask-projekt.

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

Routing-URL: er

Med Flask görs URL-routing traditionellt med dekoratörer. Dessa dekoratörer kan användas för statisk routing, samt för att dirigera URL: er med parametrar. För följande exempel kan du föreställa dig att detta Flask-skript kör webbplatsen 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"

Med den sista rutten kan du se att med tanke på en URL med / användare / och profilnamnet kan vi returnera en profil. Eftersom det skulle vara fruktansvärt ineffektivt och rörigt att inkludera en @app.route() för varje användare, erbjuder Flask att ta parametrar från URL:

@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-metoder

De två vanligaste HTTP-metoderna är GET och POST . Kolven kan köra annan kod från samma URL beroende på vilken HTTP-metod som används. Till exempel i en webbtjänst med konton är det mest bekvämt att dirigera inloggningssidan och inloggningsprocessen via samma URL. En GET-begäran, samma som görs när du öppnar en URL i din webbläsare ska visa inloggningsformuläret, medan en POST-begäran (med inloggningsdata) ska behandlas separat. En rutt skapas också för att hantera metoden DELETE och PUT HTTP.

@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"

För att förenkla koden lite kan vi importera request från kolven.

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"

För att hämta data från POST-begäran måste vi använda 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"]

Filer och mallar

Istället för att skriva in vår HTML-markering i return-uttalandena kan vi använda render_template() -funktionen:

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)

Det här använder vår about-us.html . För att säkerställa att vår ansökan kan hitta den här filen måste vi organisera vår katalog i följande format:

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

Det viktigaste av allt är att referenser till dessa filer i HTML måste se ut så här:

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

vilket leder applikationen för att leta efter about-style.css i mappen stilar under den statiska mappen. Samma sökvägsformat gäller alla referenser till bilder, stilar, skript eller filer.

Jinja Templating

I likhet med Meteor.js integreras Flask väl med front-end-templating-tjänster. Flaskan använder som standard Jinja Templating. Mallar tillåter små kodavsnitt att användas i HTML-filen, till exempel villkor eller slingor.

När vi gör en mall överförs eventuella parametrar utöver mallfilnamnet till HTML-templattjänsten. Följande rutt passerar användarnamnet och det sammanfogade datumet (från en funktion någon annanstans) till HTML.

@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)

När denna mall återges kan den använda variablerna som skickas till den från render_template() -funktionen. Här är innehållet i 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>

Följande avgränsare används för olika tolkningar:

• {% ... %} anger ett uttalande
• {{ ... }} anger ett uttryck där en mall matas ut
• {# ... #} anger en kommentar (ingår inte i mallutgången)
• {# ... ## antyder att resten av raden ska tolkas som ett uttalande

Begäran-objektet

request ger information om begäran som gjordes till rutten. För att använda detta objekt måste det importeras från kolvmodulen:

from flask import request

URL-parametrar

I tidigare exempel request.method och request.form , men vi kan också använda egenskapen request.args att hämta en ordlista med nycklar / värden i URL-parametrarna.

@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"

För att korrekt autentisera i detta sammanhang skulle följande URL behövas (ersätta användarnamnet med vilket användarnamn som helst:

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

Filuppladdningar

Om en filöverföring var en del av det skickade formuläret i en POST-begäran, kan filerna hanteras med hjälp av request :

@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

Småkakor

Begäran kan också innehålla kakor i en ordlista som liknar URL-parametrarna.

@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")