Comment fonctionnent les formulaires Django ?

Question

Accepted Answer

Django **forms** gère le cycle de vie complet de l'entrée utilisateur : rendre les champs de formulaire HTML, **valider** les données soumises, et les convertir en valeurs Python saines. Ils abstraient le travail fastidieux et sujet aux erreurs du traitement manuel des entrées et de la validation — une fonctionnalité majeure de productivité et de sécurité. ## Un formulaire basique ```python from django import forms class ContactForm(forms.Form): name = forms.CharField(max_length=100) email = forms.EmailField() # validates email format age = forms.IntegerField(min_value=0, required=False) message = forms.CharField(widget=forms.Textarea) ``` Chaque champ de formulaire déclare son type et ses règles de validation. Le formulaire peut se rendre en HTML et valider l'entrée par rapport à ces règles. ## Gérer un formulaire dans une vue (le motif standard) ```python def contact(request): if request.method == "POST": form = ContactForm(request.POST) # bind submitted data if form.is_valid(): # run validation # cleaned_data = validated, type-converted Python values name = form.cleaned_data["name"] send_email(form.cleaned_data) return redirect("success") else: form = ContactForm() # empty form for GET return render(request, "contact.html", {"form": form}) ``` Les méthodes clés : `is_valid()` exécute la validation, et en cas de succès `cleaned_data` vous donne des valeurs sûres, validées et converties de type. En cas d'échec, le formulaire conserve l'entrée et collecte les messages d'erreur. ## ModelForms — formulaires issus de modèles (DRY) ```python from django.forms import ModelForm class ArticleForm(ModelForm): class Meta: model = Article # build the form FROM a model fields = ["title", "body", "published"] # which fields to include # ModelForm can SAVE directly to the database def create(request): form = ArticleForm(request.POST) if form.is_valid(): form.save() # creates/updates the model instance! ``` **ModelForms** génère automatiquement un formulaire à partir des champs d'un modèle et peut enregistrer directement dans la base de données — incarnant le principe DRY (le modèle pilote le formulaire), éliminant le code boilerplate pour les formulaires CRUD. ## Validation personnalisée ```python class SignupForm(forms.Form): password = forms.CharField() confirm = forms.CharField() def clean_password(self): # field-level validation pw = self.cleaned_data["password"] if len(pw) < 8: raise forms.ValidationError("Too short") return pw def clean(self): # form-level (cross-field) validation data = super().clean() if data.get("password") != data.get("confirm"): raise forms.ValidationError("Passwords don't match") ``` ## Rendu et sécurité ```html ``` Les formulaires s'intègrent à la **protection CSRF** de Django (`{% csrf_token %}`) et rendent automatiquement les champs avec leurs messages d'erreur de validation. ## Pourquoi c'est important Les formulaires Django sont une fonctionnalité centrale pour traiter les entrées utilisateur de manière sûre et productive — et traiter les entrées correctement est à la fois omniprésent (presque chaque application a des formulaires) et critique pour la sécurité. Comprendre les formulaires est essentiel car ils abstraient le travail fastidieux et sujet aux erreurs du traitement des entrées : rendre les champs HTML, **valider** les données par rapport aux règles, les convertir en valeurs Python typées saines (`cleaned_data`), préserver l'entrée et afficher les erreurs en cas d'échec, et vous protéger contre les attaques. L'aspect validation est particulièrement important pour la **sécurité et la robustesse** — les formulaires garantissent que vous ne faites jamais confiance à l'entrée brute de l'utilisateur, en détectant les données malformées ou malveillantes avant qu'elles n'atteignent votre logique métier. **ModelForms** sont un gain de productivité majeur, incarnant le principe DRY en générant des formulaires directement à partir de modèles et en enregistrant dans la base de données avec un code minimal — éliminant le boilerplate pour le cas extrêmement courant des formulaires CRUD. Connaître le motif de vue standard (`is_valid()` + `cleaned_data`), comment ajouter une validation personnalisée au niveau du champ et entre champs, ModelForms pour les formulaires sauvegardés dans le modèle, et l'intégration avec la **protection CSRF** est fondamental pour construire toute application Django qui accepte l'entrée utilisateur. Les formulaires lient le traitement des entrées, la validation, la sécurité et la couche modèle, ce qui en fait une partie importante et fréquemment utilisée du framework et une raison clé pour laquelle Django est si productif pour les applications lourdes en saisie de données.