Python Language
fles

Invoering

Syntaxis

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

De basis

Het volgende voorbeeld is een voorbeeld van een basisserver:

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

Het uitvoeren van dit script (met alle juiste afhankelijkheden geïnstalleerd) zou een lokale server moeten opstarten. De host is 127.0.0.1 algemeen bekend als localhost . Deze server draait standaard op poort 5000 . Om toegang te krijgen tot uw webserver, opent u een webbrowser en voert u de URL localhost:5000 of 127.0.0.1:5000 (geen verschil). Momenteel heeft alleen uw computer toegang tot de webserver.

app.run() heeft drie parameters: host , poort en foutopsporing . De host is standaard 127.0.0.1 , maar als u dit instelt op 0.0.0.0 , is uw webserver toegankelijk vanaf elk apparaat in uw netwerk met uw privé-IP-adres in de URL. de poort is standaard 5000, maar als de parameter is ingesteld op poort 80 , hoeven gebruikers geen poortnummer op te geven, omdat browsers standaard poort 80 gebruiken. Wat de foutopsporingsoptie betreft, het helpt tijdens het ontwikkelingsproces (nooit in productie) om deze parameter op True in te stellen, omdat uw server opnieuw wordt opgestart wanneer wijzigingen in uw Flask-project worden aangebracht.

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

Routing URL's

Met Flask wordt URL-routering traditioneel gedaan met behulp van decorateurs. Deze decorateurs kunnen worden gebruikt voor statische routing, evenals routing-URL's met parameters. Stel je voor het volgende voorbeeld voor dat dit Flask-script de 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"

Met die laatste route kunt u zien dat we, gegeven een URL met / users / en de profielnaam, een profiel kunnen retourneren. Omdat het vreselijk inefficiënt en rommelig zou zijn om een @app.route() voor elke gebruiker op te nemen, biedt Flask aan om parameters uit de URL te halen:

@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

De twee meest voorkomende HTTP-methoden zijn GET en POST . Flask kan verschillende code van dezelfde URL uitvoeren, afhankelijk van de gebruikte HTTP-methode. In een webservice met accounts is het bijvoorbeeld het handigst om de aanmeldingspagina en het aanmeldingsproces via dezelfde URL te routeren. Een GET-verzoek, hetzelfde dat wordt gedaan wanneer u een URL in uw browser opent, moet het inlogformulier tonen, terwijl een POST-verzoek (met inloggegevens) afzonderlijk moet worden verwerkt. Er wordt ook een route gemaakt om de HTTP-methode DELETE en PUT af te handelen.

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

Om de code een beetje te vereenvoudigen, kunnen we het request uit de kolf importeren.

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"

Om gegevens uit het POST-verzoek op te halen, moeten we het 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"]

Bestanden en sjablonen

In plaats van onze HTML-opmaak in de render_template() typen, kunnen we de functie 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)

Dit maakt gebruik van ons sjabloonbestand about-us.html . Om ervoor te zorgen dat onze applicatie dit bestand kan vinden, moeten we onze map in de volgende indeling organiseren:

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

Het belangrijkste is dat verwijzingen naar deze bestanden in de HTML er als volgt uit moeten zien:

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

waardoor de toepassing naar about-style.css zoekt in de map stijlen onder de statische map. Hetzelfde padformaat is van toepassing op alle verwijzingen naar afbeeldingen, stijlen, scripts of bestanden.

Jinja Templating

Net als Meteor.js kan Flask goed worden geïntegreerd met front-end templating-services. Flask gebruikt standaard Jinja Templating. Met sjablonen kunnen kleine codefragmenten in het HTML-bestand worden gebruikt, zoals voorwaardelijke informatie of lussen.

Wanneer we een sjabloon weergeven, worden alle parameters buiten de naam van het sjabloonbestand doorgegeven aan de HTML-sjablonenservice. De volgende route geeft de gebruikersnaam en de verbindingsdatum (van een functie ergens anders) door in de 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)

Wanneer deze sjabloon wordt weergegeven, kan deze de variabelen gebruiken die aan de functie render_template() doorgegeven. Hier is de inhoud van 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>

De volgende scheidingstekens worden gebruikt voor verschillende interpretaties:

• {% ... %} geeft een verklaring aan
• {{ ... }} geeft een uitdrukking aan waar een sjabloon wordt uitgevoerd
• {# ... #} geeft een opmerking aan (niet inbegrepen in sjabloonuitvoer)
• {# ... ## betekent dat de rest van de regel als een verklaring moet worden geïnterpreteerd

Het verzoekobject

Het request object geeft informatie over het verzoek dat werd gedaan om de route. Om dit object te gebruiken, moet het worden geïmporteerd uit de kolfmodule:

from flask import request

URL-parameters

In vorige voorbeelden werden request.method en request.form gebruikt, maar we kunnen ook de eigenschap request.args gebruiken om een woordenboek op te halen met de sleutels / waarden in de URL-parameters.

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

Om in deze context correct te verifiëren, zou de volgende URL nodig zijn (de gebruikersnaam vervangen door een gebruikersnaam:

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

Bestandsuploads

Als een bestandsupload onderdeel was van het ingediende formulier in een POST-aanvraag, kunnen de bestanden worden verwerkt met behulp van het 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

koekjes

Het verzoek kan ook cookies bevatten in een woordenboek vergelijkbaar met de URL-parameters.

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