Field
(**kwargs)¶Lorsque vous créez une classe Form
, la partie la plus importante est de définir les champs du formulaire. Chaque champ possède sa propre logique de validation, ainsi que quelques autres points d’entrée.
Field.
clean
(value)¶Même si l’emploi principal des classes Field
concerne la définition de classes Form
, il est aussi possible de les instancier et de les utiliser directement pour obtenir une meilleure idée de leur fonctionnement. Chaque instance Field
possède une méthode clean()
acceptant un seul paramètre et qui renvoie une valeur « nettoyée » ou qui génère une exception django.core.exceptions.ValidationError
:
>>> from django import forms
>>> f = forms.EmailField()
>>> f.clean('foo@example.com')
'foo@example.com'
>>> f.clean('invalid email address')
Traceback (most recent call last):
...
ValidationError: ['Enter a valid email address.']
Chaque constructeur de classe Field
accepte au moins trois paramètres. Certaines classes acceptent d’autres paramètres spécifiques à la classe, mais ceux qui suivent sont toujours acceptés :
required
¶Field.
required
¶Par défaut, chaque classe Field
suppose qu’une valeur est obligatoire, ce qui fait que si vous ne fournissez pas de valeur (que ce soit None
ou une chaîne vide(""
)), clean()
génère une exception ValidationError
:
>>> from django import forms
>>> f = forms.CharField()
>>> f.clean('foo')
'foo'
>>> f.clean('')
Traceback (most recent call last):
...
ValidationError: ['This field is required.']
>>> f.clean(None)
Traceback (most recent call last):
...
ValidationError: ['This field is required.']
>>> f.clean(' ')
' '
>>> f.clean(0)
'0'
>>> f.clean(True)
'True'
>>> f.clean(False)
'False'
Pour indiquer qu’un champ n’est pas obligatoire, passez required=False
au constructeur de Field
:
>>> f = forms.CharField(required=False)
>>> f.clean('foo')
'foo'
>>> f.clean('')
''
>>> f.clean(None)
''
>>> f.clean(0)
'0'
>>> f.clean(True)
'True'
>>> f.clean(False)
'False'
Lorsque required=False
est défini pour un champ Field
et que vous fournissez une valeur vide à clean()
, la valeur renvoyée est une valeur vide normalisée et aucune exception ValidationError
n’est générée. Pour CharField
, la valeur renvoyée correspond à empty_value
qui est une chaîne vide par défaut. Pour les autres classes Field
, il peut s’agir de None
(cela varie en fonction du champ).
Les composants des champs de formulaire obligatoires possèdent l’attribut HTML required
. Il est possible de désactiver cela en définissant l’attribut Form.use_required_attribute
à False
. L’attribut required
n’est pas ajouté aux formulaires groupés car la validation des navigateurs n’est pas toujours correcte quand on ajoute ou qu’on supprime de tels formulaires.
label
¶Field.
label
¶Le paramètre label
permet d’indiquer une étiquette conviviale pour le champ. Cette valeur est utilisée lorsque le champ Field
est affiché dans un formulaire Form
.
Comme expliqué dans « Affichage des formulaires en HTML » ci-dessus, l’étiquette par défaut d’un champ Field
est générée à partir du nom de champ en convertissant tous les soulignements en espaces et en mettant en majuscule la première lettre. Donnez une valeur à label
si ce comportement par défaut ne produit pas un résultat convenable.
Voici un exemple complet de formulaire implémentant label
pour deux de ses champs. Nous avons indiqué auto_id=False
pour simplifier l’affichage :
>>> from django import forms
>>> class CommentForm(forms.Form):
... name = forms.CharField(label='Your name')
... url = forms.URLField(label='Your website', required=False)
... comment = forms.CharField()
>>> f = CommentForm(auto_id=False)
>>> print(f)
<tr><th>Your name:</th><td><input type="text" name="name" required></td></tr>
<tr><th>Your website:</th><td><input type="url" name="url"></td></tr>
<tr><th>Comment:</th><td><input type="text" name="comment" required></td></tr>
label_suffix
¶Field.
label_suffix
¶Le paramètre label_suffix
permet de surcharger l’attribut label_suffix
d’un formulaire pour un champ particulier :
>>> class ContactForm(forms.Form):
... age = forms.IntegerField()
... nationality = forms.CharField()
... captcha_answer = forms.IntegerField(label='2 + 2', label_suffix=' =')
>>> f = ContactForm(label_suffix='?')
>>> print(f.as_p())
<p><label for="id_age">Age?</label> <input id="id_age" name="age" type="number" required></p>
<p><label for="id_nationality">Nationality?</label> <input id="id_nationality" name="nationality" type="text" required></p>
<p><label for="id_captcha_answer">2 + 2 =</label> <input id="id_captcha_answer" name="captcha_answer" type="number" required></p>
initial
¶Field.
initial
¶Le paramètre initial
permet d’indiquer la valeur initiale à utiliser lors de l’affichage HTML du champ dans un formulaire Form
non lié.
Pour indiquer des données initiales dynamiques, voir le paramètre Form.initial
.
Le cas d’utilisation typique est lorsque l’on veut afficher un formulaire vierge dans lequel un champ contient initialement une valeur. Par exemple :
>>> from django import forms
>>> class CommentForm(forms.Form):
... name = forms.CharField(initial='Your name')
... url = forms.URLField(initial='http://')
... comment = forms.CharField()
>>> f = CommentForm(auto_id=False)
>>> print(f)
<tr><th>Name:</th><td><input type="text" name="name" value="Your name" required></td></tr>
<tr><th>Url:</th><td><input type="url" name="url" value="http://" required></td></tr>
<tr><th>Comment:</th><td><input type="text" name="comment" required></td></tr>
Vous vous demandez peut-être pourquoi on ne passe pas simplement un dictionnaire de valeurs initiales dans le paramètre data
au moment d’afficher le formulaire ? Le problème de cette solution est que cela provoque la validation des données et que le résultat HTML contiendra alors d’éventuelles erreurs de validation :
>>> class CommentForm(forms.Form):
... name = forms.CharField()
... url = forms.URLField()
... comment = forms.CharField()
>>> default_data = {'name': 'Your name', 'url': 'http://'}
>>> f = CommentForm(default_data, auto_id=False)
>>> print(f)
<tr><th>Name:</th><td><input type="text" name="name" value="Your name" required></td></tr>
<tr><th>Url:</th><td><ul class="errorlist"><li>Enter a valid URL.</li></ul><input type="url" name="url" value="http://" required></td></tr>
<tr><th>Comment:</th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="comment" required></td></tr>
C’est pourquoi les valeurs initiales ne sont affichées que pour les formulaires non liés. Pour les formulaires liés, le résultat HTML utilise les données liées.
Notez également que les valeurs initiales ne sont pas utilisées comme données de repli dans la validation lorsqu’une valeur de champ est manquante. Les valeurs initiales sont uniquement destinées à l’affichage initial d’un formulaire :
>>> class CommentForm(forms.Form):
... name = forms.CharField(initial='Your name')
... url = forms.URLField(initial='http://')
... comment = forms.CharField()
>>> data = {'name': '', 'url': '', 'comment': 'Foo'}
>>> f = CommentForm(data)
>>> f.is_valid()
False
# The form does *not* fall back to using the initial values.
>>> f.errors
{'url': ['This field is required.'], 'name': ['This field is required.']}
Au lieu d’une constante, il est aussi possible de transmettre un objet exécutable :
>>> import datetime
>>> class DateForm(forms.Form):
... day = forms.DateField(initial=datetime.date.today)
>>> print(DateForm())
<tr><th>Day:</th><td><input type="text" name="day" value="12/23/2008" required><td></tr>
L’objet exécutable ne sera évalué qu’au moment où le formulaire non lié est affiché, et non pas au moment de sa définition.
widget
¶Field.
widget
¶Le paramètre widget
permet d’indiquer une classe Widget
à utiliser lors du rendu HTML de ce champ. Voir Composants de formulaires (« widgets ») pour plus d’informations.
help_text
¶Field.
help_text
¶Le paramètre help_text
vous permet de définir du texte descriptif pour ce champ. S’il est défini, il sera affiché près du champ lorsque celui-ci sera affiché en HTML par l’une des méthodes de raccourci de Form
(par ex. as_ul()
).
Tout comme l’attribut help_text
d’un champ de modèle, cette valeur n’est pas sujette à l’échappement HTML dans les formulaires générés automatiquement.
Voici un exemple complet de formulaire implémentant help_text
pour deux de ses champs. Nous avons indiqué auto_id=False
pour simplifier l’affichage :
>>> from django import forms
>>> class HelpTextContactForm(forms.Form):
... subject = forms.CharField(max_length=100, help_text='100 characters max.')
... message = forms.CharField()
... sender = forms.EmailField(help_text='A valid email address, please.')
... cc_myself = forms.BooleanField(required=False)
>>> f = HelpTextContactForm(auto_id=False)
>>> print(f.as_table())
<tr><th>Subject:</th><td><input type="text" name="subject" maxlength="100" required><br><span class="helptext">100 characters max.</span></td></tr>
<tr><th>Message:</th><td><input type="text" name="message" required></td></tr>
<tr><th>Sender:</th><td><input type="email" name="sender" required><br>A valid email address, please.</td></tr>
<tr><th>Cc myself:</th><td><input type="checkbox" name="cc_myself"></td></tr>
>>> print(f.as_ul()))
<li>Subject: <input type="text" name="subject" maxlength="100" required> <span class="helptext">100 characters max.</span></li>
<li>Message: <input type="text" name="message" required></li>
<li>Sender: <input type="email" name="sender" required> A valid email address, please.</li>
<li>Cc myself: <input type="checkbox" name="cc_myself"></li>
>>> print(f.as_p())
<p>Subject: <input type="text" name="subject" maxlength="100" required> <span class="helptext">100 characters max.</span></p>
<p>Message: <input type="text" name="message" required></p>
<p>Sender: <input type="email" name="sender" required> A valid email address, please.</p>
<p>Cc myself: <input type="checkbox" name="cc_myself"></p>
error_messages
¶Field.
error_messages
¶Le paramètre error_messages
permet de redéfinir les messages par défaut que le champ renvoie. Passez un dictionnaire dont les clés correspondent aux messages d’erreur que vous voulez redéfinir. Par exemple, voici le message d’erreur par défaut :
>>> from django import forms
>>> generic = forms.CharField()
>>> generic.clean('')
Traceback (most recent call last):
...
ValidationError: ['This field is required.']
Et voici un message d’erreur personnalisé :
>>> name = forms.CharField(error_messages={'required': 'Please enter your name'})
>>> name.clean('')
Traceback (most recent call last):
...
ValidationError: ['Please enter your name']
Dans la section Classes de champs Field intégrées ci-dessous, chaque champ Field
définit les clés de messages d’erreur qu’il utilise.
validators
¶Field.
validators
¶Le paramètre validators
permet de définir une liste de fonctions de validation pour le champ.
Consultez la documentation des validateurs pour plus d’informations.
localize
¶Field.
localize
¶Le paramètre localize
active la régionalisation des données de formulaires, aussi bien au niveau de la saisie que de l’affichage produit.
Consultez la documentation sur la régionalisation de la mise en forme pour plus d’informations.
disabled
¶Field.
disabled
¶Le paramètre booléen disabled
, lorsqu’il est défini à True
, désactive un champ de formulaire en utilisant l’attribut HTML disabled
afin qu’il ne soit pas modifiable par les utilisateurs. Même si quelqu’un forçait la modification de la valeur du champ soumis au serveur, elle serait ignorée en faveur de la valeur fournie initialement au formulaire.
has_changed()
¶Field.
has_changed
()¶La méthode has_changed()
est utilisée pour déterminer si la valeur du champ a été modifiée par rapport à sa valeur initiale. Renvoie True
ou False
.
Consultez la documentation de Form.has_changed()
pour plus de détails.
Field
intégrées¶Bien évidemment, la bibliothèque des formulaires est livrée avec une série de classes Field
représentant les besoins de validation les plus courants. Cette section décrit chaque champ intégré dans Django.
Pour chaque champ, nous indiquons le composant utilisé par défaut quand widget
n’est pas précisé. Nous indiquons également la valeur renvoyée lorsqu’une valeur vide est fournie (voir la section sur required
ci-dessus pour comprendre ce que cela signifie).
BooleanField
¶BooleanField
(**kwargs)¶CheckboxInput
False
True
ou False
.True
(signifiant par exemple que la case à cocher est cochée) si required=True
pour ce champ.required
Note
Comme toutes les sous-classes de Field
héritent required=True
par défaut, la condition de validation est importante à cet endroit. Si vous souhaitez inclure une valeur booléenne dans un formulaire qui puisse valoir aussi bien True
que False
(par exemple une case cochée ou non), vous devez vous rappeler de passer required=False
au moment de créer le champ BooleanField
.
CharField
¶CharField
(**kwargs)¶TextInput
empty_value
.MaxLengthValidator
et MinLengthValidator
si max_length
et min_length
sont fournis. Sinon, toutes les entrées sont valides.required
, max_length
, min_length
Possède quatre paramètres facultatifs liés à la validation :
max_length
¶min_length
¶Quand ils sont fournis, ces paramètres garantissent que la chaîne de caractères correspond au maximum ou au minimum à la longueur donnée.
strip
¶Si True
(valeur par défaut), la valeur sera épurée d’éventuelles espaces initiales ou finales.
empty_value
¶La valeur à utiliser pour représenter une valeur vide. Contient une chaîne vide par défaut.
ChoiceField
¶ChoiceField
(**kwargs)¶Select
''
(une chaîne vide)required
, invalid_choice
Le message d’erreur invalid_choice
peut contenir %(value)s
, qui sera remplacé par le choix sélectionné.
Accepte un paramètre supplémentaire :
choices
¶Soit un object itérable de tuples à 2 valeurs à utiliser comme liste de choix pour ce champ, soit des choix d’une énumération, soit un objet exécutable qui renvoie un tel objet itérable. Ce paramètre accepte les mêmes formats que le paramètre choices
d’un champ de modèle. Consultez la documentation des champs de modèles sur les choix pour plus de détails. Si le paramètre est un exécutable, il est évalué lors de chaque initialisation du formulaire contenant le champ, en plus de l’évaluation au moment du rendu. Par défaut, c’est une liste vide.
TypedChoiceField
¶TypedChoiceField
(**kwargs)¶Similaire à ChoiceField
, sauf que TypedChoiceField
accepte deux paramètres supplémentaires, coerce
et empty_value
.
Select
empty_value
.coerce
.required
, invalid_choice
Accepte des paramètres supplémentaires :
coerce
¶Une fonction acceptant un paramètre et renvoyant une valeur transtypée. Comme exemple, on peut mentionner les fonctions Python int
, float
, bool
et les autres types. Par défaut, il s’agit de la fonction identité. Notez que le forçage de type se produit après la validation de saisie, il est donc possible de forcer une valeur qui n’est pas présente dans choices
.
empty_value
¶La valeur utilisée pour signifier « vide ». Par défaut, il s’agit de la chaîne vide ; None
est une autre option assez fréquente ici. Remarquez que le type de cette valeur ne sera pas transformé par le contenu du paramètre coerce
, il faut donc la choisir en conséquence.
DateField
¶DateField
(**kwargs)¶DateInput
None
datetime.date
.datetime.date
, datetime.datetime
ou une chaîne mise en forme dans un format de date particulier.required
, invalid
Accepte un paramètre facultatif :
input_formats
¶Une liste de chaînes de format utilisées pour essayer de convertir une chaîne en un objet datetime.date
valide.
Si aucun paramètre input_formats
n’est indiqué, les formats d’entrée par défaut sont lus dans dans DATE_INPUT_FORMATS
si USE_L10N
est False
, ou dans la clé DATE_INPUT_FORMATS
de la langue active si la régionalisation est activée. Voir aussi la régionalisation des formats.
DateTimeField
¶DateTimeField
(**kwargs)¶DateTimeInput
None
datetime.datetime
.datetime.datetime
, datetime.date
ou une chaîne mise en forme dans un format de date/heure particulier.required
, invalid
Accepte un paramètre facultatif :
input_formats
¶Une liste de chaînes de format utilisées pour essayer de convertir une chaîne en un objet datetime.datetime
valide, en plus des formats ISO 8601.
Le champ accepte toujours les chaînes mises en forme selon le format ISO 8601 ou apparenté reconnues par parse_datetime()
. Voici quelques exemples
* '2006-10-25 14:30:59'
* '2006-10-25T14:30:59'
* '2006-10-25 14:30'
* '2006-10-25T14:30'
* '2006-10-25T14:30Z'
* '2006-10-25T14:30+02:00'
* '2006-10-25'
Si aucun paramètre input_formats
n’est indiqué, les formats d’entrée par défaut sont lus dans dans DATETIME_INPUT_FORMATS
et DATE_INPUT_FORMATS
si USE_L10N
est False
, ou dans les clés DATETIME_INPUT_FORMATS
et DATE_INPUT_FORMATS
de la langue active si la régionalisation est activée. Voir aussi la régionalisation des formats.
La prise en charge des formats de date ISO 8601 (y compris un éventuel fuseau horaire) a été ajoutée.
Le recours à DATE_INPUT_FORMATS
si nécessaire dans la valeur input_formats
par défaut a été ajouté.
DecimalField
¶DecimalField
(**kwargs)¶NumberInput
lorsque Field.localize
vaut False
, sinon TextInput
.None
decimal
.MaxValueValidator
et MinValueValidator
si max_value
et min_value
sont fournis. Les espaces de début et de fin sont ignorés.required
, invalid
, max_value
, min_value
, max_digits
, max_decimal_places
, max_whole_digits
Les messages d’erreur max_value
et min_value
peuvent contenir %(limit_value)s
, qui sera remplacé par la limite concernée. Sur le même principe, les messages d’erreur max_digits
, max_decimal_places
et max_whole_digits
peuvent contenir %(max)s
.
Accepte quatre paramètres facultatifs :
max_value
¶min_value
¶Ces paramètres contrôlent les intervalles de valeurs autorisées dans le champ et doivent être exprimés en valeurs decimal.Decimal
.
max_digits
¶Le nombre maximum de chiffres autorisés dans la valeur (avant et après le point décimal, sans tenir compte des zéros initiaux).
decimal_places
¶Le nombre maximal de décimales autorisées.
DurationField
¶DurationField
(**kwargs)¶TextInput
None
timedelta
.timedelta
. La valeur doit être comprise entre datetime.timedelta.min
et datetime.timedelta.max
.required
, invalid
, overflow
.Accepte tout format que parse_duration()
peut analyser.
EmailField
¶EmailField
(**kwargs)¶EmailInput
empty_value
.EmailValidator
pour valider que la valeur donnée est une adresse de courriel valide, en utilisant une expression régulière moyennement complexe.required
, invalid
Possède trois paramètres facultatifs max_length
, min_length
et empty_value
, qui fonctionnent exactement comme pour CharField
.
FileField
¶FileField
(**kwargs)¶ClearableFileInput
None
UploadedFile
englobant le contenu du fichier et son nom dans un seul objet.required
, invalid
, missing
, empty
, max_length
Accepte deux paramètres facultatifs pour la validation, max_length
et allow_empty_file
. S’ils sont présents, ils garantissent respectivement que la longueur du nom de fichier ne dépasse pas la longueur indiquée et que la validation passe même quand le contenu du fichier est vide.
Pour en savoir plus au sujet de l’objet UploadedFile
, consultez la documentation sur les envois de fichiers.
Lorsque vous utilisez un champ FileField
dans un formulaire, vous ne devez pas oublier de lier les données de fichier au formulaire.
L’erreur max_length
porte sur la longueur du nom de fichier. Dans le message d’erreur de cette clé, %(max)d
sera remplacé par la longueur maximale du nom de fichier et %(length)d
sera remplacé par la longueur effective du nom de fichier.
FilePathField
¶FilePathField
(**kwargs)¶Select
''
(une chaîne vide)required
, invalid_choice
Ce champ permet de choisir parmi des fichiers dans un répertoire désigné. Il accepte cinq paramètres supplémentaires ; seul path
est obligatoire :
path
¶Le chemin absolu vers le répertoire dont le contenu doit être présent dans la liste. Ce répertoire doit exister.
recursive
¶Si False
(valeur par défaut), seul le contenu au premier niveau de path
sera à disposition dans les choix possibles. Si True
, le répertoire sera parcouru récursivement et tous ses descendants seront inclus dans les choix possibles.
match
¶Un motif d’expression régulière ; seuls les fichiers dont les noms correspondent à cette expression seront disponibles dans la liste à choix.
allow_files
¶Facultatif. Vaut True
ou False
. La valeur par défaut est True
. Indique si les fichiers de l’emplacement spécifié doivent être inclus. Il faut que l’une des deux valeurs, ce champ ou allow_folders
, soit True
.
allow_folders
¶Facultatif. Vaut True
ou False
. La valeur par défaut est False
. Indique si tous les répertoires à l’intérieur de l’emplacement spécifié doivent être inclus. Il faut que l’une des deux valeurs, ce champ ou allow_files
, soit True
.
FloatField
¶FloatField
(**kwargs)¶NumberInput
lorsque Field.localize
vaut False
, sinon TextInput
.None
MaxValueValidator
et MinValueValidator
si max_value
et min_value
sont fournis. Les espaces de début et de fin sont permis, comme pour la fonction float()
de Python.required
, invalid
, max_value
, min_value
Accepte deux paramètres facultatifs pour la validation, max_value
et min_value
. Ces paramètres contrôlent l’intervalle des valeurs autorisées dans ce champ.
ImageField
¶ImageField
(**kwargs)¶ClearableFileInput
None
UploadedFile
englobant le contenu du fichier et son nom dans un seul objet.FileExtensionValidator
pour valider que l’extension de fichier est prise en charge par Pillow.required
, invalid
, missing
, empty
, invalid_image
L’emploi de ImageField
requiert que Pillow soit installé et gère les formats d’image que vous utilisez. Si vous obtenez une erreur d’image corrompue (corrupt image
) lorsque vous téléversez une image, cela signifie généralement que Pillow ne prend pas en charge son format. Pour corriger cela, installez la bibliothèque correspondante et réinstallez Pillow.
Lorsque vous utilisez un champ ImageField
dans un formulaire, vous ne devez pas oublier de lier les données de fichier au formulaire.
Après que le champ a été nettoyé et validé, l’objet UploadedFile
comportera un attribut supplémentaire image
contenant l’instance Image de Pillow utilisée pour contrôler que le fichier est une image valide. Pillow ferme le descripteur de fichier sous-jacent après avoir vérifié l’image ; ainsi, alors que certains attributs de données non image tels que format
, height
et width
sont accessibles, ce n’est pas le cas des méthodes qui accèdent aux données image sous-jacentes, telles que getdata()
ou getpixel()
, sauf si vous prenez la peine de réouvrir le fichier. Par exemple
>>> from PIL import Image
>>> from django import forms
>>> from django.core.files.uploadedfile import SimpleUploadedFile
>>> class ImageForm(forms.Form):
... img = forms.ImageField()
>>> file_data = {'img': SimpleUploadedFile('test.png', <file data>)}
>>> form = ImageForm({}, file_data)
# Pillow closes the underlying file descriptor.
>>> form.is_valid()
True
>>> image_field = form.cleaned_data['img']
>>> image_field.image
<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=191x287 at 0x7F5985045C18>
>>> image_field.image.width
191
>>> image_field.image.height
287
>>> image_field.image.format
'PNG'
>>> image_field.image.getdata()
# Raises AttributeError: 'NoneType' object has no attribute 'seek'.
>>> image = Image.open(image_field)
>>> image.getdata()
<ImagingCore object at 0x7f5984f874b0>
De plus, UploadedFile.content_type
sera également mis à jour avec le type de contenu de l’image pour autant que Pillow puisse le déterminer, sinon il prend la valeur None
.
IntegerField
¶IntegerField
(**kwargs)¶NumberInput
lorsque Field.localize
vaut False
, sinon TextInput
.None
MaxValueValidator
et MinValueValidator
si max_value
et min_value
sont fournis. Les espaces de début et de fin sont permis, comme pour la fonction int()
de Python.required
, invalid
, max_value
, min_value
Les messages d’erreur max_value
et min_value
peuvent contenir %(limit_value)s
, qui sera remplacé par la limite concernée.
Accepte deux paramètres facultatifs liés à la validation :
max_value
¶min_value
¶Ces paramètres contrôlent l’intervalle des valeurs autorisées dans ce champ.
JSONField
¶JSONField
(encoder=None, decoder=None, **kwargs)¶Un champ qui accepte des données codées en JSON pour un champ JSONField
.
Textarea
None
dict
, list
ou None
), en fonction de JSONField.decoder
.required
, invalid
Accepte deux paramètres facultatifs :
encoder
¶Une sous-classe de py:class:json.JSONEncoder pour sérialiser les types de données non prises en charge par le sérialiseur JSON standard (par ex. datetime.datetime
ou UUID
). Par exemple, vous pouvez utiliser la classe DjangoJSONEncoder
.
Contient json.JSONEncoder
par défaut.
decoder
¶Une sous-classe de json.JSONDecoder
pour désérialiser l’entrée. La désérialisation pourrait devoir tenir compte de l’incertitude liée au type de la valeur d’entrée. Par exemple, vous courez le risque de renvoyer un objet datetime
qui était en fait une chaîne qui était fortuitement au même format que celui choisi pour les objets datetime
.
Le decoder
peut être utiliser pour valider les données entrées. Si json.JSONDecodeError
est générée durant la désérialisation, une exception ValidationError
sera produite.
Contient json.JSONDecoder
par défaut.
Note
Si vous utilisez un formulaire ModelForm
, ce sont les paramètres encoder
et decoder
de JSONField
qui seront utilisés.
Formulaires conviviaux
JSONField
n’est pas particulièrement convivial dans la plupart des cas. Il s’agit cependant d’une manière utile de mettre en forme des données d’un composant côté client en vue de son envoi vers le serveur.
GenericIPAddressField
¶GenericIPAddressField
(**kwargs)¶Un champ contenant soit une adresse IPv4, soit une adresse IPv6.
TextInput
''
(une chaîne vide)required
, invalid
La normalisation d’adresse IPv6 respecte la section 2.2 de la RFC 4291#section-2.2, y compris l’utilisation du format IPv4 suggéré dans le 3e paragraphe de cette section, comme ::ffff:192.0.2.0
. Par exemple, 2001:0::0:01
sera normalisé en 2001::1
et ::ffff:0a0a:0a0a
en ::ffff:10.10.10.10
. Tous les caractères sont convertis en minuscules.
Accepte deux paramètres facultatifs :
protocol
¶Limite la validité des saisies au protocole indiqué. Les valeurs possibles sont 'both'
(les deux protocoles acceptés, valeur par défaut), 'IPv4'
ou 'IPv6'
. La correspondance n’est pas sensible à la casse.
unpack_ipv4
¶Décode les adresses IPv4 mappées comme ::ffff:192.0.2.1
. Si cette option est activée, cette adresse serait décodée en 192.0.2.1
. L’option est désactivée par défaut. Utilisable uniquement quand protocol
est défini à 'both'
.
MultipleChoiceField
¶MultipleChoiceField
(**kwargs)¶SelectMultiple
[]
(une liste vide)required
, invalid_choice
, invalid_list
Le message d’erreur invalid_choice
peut contenir %(value)s
, qui sera remplacé par le choix sélectionné.
Requiert un paramètre supplémentaire obligatoire, choices
, comme pour ChoiceField
.
TypedMultipleChoiceField
¶TypedMultipleChoiceField
(**kwargs)¶Similaire à MultipleChoiceField
, sauf que TypedMultipleChoiceField
accepte deux paramètres supplémentaires, coerce
et empty_value
.
SelectMultiple
empty_value
coerce
.required
, invalid_choice
Le message d’erreur invalid_choice
peut contenir %(value)s
, qui sera remplacé par le choix sélectionné.
Accepte deux paramètres supplémentaires, coerce
et empty_value
, comme pour TypedChoiceField
.
NullBooleanField
¶NullBooleanField
(**kwargs)¶NullBooleanSelect
None
True
, False
ou None
.ValidationError
).NullBooleanField
peut être utilisé avec des composants tels que Select
ou RadioSelect
en indiquant les choix choices
du composant
NullBooleanField(
widget=Select(
choices=[
('', 'Unknown'),
(True, 'Yes'),
(False, 'No'),
]
)
)
RegexField
¶RegexField
(**kwargs)¶TextInput
empty_value
.RegexValidator
pour valider que la valeur donnée correspond à une certaine expression régulière.required
, invalid
Requiert un paramètre supplémentaire obligatoire :
regex
¶Une expression régulière exprimée sous forme de chaîne ou d’objet expression régulière compilée.
Accepte également max_length
, min_length
, strip
et empty_value
, qui fonctionnent exactement comme pour CharField
.
strip
¶Contient False
par défaut. Quand ce paramètre est activé, l’épuration des espaces initiales et finales s’effectue avant la validation par l’expression régulière.
SlugField
¶SlugField
(**kwargs)¶TextInput
empty_value
.validate_slug
ou validate_unicode_slug
pour valider que la valeur donnée ne contient que des lettres, des nombres, des soulignements et des tirets.required
, invalid
Ce champ est prévu pour l’affichage des champs de modèle SlugField
dans les formulaires.
Accepte deux paramètres facultatifs :
allow_unicode
¶Une valeur booléenne indiquant au champ d’accepter des lettres Unicode en plus des lettres ASCII de base. La valeur par défaut est False
.
empty_value
¶La valeur à utiliser pour représenter une valeur vide. Contient une chaîne vide par défaut.
TimeField
¶TimeField
(**kwargs)¶TimeInput
None
datetime.time
.datetime.time
ou une chaîne mise en forme dans un format d’heure particulier.required
, invalid
Accepte un paramètre facultatif :
input_formats
¶Une liste de chaînes de format utilisées pour essayer de convertir une chaîne en un objet datetime.time
valide.
Si aucun paramètre input_formats
n’est indiqué, les formats d’entrée par défaut sont lus dans dans TIME_INPUT_FORMATS
si USE_L10N
est False
, ou dans la clé TIME_INPUT_FORMATS
de la langue active si la régionalisation est activée. Voir aussi la régionalisation des formats.
URLField
¶URLField
(**kwargs)¶URLInput
empty_value
.URLValidator
pour valider que la valeur donnée est une URL valide.required
, invalid
Possède trois paramètres facultatifs max_length
, min_length
et empty_value
, qui fonctionnent exactement comme pour CharField
.
Field
intégrées plus complexes¶ComboField
¶ComboField
(**kwargs)¶TextInput
''
(une chaîne vide)ComboField
.required
, invalid
Requiert un paramètre supplémentaire obligatoire :
fields
¶La liste des champs devant être utilisés pour valider la valeur du champ (dans l’ordre de leur présentation).
>>> from django.forms import ComboField
>>> f = ComboField(fields=[CharField(max_length=20), EmailField()])
>>> f.clean('test@example.com')
'test@example.com'
>>> f.clean('longemailaddress@example.com')
Traceback (most recent call last):
...
ValidationError: ['Ensure this value has at most 20 characters (it has 28).']
MultiValueField
¶MultiValueField
(fields=(), **kwargs)¶TextInput
''
(une chaîne vide)compress
de la sous-classe.MultiValueField
.required
, invalid
, incomplete
Agrège la logique de plusieurs champs qui produisent une seule valeur en commun.
Ce champ est abstrait et doit être hérité. Au contraire des champs à valeur unique, les sous-classes de MultiValueField
ne doivent pas implémenter clean()
mais plutôt compress()
.
Requiert un paramètre supplémentaire obligatoire :
fields
¶Un tuple de champs dont les valeurs sont nettoyées puis ultérieurement combinées en une seule valeur. Chaque valeur du champ est nettoyée par le champ correspondant dans fields
– la première valeur est nettoyée par le premier champ, la deuxième valeur par le deuxième champ, etc. Lorsque tous les champs ont été nettoyés, la liste de ces valeurs est combinée en une valeur unique par compress()
.
Accepte aussi des paramètre facultatifs :
require_all_fields
¶La valeur par défaut est True
, auquel cas une erreur de validation required
est générée si aucune valeur n’est fournie pour aucun champ.
Lorsque la valeur est False
, l’attribut Field.required
peut être défini à False
pour des champs individuels pour les rendre facultatifs. Si aucune valeur n’est fournie pour un champ obligatoire, une erreur de validation incomplete
est générée.
Un message d’erreur incomplete
par défaut peut être défini dans la sous-classe de MultiValueField
, ou il est possible de définir des messages différents pour chaque champ individuellement. Par exemple :
from django.core.validators import RegexValidator
class PhoneField(MultiValueField):
def __init__(self, **kwargs):
# Define one message for all fields.
error_messages = {
'incomplete': 'Enter a country calling code and a phone number.',
}
# Or define a different message for each field.
fields = (
CharField(
error_messages={'incomplete': 'Enter a country calling code.'},
validators=[
RegexValidator(r'^[0-9]+$', 'Enter a valid country calling code.'),
],
),
CharField(
error_messages={'incomplete': 'Enter a phone number.'},
validators=[RegexValidator(r'^[0-9]+$', 'Enter a valid phone number.')],
),
CharField(
validators=[RegexValidator(r'^[0-9]+$', 'Enter a valid extension.')],
required=False,
),
)
super().__init__(
error_messages=error_messages, fields=fields,
require_all_fields=False, **kwargs
)
widget
¶Doit être une sous-classe de django.forms.MultiWidget
. La valeur par défaut est TextInput
, qui n’est probablement pas très utile dans ce cas.
compress
(data_list)¶Accepte une liste de valeurs valides et renvoie une version « compressée » de ces valeurs dans une seule valeur. Par exemple, SplitDateTimeField
est une sous-classe qui combine un champ heure et un champ date en un seul objet datetime
.
Cette méthode doit être implémentée par les sous-classes.
SplitDateTimeField
¶SplitDateTimeField
(**kwargs)¶SplitDateTimeWidget
None
datetime.datetime
.datetime.datetime
ou une chaîne mise en forme dans un format de date/heure particulier.required
, invalid
, invalid_date
, invalid_time
Accepte deux paramètres facultatifs :
input_date_formats
¶Une liste de chaînes de format utilisées pour essayer de convertir une chaîne en un objet datetime.date
valide.
Si aucun paramètre input_date_formats
n’est indiqué, ce sont les formats de saisie par défaut de DateField
qui sont utilisés.
input_time_formats
¶Une liste de chaînes de format utilisées pour essayer de convertir une chaîne en un objet datetime.time
valide.
Si aucun paramètre input_time_formats
n’est indiqué, ce sont les formats de saisie par défaut de TimeField
qui sont utilisés.
Deux champs sont disponibles pour représenter les relations entre modèles : ModelChoiceField
and ModelMultipleChoiceField
. Ces deux champs exigent un seul paramètre queryset
utilisé pour créer les choix du champ. Lors de la validation du formulaire, ces champs placent soit un objet de modèle (dans le cas de ModelChoiceField
), soit plusieurs objets de modèle (dans le cas de ModelMultipleChoiceField
) dans le dictionnaire cleaned_data
du formulaire.
Pour des usages plus complexes, il est possible d’indiquer queryset=None
au moment de déclarer le champ de formulaire, puis de remplir queryset
dans la méthode __init__()
du formulaire :
class FooMultipleChoiceForm(forms.Form):
foo_select = forms.ModelMultipleChoiceField(queryset=None)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['foo_select'].queryset = ...
ModelChoiceField
et ModelMultipleChoiceField
ont les deux un attribut iterator
qui spécifie la classe utilisée pour itérer sur le jeu de requête lors de la génération des choix. Voir Itération sur les choix relationnels pour plus de détails.
ModelChoiceField
¶ModelChoiceField
(**kwargs)¶Select
None
required
, invalid_choice
Permet de sélectionner un seul objet de modèle, adapté à la représentation d’une clé étrangère. Notez que le composant par défaut de ModelChoiceField
devient difficilement utilisable au fur et à mesure que le nombre de choix possibles augmente. Il n’est pas recommandé de l’utiliser lorsque le nombre d’éléments à choix dépasse 100.
Un seul paramètre est obligatoire :
queryset
¶Un jeu de requête QuerySet
d’objets de modèles constituant la source des choix possibles pour le champ et qui est utilisé aussi pour valider le choix de l’utilisateur. Il est évalué au moment du rendu du formulaire.
ModelChoiceField
accepte aussi deux paramètres facultatifs :
empty_label
¶Par défaut, le composant <select>
utilisé par ModelChoiceField
comportera un choix vide en premier dans la liste. Vous pouvez adapter le texte de cette étiquette (qui est "---------"
par défaut) au moyen de l’attribut empty_label
, ou même désactiver complètement le choix vide en définissant empty_label
à None
:
# A custom empty label
field1 = forms.ModelChoiceField(queryset=..., empty_label="(Nothing)")
# No empty label
field2 = forms.ModelChoiceField(queryset=..., empty_label=None)
Notez que si un ModelChoiceField
est obligatoire et qu’il contient une valeur initiale par défaut, aucun choix vide n’est créé (quelle que soit la valeur de empty_label
).
to_field_name
¶Ce paramètre facultatif est utilisé pour désigner le champ à utiliser comme valeur des choix dans le composant du champ. Contrôlez qu’il s’agit bien d’un champ unique du modèle, sinon la valeur sélectionnée pourrait correspondre à plus d’un objet. Par défaut ce paramètre vaut None
, ce qui signifie que c’est la clé primaire de chaque objet qui est utilisée. Par exemple :
# No custom to_field_name
field1 = forms.ModelChoiceField(queryset=...)
produirait :
<select id="id_field1" name="field1">
<option value="obj1.pk">Object1</option>
<option value="obj2.pk">Object2</option>
...
</select>
et :
# to_field_name provided
field2 = forms.ModelChoiceField(queryset=..., to_field_name="name")
produirait :
<select id="id_field2" name="field2">
<option value="obj1.name">Object1</option>
<option value="obj2.name">Object2</option>
...
</select>
ModelChoiceField
possède également cet attribut :
iterator
¶La classe d’itération utilisée pour générer les choix du champ à partir de queryset
. Par défaut, ModelChoiceIterator
.
La méthode __str__()
du modèle sera appelée pour générer les représentations textuelles des objets à faire figurer dans les choix du champ. Pour fournir des représentations personnalisées, créez une sous-classe de ModelChoiceField
et surchargez label_from_instance
. Cette méthode reçoit un objet de modèle et doit renvoyer une chaîne représentative de l’objet. Par exemple :
from django.forms import ModelChoiceField
class MyModelChoiceField(ModelChoiceField):
def label_from_instance(self, obj):
return "My Object #%i" % obj.id
ModelMultipleChoiceField
¶ModelMultipleChoiceField
(**kwargs)¶SelectMultiple
QuerySet
vide (self.queryset.none()
)QuerySet
d’instances de modèles.required
, invalid_list
, invalid_choice
, invalid_pk_value
Le message d’erreur invalid_choice
peut contenir %(value)s
et le message invalid_pk_value
peut contenir %(pk)s
, qui seront substitués par les valeurs appropriées.
Permet la sélection d’un ou de plusieurs objets de modèles, adapté à la représentation de relations plusieurs-à-plusieurs. Comme pour ModelChoiceField
, vous pouvez utiliser label_from_instance
afin de personnaliser les représentations des objets.
Un seul paramètre est obligatoire :
queryset
¶Identique à ModelChoiceField.queryset
.
Accepte un paramètre facultatif :
to_field_name
¶Identique à ModelChoiceField.to_field_name
.
ModelMultipleChoiceField
possède également cet attribut :
iterator
¶Identique à ModelChoiceField.iterator
.
Obsolète depuis la version 3.1: Le message list
est osbolète, il a été remplacé par invalid_list
.
Par défaut, ModelChoiceField
et ModelMultipleChoiceField
utilisent ModelChoiceIterator
pour générer leur choix de champ choices
.
Lors de son itération, ModelChoiceIterator
produit des choix de tuples à 2 éléments contenant des instances ModelChoiceIteratorValue
comme premier élément value
dans chaque choix. ModelChoiceIteratorValue
enveloppe la valeur du choix tout en maintenant une référence à l’instance de modèle source pouvant être utilisée par exemple dans des implémentations de composants personnalisés pour ajouter des attributs data-* aux éléments <option>
.
Par exemple, considérons les modèles suivants :
from django.db import models
class Topping(models.Model):
name = models.CharField(max_length=100)
price = models.DecimalField(decimal_places=2, max_digits=6)
def __str__(self):
return self.name
class Pizza(models.Model):
topping = models.ForeignKey(Topping, on_delete=models.CASCADE)
Vous pouvez utiliser une sous-classe de composant Select
pour inclure la valeur de Topping.price
sous forme d’attribut HTML data-price
pour chaque élément <option>
:
from django import forms
class ToppingSelect(forms.Select):
def create_option(self, name, value, label, selected, index, subindex=None, attrs=None):
option = super().create_option(name, value, label, selected, index, subindex, attrs)
if value:
option['attrs']['data-price'] = value.instance.price
return option
class PizzaForm(forms.ModelForm):
class Meta:
model = Pizza
fields = ['topping']
widgets = {'topping': ToppingSelect}
Cela produira l’élément select pour Pizza.topping
ainsi :
<select id="id_topping" name="topping" required>
<option value="" selected>---------</option>
<option value="1" data-price="1.50">mushrooms</option>
<option value="2" data-price="1.25">onions</option>
<option value="3" data-price="1.75">peppers</option>
<option value="4" data-price="2.00">pineapple</option>
</select>
Pour des usages plus avancés, vous pouvez créer des sous-classes de ModelChoiceIterator
afin de personnaliser les choix de tuples à 2 éléments qui sont produits.
ModelChoiceIterator
¶ModelChoiceIterator
(field)¶La classes par défaut attribuée à l’attribut iterator
des champs ModelChoiceField
et ModelMultipleChoiceField
. Un objet itérable produisant des choix de tuples à 2 éléments à partir du jeu de requête.
Un seul paramètre est obligatoire :
field
¶L’instance ModelChoiceField
ou ModelMultipleChoiceField
sur laquelle itérer et qui produira les choix.
ModelChoiceIterator
possède la méthode suivante :
__iter__
()¶Produit des choix de tuples à 2 éléments, au format (value, label)
utilisé par ChoiceField.choices
. Le premier élément value
est une instance ModelChoiceIteratorValue
.
Dans les anciennes versions, le premier élément value
dans le tuple de choix était la valeur du champ elle-même au lieu d’une instance ModelChoiceIteratorValue
. Dans la plupart de cas, la substitution se fait de manière transparente, mais si vous avez besoin de la valeur de field
elle-même, utilisez plutôt l’attribut ModelChoiceIteratorValue.value
.
ModelChoiceIteratorValue
¶ModelChoiceIteratorValue
(value, instance)¶Deux paramètres sont obligatoires :
value
¶La valeur du choix. Cette valeur est utilisée pour produire l’attribut value
d’un élément HTML <option>
.
instance
¶L’instance de modèle provenant du jeu de requête. On peut accéder à cette instance dans des implémentations personnalisées de ChoiceWidget.create_option()
pour ajuster le code HTML produit.
ModelChoiceIteratorValue
possède la méthode suivante :
__str__
()¶Renvoie value
comme chaîne qui sera produite en HTML.
Si les classes Field
intégrées ne correspondent pas à vos besoins, vous pouvez créer des classes Field
personnalisées. Pour cela, créez une sous-classe de django.forms.Field
. Les seules exigences sont que la méthode clean()
doit être implémentée et que la méthode __init__()
accepte les paramètres de base mentionnés plus haut (required
, label
, initial
, widget
, help_text
).
Il est aussi possible de personnaliser la manière dont un champ est accédé en surchargeant get_bound_field()
.
déc. 07, 2021