Routage

Itinéraires de base

Les routes dans Flask peuvent être définies à l’aide du décorateur “route” de l’instance d’application Flask :

app = Flask(__name__)

@app.route('/')
def index():
    return 'Hello Flask'

Le décorateur route prend une chaîne qui est l’URL à faire correspondre. Lorsqu’une demande d’URL correspondant à cette chaîne est reçue par l’application, la fonction décorée (également appelée fonction d’affichage) est invoquée. Donc, pour un itinéraire approximatif, nous aurions:

@app.route('/about')
def about():
    return 'About page'

Il est important de noter que ces routes ne sont pas des expressions régulières comme elles le sont dans Django.

Vous pouvez également définir des règles de variable pour extraire les valeurs de segment d’URL dans des variables :

@app.route('/blog/posts/<post_id>')
def get_blog_post(post_id):
    # look up the blog post with id post_id
    # return some kind of HTML

Ici, la règle variable se trouve dans le dernier segment de l’URL. Quelle que soit la valeur du dernier segment de l’URL, elle sera transmise à la fonction d’affichage (get_blog_post) en tant que paramètre post_id. Ainsi, une requête à /blog/posts/42 récupérera (ou tentera de récupérer) le billet de blog avec un identifiant de 42.

Il est également courant de réutiliser les URL. Par exemple, nous voulons peut-être que /blog/posts renvoie une liste de tous les articles de blog. Nous pourrions donc avoir deux routes pour la même fonction de vue :

@app.route('/blog/posts')
@app.route('/blog/posts/<post_id>')
def get_blog_post(post_id=None):
    # get the post or list of posts

Notez ici que nous devons également fournir la valeur par défaut de None pour le post_id dans get_blog_post. Lorsque le premier itinéraire est mis en correspondance, il n’y aura aucune valeur à transmettre à la fonction d’affichage.

Notez également que par défaut le type d’une règle de variable est une chaîne. Cependant, vous pouvez spécifier plusieurs types différents tels que int et float en préfixant la variable :

@app.route('/blog/post/<int:post_id>')

Les convertisseurs d’URL intégrés de Flask sont :

string | Accepts any text without a slash (the default).
int    | Accepts integers.
float  | Like int but for floating point values.
path   | Like string but accepts slashes.
any    | Matches one of the items provided
uuid   | Accepts UUID strings

Si nous essayons de visiter l’URL /blog/post/foo avec une valeur dans le dernier segment d’URL qui ne peut pas être convertie en entier, l’application renverra une erreur 404. Il s’agit de l’action correcte car il n’y a pas de règle avec /blog/post et une chaîne dans le dernier segment.

Enfin, les routes peuvent être configurées pour accepter également les méthodes HTTP. Le décorateur route prend un argument de mot clé methods qui est une liste de chaînes représentant les méthodes HTTP acceptables pour cette route. Comme vous l’avez peut-être supposé, la valeur par défaut est “GET” uniquement. Si nous avions un formulaire pour ajouter un nouveau billet de blog et que nous voulions renvoyer le code HTML pour la requête “GET” et analyser les données du formulaire pour la requête “POST”, la route ressemblerait à ceci :

@app.route('/blog/new', methods=['GET', 'POST'])
def new_post():
    if request.method == 'GET':
        # return the form
    elif request.method == 'POST':
        # get the data from the form values

La request se trouve dans le package flask. Notez que lors de l’utilisation de l’argument mot-clé methods, nous devons être explicites sur les méthodes HTTP à accepter. Si nous n’avions répertorié que POST, la route ne répondrait plus aux requêtes GET et renverrait une erreur 405.

Itinéraire fourre-tout

Il peut être utile d’avoir une vue fourre-tout où vous gérez vous-même la logique complexe en fonction du chemin. Cet exemple utilise deux règles : la première règle intercepte spécifiquement / et la deuxième règle intercepte des chemins arbitraires avec le convertisseur path intégré. Le convertisseur path correspond à n’importe quelle chaîne (y compris les barres obliques) Voir [Flask Variable-Rules] [1]

@app.route('/', defaults={'u_path': ''})
@app.route('/<path:u_path>')
def catch_all(u_path):
    print(repr(u_path))
    ...

c = app.test_client()
c.get('/')  # u_path = ''
c.get('/hello')  # u_path = 'hello'
c.get('/hello/stack/overflow/')  # u_path = 'hello/stack/overflow/'

[1] : http://flask.pocoo.org/docs/0.12/quickstart/#variable-rules “Flask Variable-Rules”

Méthodes de routage et HTTP

Par défaut, les routes ne répondent qu’aux requêtes “GET”. Vous pouvez modifier ce comportement en fournissant l’argument methods au décorateur route().

from flask import request

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        do_the_login()
    else:
        show_the_login_form()

Vous pouvez également mapper différentes fonctions sur le même point de terminaison en fonction de la méthode HTTP utilisée.

@app.route('/endpoint', methods=['GET'])
def get_endpoint():
    #respond to GET requests for '/endpoint'


@app.route('/endpoint', methods=['POST', 'PUT', 'DELETE'])
def post_or_put():
    #respond to POST, PUT, or DELETE requests for '/endpoint'
← Téléchargements de fichiers
Plans →