Python Language
Ballon

Introduction

Syntaxe

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

Les bases

L'exemple suivant est un exemple de serveur de 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'exécution de ce script (avec toutes les dépendances correctes installées) devrait démarrer un serveur local. L'hôte est 127.0.0.1 communément appelé localhost . Ce serveur s'exécute par défaut sur le port 5000 . Pour accéder à votre serveur Web, ouvrez un navigateur Web et entrez l'URL localhost:5000 ou 127.0.0.1:5000 (aucune différence). Actuellement, seul votre ordinateur peut accéder au serveur Web.

app.run() a trois paramètres, host , port et debug . L'hôte est par défaut 127.0.0.1 , mais si vous le définissez sur 0.0.0.0 , votre serveur Web sera accessible à partir de n'importe quel périphérique de votre réseau en utilisant votre adresse IP privée dans l'URL. le port est par défaut 5000 mais si le paramètre est défini sur le port 80 , les utilisateurs n'auront pas besoin de spécifier un numéro de port, car les navigateurs utilisent le port 80 par défaut. Comme pour l'option de débogage, pendant le processus de développement (jamais en production), il est utile de définir ce paramètre sur True, car votre serveur redémarrera lorsque des modifications seront apportées à votre projet Flask.

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

URL de routage

Avec Flask, le routage d'URL est traditionnellement effectué à l'aide de décorateurs. Ces décorateurs peuvent être utilisés pour le routage statique, ainsi que pour router les URL avec des paramètres. Pour l'exemple suivant, imaginez que ce script Flask exécute le site Web 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"

Avec ce dernier itinéraire, vous pouvez voir que, avec une URL avec / users / et le nom du profil, nous pourrions retourner un profil. Comme il serait horriblement inefficace et désordonné d’inclure un @app.route() pour chaque utilisateur, Flask propose de prendre les paramètres depuis l’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

Méthodes HTTP

Les deux méthodes HTTP les plus courantes sont GET et POST . Flask peut exécuter un code différent à partir de la même URL en fonction de la méthode HTTP utilisée. Par exemple, dans un service Web avec des comptes, il est plus pratique d'acheminer la page de connexion et le processus de connexion via la même URL. Une requête GET, identique à celle qui est effectuée lorsque vous ouvrez une URL dans votre navigateur, doit afficher le formulaire de connexion, tandis qu’une requête POST (contenant des données de connexion) doit être traitée séparément. Un itinéraire est également créé pour gérer les méthodes DELETE et 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"

Pour simplifier un peu le code, nous pouvons importer le paquet de request de flask.

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"

Pour récupérer des données de la demande POST, nous devons utiliser le package de 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"]

Fichiers et modèles

Au lieu de taper notre balise HTML dans les instructions de retour, nous pouvons utiliser la fonction 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)

Cela utilisera notre fichier de gabarit about-us.html . Pour que notre application puisse trouver ce fichier, nous devons organiser notre répertoire dans le format suivant:

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

Plus important encore, les références à ces fichiers dans le code HTML doivent ressembler à ceci:

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

qui dirigera l'application à rechercher about-style.css dans le dossier styles sous le dossier static. Le même format de chemin s'applique à toutes les références aux images, aux styles, aux scripts ou aux fichiers.

Jinja Templating

Semblable à Meteor.js, Flask s'intègre bien avec les services de gabarit frontaux. Flask utilise par défaut Jinja Templating. Les modèles permettent d'utiliser de petits extraits de code dans le fichier HTML, tels que les conditionnels ou les boucles.

Lorsque nous rendons un modèle, tous les paramètres au-delà du nom du fichier de modèle sont transmis au service de modélisation HTML. L'itinéraire suivant transmettra le nom d'utilisateur et la date jointe (d'une fonction ailleurs) dans le code 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)

Lorsque ce modèle est rendu, il peut utiliser les variables qui lui sont transmises depuis la fonction render_template() . Voici le contenu de 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>

Les délimiteurs suivants sont utilisés pour différentes interprétations:

• {% ... %} indique une déclaration
• {{ ... }} désigne une expression où un modèle est généré
• {# ... #} indique un commentaire (non inclus dans la sortie du modèle)
• {# ... ## implique que le reste de la ligne doit être interprété comme une déclaration

L'objet Request

L'objet request fournit des informations sur la requête qui a été effectuée sur l'itinéraire. Pour utiliser cet objet, il faut l'importer depuis le module flask:

from flask import request

Paramètres d'URL

Dans les exemples précédents, request.method et request.form ont été utilisés, mais nous pouvons également utiliser la propriété request.args pour récupérer un dictionnaire des clés / valeurs dans les paramètres de l'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"

Pour s'authentifier correctement dans ce contexte, l'URL suivante serait nécessaire (en remplaçant le nom d'utilisateur par un nom d'utilisateur quelconque:

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

Téléchargement de fichier

Si un téléchargement de fichier faisait partie du formulaire soumis dans une requête POST, les fichiers peuvent être gérés à l'aide de l'objet 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

Biscuits

La demande peut également inclure des cookies dans un dictionnaire similaire aux paramètres 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")