Flask
Le routage

Itinéraires de base

Les itinéraires dans Flask peuvent être définis à l'aide du décorateur de route de l'instance d'application Flask:

app = Flask(__name__)

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

Le décorateur de route prend une chaîne qui correspond à l'URL. Lorsqu'une demande d'URL correspondant à cette chaîne est reçue par l'application, la fonction décorée (également appelée fonction de vue ) est appelée. Donc, pour un itinéraire à propos, 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 dans Django.

Vous pouvez également définir des règles de variable pour extraire les valeurs de segment d'URL en 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 de variable est dans le dernier segment de l'URL. Quelle que soit la valeur get_blog_post dans le dernier segment de l'URL, elle sera transmise à la fonction de vue ( get_blog_post ) en tant post_id paramètre post_id . Donc, une requête à /blog/posts/42 récupérera (ou tentera de récupérer) l’article du blog avec un identifiant de 42.

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

@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 None pour le post_id dans get_blog_post . Lorsque le premier itinéraire est mis en correspondance, aucune valeur ne sera transmise à 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 à 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 converti en entier, l'application renvoie une erreur 404. C'est 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 également être configurées pour accepter les méthodes HTTP. Le décorateur de route utilise un argument de mot-clé de 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 nouvel article de blog et que nous voulions retourner le code HTML de la requête GET et analyser les données de 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 lorsque vous utilisez l'argument du mot-clé methods , vous devez être explicite sur les méthodes HTTP à accepter. Si nous n'avions listé que POST , la route ne répondrait plus aux requêtes GET et renverrait une erreur 405.

Catch-all route

Il peut être utile d’avoir une vue d'ensemble où vous manipulez vous-même une logique complexe en fonction du chemin. Cet exemple utilise deux règles: La première règle attrape spécifiquement / et la seconde règle des chemins arbitraires avec le convertisseur de path intégré. Le convertisseur de path correspond à n'importe quelle chaîne (y compris les barres obliques) Voir Règles variables des flacons

@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/'

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 les methods argument de la route() décorateur.

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 noeud final 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'