Requête et réponse Flask
Le cœur d'une application web est "recevoir des requêtes et renvoyer des réponses". Ce chapitre explique de manière complète comment lire les données de requête et construire divers types de réponses dans Flask.
Tous les exemples peuvent être directement exécutés et vérifiés dans le serveur de développement.
Objet de requête — request
Flask fournit toutes les informations de requête via un objet proxy global.requestToutes les informations de requête sont fournies.
Bien qu'il s'agisse d'un objet "global", Flask utilise en interne l'isolation de thread pour garantir que chaque requête dispose de ses propres données.
Exemple
from flask import Flask, request
app = Flask(__name__)
@app.route("/debug")
def debug():
# Afficher diverses informations de requête pour aider à comprendre l'objet request
return f"""
<h1>Informations de débogage de la requête</h1>
<ul>
<li>Méthode : {request.method}</li>
<li>Chemin : {request.path}</li>
<li>URL complète : {request.url}</li>
<li>Hôte : {request.host}</li>
<li>IP client : {request.remote_addr}</li>
<li>User-Agent：{request.headers.get('User-Agent')}</li>
</ul>
"""
Visitezhttp://127.0.0.1:5000/debug?foo=barVous pouvez voir les informations détaillées de la requête.
Obtenir les paramètres de requête — request.args
Dans l'URL?Les paramètres qui la suivent sont appelés paramètres de requête (Query String).
Utilisationrequest.argsEn le lisant, il fonctionne comme un dictionnaire :
Exemple
def search():
# request.args.get() récupère le paramètre en toute sécurité, renvoie None lorsque la clé n'existe pas
keyword = request.args.get("keyword", "") # Obtenir le mot-clé de requête
page = request.args.get("page", "1") # Obtenir le numéro de page, 1 par défaut
return f"""
<h1>Résultats de recherche</h1>
<p>Mot-clé : {keyword}</p>
<p>Page : {page}</p>
"""
# Test : /search?keyword=flask&page=2
# Test : /search?keyword=EXAMPLE
Recommandé.get()Utilisez la méthode au lieu d'un accès direct par indice.request.args["key"], car ce dernier lève une exception lorsque la clé n'existe pas.KeyError, ce qui entraîne une page d'erreur 400.
Obtenir les données de formulaire — request.form
Pour gérer les données de formulaire envoyées par des requêtes POST, utilisezrequest.form：
Exemple
def register():
if request.method == "POST":
# Utiliser la valeur du champ name="username" dans le formulaire
username = request.form.get("username", "")
password = request.form.get("password", "")
if not username or not password:
return "<h1>Erreur</h1><p>Le nom d'utilisateur et le mot de passe ne peuvent pas être vides</p>", 400
return f"<h1>Inscription réussie</h1><p>Bienvenue {username} sur EXAMPLE !</p>"
# Afficher le formulaire d'inscription lors d'une requête GET
return """
<h1>Inscription</h1>
<form method="post">
<p>Nom d'utilisateur : <input type="text" name="username"></p>
<p>Mot de passe : <input type="password" name="password"></p>
<p><input type="submit" value="S'inscrire"></p>
</form>
"""
Remarque : dans la page HTML qui gère le formulaire,<form>doit être défini avecmethod="post", sinon les données seront envoyées via la chaîne de requête de l'URL (méthode GET), et des informations sensibles seront exposées dans l'URL.
Obtenir des données JSON — request.json
Dans le développement web moderne, JSON est le format de données le plus courant.
Lorsque le client envoie, avecContent-Type: application/json, une requête, utilisezrequest.jsonpour obtenir les données analysées :
Exemple
def create_user():
# request.json renvoie des données JSON déjà analysées dans un dictionnaire Python
data = request.json # Par exemple, le client envoie {"name": "example", "email": "[email protected]"}
# Récupérer le champ en toute sécurité
name = data.get("name", "Inconnu")
email = data.get("email", "Non fourni")
# Renvoyer directement un dict, Flask le convertit automatiquement en réponse JSON
return {
"message": "Utilisateur créé avec succès",
"name": name,
"email": email
}
Peut être utilisécurlou Postman pour tester :
$ curl -X POST http://127.0.0.1:5000/api/user \
-H "Content-Type: application/json" \
-d '{"name": "example", "email": "[email protected]"}'
{
"message": "用户创建成功",
"name": "example",
"email": "[email protected]"
}
Téléversement de fichier
Utilisez ceci pour gérer les fichiers téléversés :request.files, combiné avec la fonction fournie par Werkzeugsecure_filename()Assurez-vous que le nom du fichier est sécurisé :
Exemple
from werkzeug.utils import secure_filename # Filtrer les caractères dangereux des noms de fichiers
# Configurer le répertoire de téléversement (dans un vrai projet, ceci devrait être lu depuis la configuration)
UPLOAD_DIR = "uploads"
@app.route("/upload", methods=["GET", "POST"])
def upload_file():
if request.method == "POST":
# Vérifier si un fichier a été téléversé
if "file" not in request.files:
return "Aucun fichier sélectionné", 400
file = request.files["file"]
# L'utilisateur a peut-être soumis un formulaire vide (aucun fichier sélectionné)
if file.filename == "":
return "Le nom de fichier est vide", 400
# secure_filename filtre les caractères dangereux tels que la traversée de chemin
# Par exemple, "../../etc/passwd" serait traité comme "etc_passwd"
filename = secure_filename(file.filename)
# Vérifier que le répertoire de téléversement existe
os.makedirs(UPLOAD_DIR, exist_ok=True)
# Enregistrer le fichier
file.save(os.path.join(UPLOAD_DIR, filename))
return fFichier {filename} téléversé avec succès
# La requête GET affiche le formulaire de téléversement
return """
<h1>Téléverser un fichier</h1>
<form method="post" enctype="multipart/form-data">
<p><input type="file" name="file"></p>
<p><input type="submit" value="Téléverser"></p>
</form>
"""
Si le formulaire a un champ de téléversement de fichier,<form>Le libellé doit être définienctype="multipart/form-data", sinon les données du fichier ne seront pas envoyées par le navigateur.
Guide complet des types de réponse
Les fonctions de vue peuvent renvoyer plusieurs types de données, et Flask les convertira automatiquement en réponses HTTP appropriées.
Comprendre cette règle de conversion est la clé pour maîtriser Flask.
Retourner une chaîne
La chaîne renvoyée sert de corps de réponse HTML, avec un code d'état par défaut de 200 et un Content-Type detext/html。
Renvoie un dictionnaire ou une liste (JSON)
Appelé automatiquementjsonify()convertit en réponse JSON, avec Content-Type défini surapplication/json。
Exemple
def get_posts():
# Renvoie un dict, Flask convertit automatiquement en JSON
return {
"status": "ok",
"data": [
{"id": 1, "title": Tutoriel Flask},
{"id": 2, "title": Conception d'API RESTful},
]
}
@app.get("/api/tags")
def get_tags():
# Renvoie une liste, Flask convertit automatiquement en JSON
return ["Python", "Flask", Développement web, "EXAMPLE"]
Renvoi d'un tuple — contrôle du code de statut et des en-têtes de réponse
Le format de tuple est très pratique et comporte trois formes :
Exemple
@app.get("/not-found")
def not_found():
return <h1>Page introuvable</h1>, 404
# Forme 2 : (body, headers_dict)
@app.get("/custom-header")
def custom_header():
return "OK", {"X-Custom-Header": "example"}
# Forme 3 : (body, status_code, headers_dict)
@app.post("/api/login")
def api_login():
# Renvoie le jeton et un code de statut personnalisé
return {"token": "abc123", "user": "example"}, 201, {"X-RateLimit": "100"}
Redirect
Utilisationredirect()La fonction redirige l'utilisateur vers une autre URL :
Exemple
app = Flask(__name__)
@app.route("/")
def index():
# Rediriger vers la page de connexion lors de la visite de la page d'accueil
return redirect(url_for("login"))
@app.route("/login")
def login():
return <h1>Veuillez d'abord vous connecter</h1>
@app.route("/old-page")
def old_page():
# Ancienne page définitivement déplacée vers une nouvelle page, utilisez le code de statut 301
return redirect(url_for("new_page"), code=301)
@app.route("/new-page")
def new_page():
return <h1>Ceci est une nouvelle page</h1>
Le code de statut de redirection par défaut est303 See Other, adapté pour rediriger après la soumission d'un formulaire (modèle PRG).
Pour les scénarios de migration permanente, utilisezcode=301。
Terminer la requête — abort
Utilisationabort()Termine immédiatement la requête en cours et renvoie une erreur HTTP :
Exemple
@app.route("/post/<int:post_id>")
def view_post(post_id):
# Supposons que les ID d'article soient uniquement 1-100
if post_id < 1 or post_id > 100:
# Renvoyer immédiatement 404, le code suivant ne sera pas exécuté
abort(404)
return f"<h1>Article #{post_id}</h1>"
@app.route("/admin")
def admin():
# Renvoyer 403 pour un accès non autorisé
abort(403, description=Vous n'avez pas la permission d'accéder à cette page)
make_response — contrôler manuellement la réponse
Lorsque vous devez définir manuellement des cookies ou personnaliser les en-têtes de réponse, utilisezmake_response()：
Exemple
@app.route("/set-cookie")
def set_cookie():
# make_response encapsule la valeur de retour de la fonction de vue dans un objet Response
resp = make_response(<h1>Cookie défini</h1>)
# Définir le cookie sur l'objet Response
resp.set_cookie("theme", "dark", max_age=60*60*24) # Valable pendant 24 heures
resp.set_cookie("lang", "zh-CN")
# Vous pouvez également personnaliser les en-têtes de réponse
resp.headers["X-Powered-By"] = "EXAMPLE-Flask"
return resp
Tableau de référence rapide des attributs de requête courants
| Propriété | Type | Description | Valeur d'exemple |
|---|---|---|---|
| request.method | str | Méthode de requête HTTP | "GET", "POST" |
| request.path | str | Chemin d'URL (sans nom de domaine) | "/search" |
| request.args | MultiDict | Paramètres de requête URL | ?keyword=flask&page=1 |
| request.form | MultiDict | Données de formulaire POST | username=admin |
| request.json | dict ou None | Corps de requête JSON (analysé) | {"name": "example"} |
| request.files | FileMultiDict | Fichier téléversé | request.files["avatar"] |
| request.headers | En-têtes | En-têtes de requête | request.headers["User-Agent"] |
| request.cookies | dict | Cookie envoyé par le client | request.cookies.get("theme") |
| request.remote_addr | str | Adresse IP du client | "127.0.0.1" |