Routage Flask

Le routage est l'une des fonctionnalités principales des frameworks web ; il détermine quelle URL est traitée par quelle fonction.

Le routage Flask est un mécanisme dans les applications web qui associe les URL à des fonctions Python.

Le routage Flask est une partie essentielle de l'application Flask ; il est utilisé pour gérer les requêtes pour différentes URL et déléguer le traitement des requêtes aux fonctions de vue correspondantes.

Ce qui suit est une description détaillée du routage Flask, incluant les définitions de route, les paramètres, les méthodes et les règles.

Routage de base

Utilisation@app.route()Le décorateur lie le chemin d'URL à la fonction de vue :

Exemple

from flask import Flask

app = Flask(__name__)

# Lier le chemin racine "/"
@app.route("/")
def index():
    return "Ceci est la page d'accueil"

# Lier le chemin "/hello"
@app.route("/hello")
def hello():
    return "Hello, EXAMPLE!"

# Différents chemins correspondent à différentes fonctions
@app.route("/about")
def about():
    return "About this site"

Visitezhttp://127.0.0.1:5000/hellolorsque Flask appelle la fonctionhello().

Visitezhttp://127.0.0.1:5000/aboutlorsque Flask appelle la fonctionabout().

Règles des variables

Dans les applications réelles, les URL contiennent souvent des parties dynamiques, telles que des identifiants d'utilisateur, des titres d'articles, etc.

Flask utilisevariable_name>La syntaxe définit des parties dynamiques dans l'URL, et les paramètres correspondants sont automatiquement transmis à la fonction de vue.

Variable de chaîne (type par défaut)

Lorsqu'aucun type n'est spécifié, la variable est par défaut une chaîne et correspond à tout sauf une barre oblique./Tout caractère autre que :

Exemple

# <username> est une variable dynamique ; Flask transmet sa valeur à la fonction de vue en tant que paramètre nommé
@app.route("/user/<username>")
def show_user(username):
    # Remarque : username peut contenir des scripts malveillants ; en production, un échappement est requis
    return f"<h1>User: {username}</h1>"

# Test :
# /user/example → la page affiche "User: example"
# /user/EXAMPLE → la page affiche "User: EXAMPLE"

Convertisseurs de type

Flask fournit plusieurs convertisseurs intégrés, via la spécification de syntaxe<type:variable_name>:

Convertisseur Description URL d'exemple Résultat de correspondance
string Par défaut, accepte le texte qui ne contient pas / /user/example username = "example"
int Entier positif /post/42 post_id = 42
float Flottant positif /price/19.99 price = 19.99
path Accepte les chaînes contenant / /file/a/b/c.txt filepath = "a/b/c.txt"
uuid Chaîne au format UUID /item/550e8400-e29b-41d4-a716-446655440000 item_id = UUID string

Exemple

# convertisseur int : seuls les chiffres peuvent correspondre ; /post/abc renvoie 404
@app.route("/post/<int:post_id>")
def show_post(post_id):
    # post_id est de type int, pas string
    return f"<h1>Article #{post_id}</h1>"

# convertisseur path : peut correspondre aux chemins contenant /
@app.route("/file/<path:filepath>")
def show_file(filepath):
    return f"<p>Chemin du fichier : {filepath}</p>"

# convertisseur float : correspond aux nombres à virgule flottante
@app.route("/price/<float:amount>")
def show_price(amount):
    return f"<p>Prix : ¥{amount}</p>"

# convertisseur uuid : n'accepte que le format UUID standard
@app.route("/item/<uuid:item_id>")
def show_item(item_id):
    return f"<p>ID du produit: {item_id}</p>"

Les convertisseurs n'effectuent pas seulement une validation de type, mais convertissent aussi automatiquement les valeurs correspondantes en types Python correspondants. Par exemple<int:post_id>Ce qui est transmis à la fonction de vue estintau lieu destr。

Comportement de redirection de la barre oblique finale

à la fin de l'URL/Cela a un impact direct sur le comportement de correspondance des routes, et beaucoup de débutants sont déroutés par cela.

Exemple

# Règle 1 : se termine par / — semblable à un répertoire
# L'accès à /projects redirige automatiquement en 308 vers /projects/
@app.route("/projects/")
def projects():
    return "Page de la liste des projets"

# Règle 2 : Ne se termine pas par / — semblable à un fichier
# L'accès à /about/ renvoie 404 Not Found
@app.route("/about")
def about():
    return "Page À propos"
Définition de route Visitez /projects Visitez /projects/
@app.route("/projects/") Redirection 308 vers /projects/ Réponse normale
@app.route("/about") Réponse normale 404 Not Found

Cette conception aide au SEO : elle garantit que le même contenu n'a qu'une seule URL canonique, empêchant les moteurs de recherche d'indexer deux fois la même page.

Construction d'URL — url_for

url_for()est la fonction de génération d'URL intégrée de Flask, qui génère l'URL correspondante en fonction du nom de la fonction de vue.

Cela présente de nombreux avantages par rapport aux chaînes d'URL codées en dur :

  • Si la route d'URL est modifiée ultérieurement, toutes les URL générées viaurl_forsont automatiquement mises à jour
  • Gère automatiquement l'échappement des caractères spéciaux
  • Le chemin généré est toujours un chemin absolu

Exemple

from flask import Flask, url_for

app = Flask(__name__)

@app.route("/")
def index():
    return "Accueil"

@app.route("/login")
def login():
    return "Page de connexion"

@app.route("/user/<username>")
def profile(username):
    return f"Profil de {username}"

# Utiliser test_request_context() pour simuler un contexte de requête
# Cela permet à url_for() de générer correctement des URL
with app.test_request_context():
    print(url_for("index"))                    # Sortie /
    print(url_for("login"))                    # Sortie /login
    print(url_for("login", next="/"))          # Sortie /login?next=%2F
    print(url_for("profile", username="example"))  # Sortie /user/example

url_for()Le premier paramètre est le nom de la fonction de vue (note : il s'agit du nom de la fonction, et non du chemin d'URL).

Si l'URL contient des variables dynamiques, passez les valeurs correspondantes en tant qu'arguments nommés.

Les paramètres inconnus supplémentaires sont automatiquement concaténés à la chaîne de requête.

Méthodes HTTP

Par défaut, la route ne répond qu'à la requêteGET.

Grâce àmethods, le paramètre peut spécifier les méthodes HTTP autorisées :

Exemple

from flask import Flask, request

app = Flask(__name__)

# La même URL répond aux requêtes GET et POST
@app.route("/login", methods=["GET", "POST"])
def login():
    # Déterminer le type de requête actuel à l'aide de request.method
    if request.method == "POST":
        # Gérer la soumission du formulaire de connexion (exécuté lors d'une requête POST)
        username = request.form.get("username")
        return f"<h1>Bon retour, {username} !</h1>"
    else:
        # Afficher le formulaire de connexion (exécuté lors d'une requête GET)
        return """
        <form method="post">
<input type="text" name="username" placeholder="Nom d'utilisateur">
<input type="submit" value="Connexion">
        </form>
        """

décorateur de méthode raccourci

Flask fournit des décorateurs raccourcis pour les méthodes HTTP courantes afin de rendre le code plus clair :

Exemple

# Équivalent à @app.route("/login", methods=["GET"])
@app.get("/login")
def login_form():
    return "<form>...</form>"

# Équivalent à @app.route("/login", methods=["POST"])
@app.post("/login")
def login_submit():
    return "Connexion réussie"

# Prend également en charge @app.put(), @app.delete(), @app.patch()
@app.delete("/post/<int:post_id>")
def delete_post(post_id):
    # API pour supprimer un article
    return f"Article {post_id} supprimé"
Décorateurs pratiques Syntaxe équivalente Utilisation typique
@app.get("/path") @app.route("/path", methods=["GET"]) Récupérer des données, afficher la page
@app.post("/path") @app.route("/path", methods=["POST"]) Créer des données, soumettre le formulaire
@app.put("/path") @app.route("/path", methods=["PUT"]) Mettre à jour des données (remplacement complet)
@app.delete("/path") @app.route("/path", methods=["DELETE"]) Supprimer des données
@app.patch("/path") @app.route("/path", methods=["PATCH"]) Mettre à jour des données (mise à jour partielle)

Gère automatiquementSi la route définitGETcomme méthode, Flask ajoute automatiquement la prise en charge deHEADPrise en charge des méthodes. De plusOPTIONSLes méthodes sont généralement gérées automatiquement.

Lier plusieurs routes en même temps

La même fonction de vue peut être liée à plusieurs routes :

Exemple

# Deux URL différentes pointent vers la même fonction de vue
@app.route("/hello")
@app.route("/hello/<name>")
def greet(name=None):
    # name a une valeur par défaut de None ; lors de la visite de /hello, name est None
    if name is None:
        return "<h1>Hello, World!</h1>"
    return f"<h1>Hello, {name}!</h1>"

Visitez/hellolorsquenameutilise la valeur par défautNone, en visitant/hello/examplelorsquenameest"example"。

autres extensions