Python Language
Pallone

introduzione

Sintassi

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

Le basi

Il seguente esempio è un esempio di un server di base:

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

L'esecuzione di questo script (con tutte le giuste dipendenze installate) dovrebbe avviare un server locale. L'host è 127.0.0.1 comunemente noto come localhost . Questo server funziona di default sulla porta 5000 . Per accedere al tuo webserver, apri un browser web e inserisci l'URL localhost:5000 o 127.0.0.1:5000 (nessuna differenza). Attualmente, solo il tuo computer può accedere al webserver.

app.run() ha tre parametri, host , porta e debug . L'host è per impostazione predefinita 127.0.0.1 , ma impostandolo su 0.0.0.0 il server Web sarà accessibile da qualsiasi dispositivo sulla rete utilizzando l'indirizzo IP privato nell'URL. la porta è di default 5000 ma se il parametro è impostato sulla porta 80 , gli utenti non dovranno specificare un numero di porta in quanto i browser utilizzano la porta 80 per impostazione predefinita. Per quanto riguarda l'opzione di debug, durante il processo di sviluppo (mai in produzione) aiuta a impostare questo parametro su True, poiché il server si riavvierà quando verranno apportate modifiche al progetto Flask.

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

URL di instradamento

Con Flask, il routing degli URL viene tradizionalmente fatto utilizzando i decoratori. Questi decoratori possono essere utilizzati per il routing statico, oltre agli URL di routing con parametri. Per il seguente esempio, immagina che questo script di Flask stia eseguendo il sito 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"

Con quell'ultimo percorso, puoi vedere che dato un URL con / users / e il nome del profilo, potremmo restituire un profilo. Dal momento che sarebbe orribilmente inefficiente e disordinato includere un @app.route() per ogni utente, Flask offre di prendere parametri dall'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

Metodi HTTP

I due metodi HTTP più comuni sono GET e POST . Flask può eseguire codice diverso dallo stesso URL in base al metodo HTTP utilizzato. Ad esempio, in un servizio Web con account, è più conveniente instradare la pagina di accesso e la procedura di accesso attraverso lo stesso URL. Una richiesta GET, la stessa che viene eseguita quando si apre un URL nel browser deve mostrare il modulo di accesso, mentre una richiesta POST (che porta i dati di accesso) deve essere elaborata separatamente. Viene inoltre creata una route per gestire il metodo DELETE e 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"

Per semplificare un po 'il codice, possiamo importare il pacchetto di request dal pallone.

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"

Per recuperare i dati dalla richiesta POST, dobbiamo usare il pacchetto di 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"]

File e modelli

Invece di digitare il nostro markup HTML nelle istruzioni return, possiamo usare la funzione render_template() :

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)

Questo userà il nostro file modello about-us.html . Per garantire che la nostra applicazione possa trovare questo file, dobbiamo organizzare la nostra directory nel seguente formato:

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

Ancora più importante, i riferimenti a questi file nell'HTML devono essere come questi:

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

che dirigerà l'applicazione alla ricerca di about-style.css nella cartella styles nella cartella statica. Lo stesso formato di percorso si applica a tutti i riferimenti a immagini, stili, script o file.

Jinja Templating

Simile a Meteor.js, Flask si integra bene con i servizi di template front-end. Flask utilizza per impostazione predefinita Jinja Templating. I modelli consentono di utilizzare piccoli frammenti di codice nel file HTML come condizionali o loop.

Quando eseguiamo il rendering di un modello, tutti i parametri oltre il nome del file modello vengono passati al servizio di template HTML. Il seguente percorso passerà il nome utente e la data unita (da una funzione da qualche altra parte) nel codice 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)

Quando questo template è reso, può usare le variabili passate dalla funzione render_template() . Ecco i contenuti di 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>

I seguenti delimitatori sono usati per diverse interpretazioni:

• {% ... %} indica una dichiarazione
• {{ ... }} denota un'espressione in cui viene fornito un modello
• {# ... #} denota un commento (non incluso nell'output del modello)
• {# ... ## implica che il resto della riga debba essere interpretato come una dichiarazione

L'oggetto della richiesta

L'oggetto request fornisce informazioni sulla richiesta che è stata fatta al percorso. Per utilizzare questo oggetto, deve essere importato dal modulo flask:

from flask import request

Parametri URL

Negli esempi precedenti sono stati utilizzati request.method e request.form , tuttavia è anche possibile utilizzare la proprietà request.args per recuperare un dizionario delle chiavi / valori nei parametri URL.

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

Per autenticare correttamente in questo contesto, sarebbe necessario il seguente URL (sostituendo il nome utente con qualsiasi nome utente:

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

Upload di file

Se un caricamento di file faceva parte del modulo inviato in una richiesta POST, i file possono essere gestiti utilizzando l'oggetto 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

Biscotti

La richiesta può anche includere cookie in un dizionario simile ai parametri URL.

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