Django est un framework de développement Web de premier ordre écrit en Python qui favorise un développement rapide, une conception épurée et une approche pragmatique. L’un des aspects les plus importants du développement Web est la gestion des formulaires. Dans ce contexte, concentrons-nous sur la Section 19.4 : Formulaires dans Django.
Les formulaires constituent un élément essentiel de toute application Web. Ils constituent l'interface principale de saisie utilisateur, permettant aux utilisateurs de saisir des données que l'application peut ensuite utiliser pour effectuer diverses tâches. Dans Django, les formulaires sont gérés par une bibliothèque de formulaires intégrée.
Créer une application Django
Pour commencer, nous devons créer une nouvelle application Django. Supposons que le nom de notre application soit « myapp ». Pour créer cette application, nous utilisons la commande :
python manage.py startapp monapplication
Ensuite, nous devons ajouter « myapp » à la liste des INSTALLED_APPS dans notre fichier settings.py afin que Django sache qu'elle existe.
Formulaires dans Django
Django propose plusieurs façons de créer des formulaires. La méthode la plus courante consiste à utiliser la classe Form. Une classe Form est simplement un moyen de définir des champs de formulaire. Chaque champ de formulaire a un type de champ spécifique : CharField pour les champs de saisie de texte, DateTimeField pour les entrées datetime, etc.
Par exemple, nous pouvons créer un formulaire simple pour un système de commentaires comme suit :
à partir des formulaires d'importation Django
classe CommentForm(forms.Form):
nom = form.CharField(max_length=100)
commentaire = form.CharField(widget=forms.Textarea)
Il s'agit d'un formulaire très basique avec deux champs : un champ de saisie de texte pour le nom et une zone de texte pour le commentaire. Django gère automatiquement le rendu de ces champs au format HTML, la validation de l'entrée utilisateur et la conversion de l'entrée utilisateur en types de données Python.
Utiliser des formulaires dans les vues
Après avoir défini un formulaire, nous pouvons l'utiliser dans une vue. Une vue est simplement une fonction Python qui prend une requête Web et renvoie une réponse. Dans Django, nous pouvons utiliser la fonction render() pour restituer un modèle HTML avec un contexte donné. Le contexte est un dictionnaire qui mappe les noms de variables aux valeurs Python.
Par exemple, voici une vue qui affiche notre formulaire CommentForm :
à partir du rendu d'importation de Django.shortcuts
à partir de .forms importer CommentForm
commentaire def (demande):
form = CommentForm()
return render(request, 'comment.html', {'form': form})
Cette vue crée simplement une nouvelle instance de notre CommentForm et la transmet au modèle 'comment.html' sous le nom 'form'.
Traitement de la soumission des formulaires
Lorsqu'un utilisateur soumet un formulaire, nous devons traiter les données du formulaire. Django facilite cela avec la méthode is_valid(). Cette méthode vérifie que les données du formulaire sont valides - que tous les champs ont été correctement remplis et que les données passent toutes les validations définies.
Si le formulaire est valide, nous pouvons accéder aux données nettoyées du formulaire via l'attribut cleaning_data, qui est un dictionnaire qui mappe les noms de champs aux valeurs de champs propres.
Par exemple, voici une vue qui traite notre soumission de CommentForm :
depuis django.shortcuts importer le rendu, rediriger
à partir de .forms importer CommentForm
commentaire def (demande):
si request.method == 'POST' :
form = CommentForm(request.POST)
si form.is_valid() :
# traiter les données dans form.cleaned_data
#...
redirection de retour ('succès')
autre:
form = CommentForm()
return render(request, 'comment.html', {'form': form})
Cette vue vérifie d'abord si la requête est un POST. Si tel est le cas, il crée une nouvelle instance CommentForm à partir des données POST, vérifie que le formulaire est valide, puis traite les données. Si la requête n'est pas un POST, la vue restitue simplement le formulaire comme avant.
Conclusion
Les formulaires constituent un élément essentiel du développement Web et Django offre un moyen puissant et flexible de travailler avec eux. Avec la bibliothèque de formulaires de Django, nous pouvons définir des formulaires de manière déclarative, traiter facilement les soumissions de formulaires et réutiliser les formulaires courants dans toute notre application.
