Ce document contient toutes les références d’API de Field, y compris les détails que Django met à disposition concernant les options de champs et les types de champs.
Les paramètres suivants sont disponibles pour tous les types de champs. Tous sont facultatifs.
\nnullLien vers cette rubrique#Si la valeur est True, Django stocke les valeurs vides avec NULL dans la base de données. La valeur par défaut est False.
Évitez d’utiliser null pour des champs textuels comme CharField ou TextField. Un champ textuel avec null=True implique qu’il y a deux valeurs possibles signifiant « pas de données » : NULL` et la chaîne vide. Dans la plupart des cas, il est redondant d’avoir deux valeurs possibles indiquant qu’il n’y a pas de données. La convention dans Django est d’utiliser la chaîne vide, pas NULL. Une exception est lorsqu’un champ class:CharField possède à la fois unique=True et blank=True. Dans ce cas, null=True est nécessaire pour éviter des violations de contrainte unique quand plusieurs objets avec des valeurs vierges sont enregistrées.
Pour les champs textuels comme pour les champs non textuels, il est aussi nécessaire de définir blank=True si vous voulez autoriser les valeurs vides dans les formulaires, puisque le paramètre null ne se rapporte qu’au stockage dans la base de données (voir blank).
Si vous souhaitez accepter des valeurs null avec BooleanField, utilisez plutôt NullBooleanField.
blankLien vers cette rubrique#Si la valeur est True, le champ peut être vide. La valeur par défaut est False.
Notez que c’est différent de null. null est purement lié à la base de données, alors que blank est lié à la validation. Quand un champ possède blank=True, la validation de formulaire permet la saisie de valeurs vides. Quand un champ possède blank=False, le champ doit être obligatoirement rempli.
choicesLien vers cette rubrique#Un itérable (par exemple une liste ou un tuple) composé lui-même d’itérables de tuples binaires (par ex. [(A, B), (A, B) ...]) représentant les choix possibles pour ce champ. Si ce paramètre est présent, le composant de formulaire par défaut sera une liste déroulante contenant ces choix au lieu de la boîte de saisie de texte standard.
Le premier élément de chaque tuple est la valeur réelle à définir pour le modèle. Le second élément est la valeur visible par l’utilisateur. Par exemple :
\nYEAR_IN_SCHOOL_CHOICES = (\n ('FR', 'Freshman'),\n ('SO', 'Sophomore'),\n ('JR', 'Junior'),\n ('SR', 'Senior'),\n)\nIl est généralement conseillé de définir les choix à l’intérieur de la classe d’un modèle et de définir des constantes judicieusement nommées pour chaque valeur :
\nfrom django.db import models\n\nclass Student(models.Model):\n FRESHMAN = 'FR'\n SOPHOMORE = 'SO'\n JUNIOR = 'JR'\n SENIOR = 'SR'\n YEAR_IN_SCHOOL_CHOICES = (\n (FRESHMAN, 'Freshman'),\n (SOPHOMORE, 'Sophomore'),\n (JUNIOR, 'Junior'),\n (SENIOR, 'Senior'),\n )\n year_in_school = models.CharField(\n max_length=2,\n choices=YEAR_IN_SCHOOL_CHOICES,\n default=FRESHMAN,\n )\n\n def is_upperclass(self):\n return self.year_in_school in (self.JUNIOR, self.SENIOR)\nBien qu’il soit possible de définir une liste de choix en dehors de la classe d’un modèle, puis de s’y référer, le fait de définir les choix et leurs étiquettes à l’intérieur de la classe du modèle permet de conserver toutes ces informations avec la classe qui les exploite ainsi que de faciliter la référence à ces choix (par exemple, Student.SOPHOMORE fonctionnera partout où le modèle Student a été importé).
Vous pouvez aussi arranger les choix possibles dans des groupes nommés qui pourront être utilisés à des fins d’organisation :
\nMEDIA_CHOICES = (\n ('Audio', (\n ('vinyl', 'Vinyl'),\n ('cd', 'CD'),\n )\n ),\n ('Video', (\n ('vhs', 'VHS Tape'),\n ('dvd', 'DVD'),\n )\n ),\n ('unknown', 'Unknown'),\n)\nLe premier élément de chaque tuple est le nom utilisé pour le groupe. Le second élément est un objet itérable de tuples binaires contenant la valeur et l’étiquette à afficher pour cette option. Les options groupées peuvent être combinées à des options non groupées dans une seule liste (comme l’option unknown dans cet exemple).
\nPour chaque champ de modèle ayant l’option choices, Django ajoute une méthode pour obtenir l’étiquette à afficher selon la valeur actuelle du champ. Voir get_FOO_display() dans la documentation de l’API de base de données.
Notez que ces choix peuvent être constitués par n’importe quel objet itérable, et pas nécessairement par une liste ou un tuple. Ceci vous permet de construire dynamiquement la liste des choix. Mais si vous commencer à bidouiller l’attribut choices pour qu’il soit dynamique, il est probable qu’il soit plus judicieux d’utiliser une vraie table de base de données contenant une ForeignKey. choices est conçu pour les données statiques qui ne changent pas souvent, voire jamais.
À l’exception des cas où blank=False est défini pour le champ avec un contenu default, une étiquette contenant "---------" sera ajoutée à la liste de sélection. Pour surcharger ce comportement, ajoutez un tuple à choices contenant None. Par exemple, (None, 'Votre chaîne à afficher'). Il est aussi possible d’utiliser une chaîne vide au lieu de None lorsque c’est raisonnable, comme pour un champ CharField.
db_columnLien vers cette rubrique#Le nom de la colonne à utiliser pour ce champ dans la base de données. Si cet attribut est absent, Django utilise le nom du champ.
\nSi le nom de la colonne dans la base de données est un mot réservé en SQL ou s’il contient des caractères non autorisés dans le nom d’une variable Python (notamment, le trait d’union), ce n’est pas un souci. Django met entre guillemets les noms de table et de colonne de manière transparente.
\ndb_indexLien vers cette rubrique#Si True, une index de base de données sera créé pour ce champ.
db_tablespaceLien vers cette rubrique#Le nom de l”espace de tables de base de données à utiliser pour l’index de ce\nchamp, si ce champ est indexé. La valeur par défaut est le réglage DEFAULT_INDEX_TABLESPACE du projet, s’il est défini, ou l’attribut db_tablespace du modèle, s’il existe. Si le moteur de base\nde données ne prend pas en charge les espaces de tables, cette option est ignorée.
defaultLien vers cette rubrique#La valeur par défaut du champ. Cela peut être une valeur ou un objet exécutable. Dans ce dernier cas, l’objet est appelé lors de chaque création d’un nouvel objet.
\nLa valeur par défaut ne peut pas être un objet mutant (instance de modèle, list, set, etc.), car toutes les nouvelles instances du modèle utiliseraient une référence vers la même instance de cet objet. Au lieu de cela, imbriquez la valeur par défaut souhaitée dans un exécutable. Par exemple, si vous vouliez indiquer un dict par défaut pour un champ JSONField, utilisez une fonction :
def contact_default():\n return {"email": "to1@example.com"}\n\ncontact_info = JSONField("ContactInfo", default=contact_default)\nLes fonctions lambda ne peuvent pas être utilisées comme options de champs tels que default car elles ne peuvent pas être sérialisées par les migrations. Consultez cette dernière documentation pour d’autres mises en garde.
Pour les champs comme ForeignKey qui correspondent à des instances de modèles, les valeurs par défaut devraient être la valeur du champ qu’ils représentent (pk sauf si to_field est défini) et non pas des instances de modèles.
La valeur par défaut est utilisée lorsque de nouvelles instances de modèle sont créées et qu’aucune valeur n’est fournie pour le champ. Lorsque le champ est une clé primaire, la valeur par défaut est aussi utilisée si le champ est défini à None.
editableLien vers cette rubrique#Si False, le champ ne sera pas affiché dans l’administration de Django, ni dans d’éventuels formulaires basés sur ModelForm. Il sera aussi omis dans la phase de validation de modèle. La valeur par défaut est True.
error_messagesLien vers cette rubrique#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.
Les clés des messages d’erreur comprennent null, blank, invalid, invalid_choice, unique et unique_for_date. D’autres clés de messages d’erreur sont définies pour chaque champ de la section types de champs ci-dessous.
Ces messages d’erreur ne se propagent souvent pas aux formulaires. Voir Considérations sur les messages d’erreur des modèles.
\nhelp_textLien vers cette rubrique#Texte d’aide supplémentaire à afficher avec le composant de formulaire. Utile pour la documentation même si le champ n’est pas utilisé dans un formulaire.
\nNotez que le HTML contenu dans cette valeur n’est pas échappé dans les formulaires générés automatiquement. Cela vous permet d’inclure du HTML dans help_text si vous le souhaitez. Par\nexemple :
help_text="Please use the following format: <em>YYYY-MM-DD</em>."\nAccessoirement, vous pouvez utiliser du texte brut et django.utils.html.escape() pour échapper n’importe quel caractère spécial HTML. Assurez-vous d’échapper tout texte d’aide qui proviendrait d’utilisateurs non fiables afin d’éviter des attaques de script inter-site.
primary_keyLien vers cette rubrique#Si la valeur est True, ce champ représentera la clé primaire du modèle.
Si vous n’indiquez aucun paramètre primary_key=True dans les champs d’un modèle, Django ajoute automatiquement un champ AutoField pour constituer une clé primaire ; il n’est donc pas nécessaire de définir le paramètre primary_key=True pour un champ sauf si vous souhaitez modifier le comportement par défaut de clé primaire automatique. Pour en savoir plus, consultez Champs clé primaire automatiques.
primary_key=True implique null=False et unique=True. Une seule clé primaire est autorisée par objet.
Le champ de clé primaire est en lecture seule. Si vous modifiez la valeur de la clé primaire d’un objet existant et que vous l’enregistrez, un nouvel objet est créé en parallèle à l’ancien.
\nuniqueLien vers cette rubrique#Si la valeur est True, ce champ doit être unique dans toute la table.
Cet attribut est appliqué au niveau de la base de données ainsi que dans la validation des modèles. Si vous essayez d’enregistrer une instance d’un modèle avec une valeur d’un champ unique dupliquée, une exception django.db.IntegrityError sera levée par la méthode save() du modèle.
Cette option est valide pour tous les types de champs, sauf pour ManyToManyField et OneToOneField.
Notez que lorsque unique vaut True, il n’est pas nécessaire de définir db_index, car unique implique qu’un index sera créé.
unique_for_dateLien vers cette rubrique#Indiquez le nom d’un champ de type DateField ou DateTimeField comme valeur pour cette option, pour rendre obligatoire l’unicité de la valeur de ce champ en fonction de la valeur du champ date\nindiqué.
Par exemple, si vous avez un champ title qui a unique_for_date="pub_date", Django n’autorise pas la saisie de deux enregistrements avec le même title et la même pub_date.
Notez que si cet attribut est défini avec un objet DateTimeField, seule la partie date du champ est prise en compte. De plus, lorsque USE_TZ vaut True, le contrôle est effectué dans le fuseau horaire en cours au moment où l’objet est enregistré.
Cette contrainte est appliquée par Model.validate_unique() pendant la validation des modèles, et non pas au niveau de la base de données. Si une contrainte unique_for_date implique des champs qui ne font pas partie d’un formulaire ModelForm (par exemple si l’un des champs figure dans exclude ou que son attribut editable vaut False), Model.validate_unique() passe outre la validation de la contrainte concernée.
unique_for_monthLien vers cette rubrique#Comme unique_for_date, mais requiert que le champ soit unique en rapport au mois du champ date.
unique_for_yearLien vers cette rubrique#Comme unique_for_date et unique_for_month, mais avec l’année du champ date.
verbose_nameLien vers cette rubrique#Un nom humainement compréhensible pour le champ. Si cet attribut n’est pas renseigné, Django le crée automatiquement en utilisant le nom d’attribut du champ, en convertissant les soulignements en espaces. Voir\nnoms de champs verbeux.
\nvalidatorsLien vers cette rubrique#Une liste de validateurs à exécuter pour ce champ. Consultez la documentation des validateurs pour plus d’informations.
\nField implémente l”API d’inscription d’expressions de recherche. Cette API peut être utilisée pour personnaliser les recherches possibles pour une classe de champ et la manière d’obtenir ces recherches depuis un champ.
AutoFieldLien vers cette rubrique#Un champ IntegerField qui incrémente automatiquement sa valeur par rapport aux identifiants disponibles. Vous n’avez habituellement pas besoin d’utiliser ce champ directement ; un champ clé primaire est automatiquement ajouté au modèle s’il n’est pas explicitement défini. Voir Champs clé primaire automatiques.
BigAutoFieldLien vers cette rubrique#Un entier 64 bits, ressemblant à un AutoField sauf qu’il garantit la couverture des nombres de 1 à 9223372036854775807.
BigIntegerFieldLien vers cette rubrique#Un entier 64 bits, ressemblant à un IntegerField sauf qu’il garantit la couverture des nombres de -9223372036854775808 à 9223372036854775807. Le composant de formulaire par défaut de ce champ est un TextInput.
BinaryFieldLien vers cette rubrique#Un champ pour stocker des données binaires brutes. Il ne peut recevoir que des octets (bytes). Il faut savoir que ce champ possède des fonctionnalités restreintes. Par exemple, il n’est pas possible de filtrer un jeu de requête par une valeur BinaryField. Il n’est également pas possible d’inclure un champ BinaryField dans un formulaire ModelForm.
BooleanFieldLien vers cette rubrique#Un champ vrai/faux.
\nLe composant de formulaire par défaut de ce champ est un CheckboxInput.
Si vous devez accepter les valeurs null, utilisez plutôt NullBooleanField.
La valeur par défaut de BooleanField est None lorsque Field.default n’est pas défini.
CharFieldLien vers cette rubrique#Un champ pour les chaînes de caractères, courtes ou longues.
\nPour une grande quantité de texte, utilisez TextField.
Le composant de formulaire par défaut de ce champ est un TextInput.
CharField a un paramètre obligatoire supplémentaire :
La taille maximale (en caractères) du champ. Cette taille est définie au niveau de la base de données et appliquée lors de la validation par Django.
\nCommaSeparatedIntegerFieldLien vers cette rubrique#Un champ d’entiers séparés par une virgule. Comme pour le champ CharField, le paramètre max_length est obligatoire ; la remarque au sujet de la portabilité entre les moteurs de base de données doit elle aussi être prise en compte.
DateFieldLien vers cette rubrique#Une date, représentée en Python par une instance de datetime.date. Accepte quelques paramètres supplémentaires et facultatifs :
Assigne automatiquement la valeur du champ à la date du jour lors de chaque enregistrement de l’objet. Utile pour les horodatages de « dernière modification ». Notez que c’est toujours la date actuelle qui est utilisée ; il ne s’agit pas seulement d’une valeur par défaut que l’on peut surcharger.
\nLa mise à jour automatique de ce champ ne se produit que lors de l’appel à Model.save(). Le champ n’est pas mis à jour lors de mises à jour d’autres champs par d’autres façons comme par exemple QuerySet.update(), bien qu’il soit possible de spécifier explicitement une valeur pour ce champ lors d’une telle mise à jour.
Assigne automatiquement la valeur du champ à la date du jour lors du premier enregistrement de l’objet. Utile pour les horodatages de date de création. Notez que c’est toujours la date actuelle qui est utilisée ; il ne s’agit pas seulement d’une valeur par défaut que l’on peut surcharger. Ainsi, même si vous définissez une valeur pour ce champ lors de la création de l’objet, il sera ignoré. Si vous voulez pouvoir modifier ce champ, utilisez ce qui suit au lieu de définir auto_now_add=True:
Pour un champ DateField: default=date.today - de datetime.date.today()
Pour un champ DateTimeField: default=timezone.now - de django.utils.timezone.now()
Le composant de formulaire par défaut de ce champ est un TextInput. L’interface d’administration ajoute un calendrier JavaScript ainsi qu’un raccourci pour « Aujourd’hui ». Contient une clé supplémentaire de message d’erreur invalid_date.
Les options auto_now_add, auto_now et default sont mutuellement exclusives. Toute combinaison de ces options produira une erreur.
DateTimeFieldLien vers cette rubrique#Une date et une heure, représentées en Python par une instance de datetime.datetime. Ce champ accepte les mêmes paramètres supplémentaires que le champ DateField.
Le composant de formulaire par défaut de ce champ est un TextInput. L’interface d’administration utilise deux composants TextInput séparés avec des raccourcis JavaScript.
DecimalFieldLien vers cette rubrique#Un nombre décimal de taille fixe, représenté en Python par une instance de Decimal. Il requiert deux paramètres obligatoires :
Le nombre maximum de chiffres autorisés dans le nombre. Notez que ce nombre doit être plus grand ou égal à decimal_places.
Le nombre de décimales à stocker avec le nombre.
\nPar exemple, pour enregistrer un nombre jusqu’à 999 avec une précision de 2 chiffres après la virgule, vous devriez utiliser :
models.DecimalField(..., max_digits=5, decimal_places=2)\nEt pour enregistrer un nombre jusqu’à un milliard environ avec une précision de 10 chiffres après la virgule :
\nmodels.DecimalField(..., max_digits=19, decimal_places=10)\nLe composant de formulaire par défaut de ce champ est un NumberInput lorsque localize vaut False, ou TextInput dans le cas contraire.
DurationFieldLien vers cette rubrique#Un champ pour stocker des périodes de temps, représentées en Python par des objets timedelta. Avec PostgreSQL, le type de données utilisé est un interval et avec Oracle, le type de données est INTERVAL DAY(9) TO SECOND(6). Sinon, c’est un grand nombre entier bigint de microsecondes qui est utilisé.
EmailFieldLien vers cette rubrique#Un champ CharField qui vérifie que sa valeur est une adresse électronique valide. Il utilise EmailValidator pour valider les valeurs saisies.
FileFieldLien vers cette rubrique#Un champ de fichier à téléverser.
\n\nPossède deux paramètres facultatifs :
\nCet attribut permet de définir le répertoire de téléversement et le nom de fichier. Il peut être défini de deux manières. Dans les deux cas, la valeur est transmise à la méthode Storage.save().
Si vous indiquez une valeur textuelle, celle-ci peut contenir des chaînes de format strftime() qui seront remplacées par la date/heure du fichier téléversé (permettant ainsi de ne pas remplir exagérément le répertoire indiqué). Par exemple :
class MyModel(models.Model):\n # file will be uploaded to MEDIA_ROOT/uploads\n upload = models.FileField(upload_to='uploads/')\n # or...\n # file will be saved to MEDIA_ROOT/uploads/2015/01/30\n upload = models.FileField(upload_to='uploads/%Y/%m/%d/')\nSi vous utilisez le stockage par défaut FileSystemStorage, la valeur textuelle sera ajoutée au chemin MEDIA_ROOT pour déterminer l’emplacement du système de fichiers local où les fichiers téléversés seront stockés. Si vous utilisez un autre stockage, vérifiez la documentation de ce dernier pour savoir comment il traite upload_to.
upload_to peut aussi être un objet exécutable, comme une fonction. Il sera appelé pour obtenir le chemin de téléversement, incluant le nom du fichier. Cet objet exécutable doit accepter deux paramètres et renvoyer un chemin de type Unix (avec des barres obliques) qui sera transmis au système de stockage. Les deux paramètres sont :
Paramètre | \nDescription | \n
|---|---|
| \nUne instance du modèle où le champ Dans la plupart des cas, cet objet n’aura pas encore été enregistré dans la base de données, donc en cas d’utilisation du champ | \n
| \nLe nom donné originellement au fichier. Sa prise en compte dans la détermination du chemin d’accès final n’est pas obligatoire. | \n
Par exemple :
\ndef user_directory_path(instance, filename):\n # file will be uploaded to MEDIA_ROOT/user_<id>/<filename>\n return 'user_{0}/{1}'.format(instance.user.id, filename)\n\nclass MyModel(models.Model):\n upload = models.FileField(upload_to=user_directory_path)\nUn objet de stockage, qui prend en charge l’enregistrement et la récupération des fichiers. Consultez Gestion des fichiers pour plus de détails sur la manière de fournir un tel objet.
\nLe composant de formulaire par défaut de ce champ est un ClearableFileInput.
L’utilisation d’un FileField ou d’un ImageField (voir ci-après) dans une classe de modèle se fait en quelques étapes :
Dans votre fichier de réglages, vous devez indiquer dans MEDIA_ROOT le chemin d’accès absolu vers un répertoire où Django enregistrera les fichiers téléversés (pour des raisons de performance, ces fichiers ne sont pas stockés en base de données). Indiquez dans MEDIA_URL l’URL publique de base correspondant à ce répertoire. Assurez vous que ce répertoire est accessible en écriture par l’utilisateur du serveur Web.
Ajoutez le champ FileField ou ImageField à votre modèle, en définissant l’option upload_to pour indiquer dans quel sous-répertoire de MEDIA_ROOT les fichiers doivent être téléversés.
Tout ce qui sera stocké dans la base de données est le chemin d’accès au fichier (relatif à MEDIA_ROOT). Il est très commode et courant d’utiliser l’attribut url offert par Django. Par exemple, considérant un ImageField nommé mug_shot, vous pouvez obtenir l’URL absolue de cette image dans un gabarit avec {{ object.mug_shot.url }}.
Par exemple, supposons que MEDIA_ROOT contient '/home/media' et que la valeur de upload_to est 'photos/%Y/%m/%d'. La partie '%Y/%m/%d' de upload_to est du formatage strftime() ; '%Y' correspond à l’année sur quatre chiffres, '%m' correspond au mois sur deux chiffres et '%d' correspond au jour sur deux chiffres. Si vous téléversez un fichier le 15 janvier 2007, il sera enregistré dans le répertoire /home/media/photos/2007/01/15.
Si vous souhaitez obtenir le nom du fichier téléversé ou sa taille, vous pouvez utiliser ses attributs\nname et size respectivement. Pour plus d’informations sur les attributs et méthodes disponibles, consultez la référence de la classe File et le guide thématique Gestion des fichiers.
L’URL relative du fichier téléversé peut être obtenue en utilisant l’attribut url. En interne, c’est la méthode url() de la classe Storage sous-jacente qui est appelée.
Notez que chaque fois que vous avez affaire à des fichiers téléversés, vous devriez faire très attention à l’endroit où vous les enregistrez ainsi qu’à leur type, pour éviter toute faille de sécurité. Vérifiez tous les fichiers téléversés, ainsi vous serez sûr que ces fichiers sont bien ce qu’ils doivent être. Par exemple, si vous laissez quelqu’un téléverser aveuglément des fichiers sans les valider à destination d’un répertoire se trouvant sous la racine des documents de votre serveur Web, cette personne pourrait envoyer un script CGI ou PHP et le faire exécuter en visitant son URL sur votre site. Ne permettez pas cela.
\nNotez également que même l’envoi d’un fichier HTML peut poser des problèmes de sécurité équivalents aux attaques XSS ou CSRF, car ces fichiers peuvent être interprétés par un navigateur (même si le serveur n’est pas impliqué dans ce cas).
\nLes instances de FileField sont créées en tant que colonnes varchar dans la base de données avec une longueur par défaut maximale de 100 caractères. Comme pour d’autres champs, vous pouvez modifier la taille maximale en utilisant le paramètre max_length.
FileField et FieldFileLien vers cette rubrique#Lorsque vous accédez à un FileField d’un modèle, vous recevez une instance de FieldFile comme substitut d’accès au fichier sous-jacent.
L’API de FieldFile reflète celle de File, avec une différence clé : *l’objet adapté par la classe n’est pas forcément une adaptation de l’objet fichier natif de Python. C’est au contraire une adaptation du résultat de la méthode Storage.open(), qui peut être un objet File ou une implémentation d’un stockage personnalisé de l’API de File.
En plus de l’API héritée de File, comme read() et write(), FieldFile comprend plusieurs méthodes pouvant être utilisées pour interagir avec le fichier sous-jacent :
Le nom du fichier contenant le chemin relatif depuis la racine de Storage du champ FileField associé.
Le résultat de la méthode sous-jacente Storage.size().
Une propriété en lecture seule pour accéder à l’URL relative du fichier, au travers de l’appel à la méthode url() de la classe Storage sous-jacente.
Ouvre ou réouvre le fichier associé à cette instance dans le mode spécifié. Au contraire de la méthode Python standard open(), elle ne renvoie pas de descripteur de fichier.
Comme le fichier sous-jacent est ouvert implicitement lors de son accès, il peut être inutile d’appeler cette méthode, sauf si l’on veut réinitialiser le pointeur du fichier sous-jacent ou que l’on veut changer le mode.
Même comportement que la méthode file.close() standard de Python et ferme le fichier associé à l’instance actuelle.
Cette méthode accepte un nom de fichier et le contenu du fichier, les transmet à la classe de stockage du champ puis associe le fichier ainsi stocké avec le champ du modèle. Si vous souhaitez attribuer manuellement des données de fichier avec des instances FileField d’un modèle, la méthode save() est utilisée pour rendre persistantes ces données de fichier.
Requiert deux paramètres obligatoires : name correspondant au nom du fichier et content qui représente un objet contenant le contenu du fichier. Le paramètre facultatif save indique si l’instance de modèle doit être enregistrée après la modification du fichier associé à ce champ. Sa valeur par défaut est True.
Notez que le paramètre content doit être une instance de django.core.files.File, et non pas de l’objet file de Python. Vous pouvez construire une instance de File à partir d’un objet Python file existant comme ceci :
from django.core.files import File\n# Open an existing file using Python's built-in open()\nf = open('/path/to/hello.world')\nmyfile = File(f)\nOu il est aussi possible de le construire à partir d’une chaîne de caractères Python comme ceci :
\nfrom django.core.files.base import ContentFile\nmyfile = ContentFile("hello world")\nPour plus d’informations, voir Gestion des fichiers.
\nSupprime le fichier associé à cette instance et efface tous les attributs du champ. Remarque : cette méthode ferme le fichier s’il se trouve être ouvert lorsque delete() est appelée.
Le paramètre facultatif save indique si l’instance de modèle doit être enregistrée après la suppression du fichier associé à ce champ. Sa valeur par défaut est True.
Notez que lorsqu’un modèle est supprimé, les fichiers liés ne sont pas supprimés. Si vous devez effacer les fichiers orphelins, c’est à vous de le faire (par exemple avec une commande de gestion personnalisée lancée manuellement ou programmée de manière périodique par un outil tel que cron).
\nFilePathFieldLien vers cette rubrique#Un CharField dont les choix sont limités aux noms de fichiers dans un répertoire déterminé du système de fichiers. Il possède trois paramètres spéciaux, dont le premier est obligatoire :
Obligatoire. Le chemin d’accès absolu vers le répertoire dont le contenu fournit la source des choix du FilePathField. Exemple : "/home/images".
Facultatif. Une expression régulière sous forme de chaîne de caractères qui sera utilisée par FilePathField pour filtrer les noms de fichier. Notez que cette expression régulière sera appliquée au nom de fichier seul, et non pas à son chemin d’accès absolu. Exemple : "foo.*\\.txt$" correspond au fichier foo23.txt, mais pas à bar.txt ni à foo23.png.
Facultatif. Vaut True ou False (valeur par défaut). Indique si tous les sous-répertoires de path doivent être inclus.
Facultatif. Vaut True (valeur par défaut) ou False. 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.
Facultatif. Vaut True ou False (valeur par défaut). 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.
Ces paramètre peuvent bien sûr être utilisés conjointement.
\nLe piège potentiel est que match s’applique au nom du fichier uniquement, et non pas au chemin d’accès absolu. Donc, dans cet exemple :
FilePathField(path="/home/images", match="foo.*", recursive=True)\n… correspondra à /home/images/foo.png mais pas à /home/images/foo/bar.png car match s’applique uniquement au nom du fichier (foo.png et bar.png).
Les instances de FilePathField sont créées en tant que colonnes varchar dans la base de données avec une longueur par défaut maximale de 100 caractères. Comme pour d’autres champs, vous pouvez modifier la taille maximale en utilisant le paramètre max_length.
FloatFieldLien vers cette rubrique#Un nombre flottant représenté en Python par une instance de float.
Le composant de formulaire par défaut de ce champ est un NumberInput lorsque localize vaut False, ou TextInput dans le cas contraire.
ImageFieldLien vers cette rubrique#Hérite de tous les attributs et méthodes de FileField, mais valide également que l’objet téléversé est une image valide.
En complément des attributs spéciaux disponibles pour FileField, un champ ImageField possède aussi les attributs height et width.
Pour faciliter l’interrogation de ces attributs, ImageField possède deux attributs facultatifs supplémentaires :
Le nom d’un champ du modèle qui sera automatiquement renseigné avec la hauteur de l’image à chaque enregistrement de l’instance du modèle.
\nLe nom d’un champ du modèle qui sera automatiquement renseigné avec la largeur de l’image à chaque enregistrement de l’instance du modèle.
\nNécessite la bibliothèque Pillow.
\nLes instances de ImageField sont créées en tant que colonnes varchar dans la base de données avec une longueur par défaut maximale de 100 caractères. Comme pour d’autres champs, vous pouvez modifier la taille maximale en utilisant le paramètre max_length.
Le composant de formulaire par défaut de ce champ est un ClearableFileInput.
IntegerFieldLien vers cette rubrique#Un nombre entier. Les valeurs de -2147483648 à 2147483647 sont acceptées par toutes les base de données prises en charge par Django. Le composant de formulaire par défaut de ce champ est un NumberInput lorsque localize vaut False, ou TextInput dans le cas contraire.
GenericIPAddressFieldLien vers cette rubrique#Une adresse IPv4 ou IPv6 au format textuel (par ex. 192.0.2.30 ou 2a02:42fe::4). Le composant de formulaire par défaut de ce champ est un TextInput.
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.
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'.
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'.
Si vous autorisez les valeurs vierges, vous devez aussi autoriser les valeurs nulles, car les valeurs vierges sont stockées par une valeur nulle.
\nNullBooleanFieldLien vers cette rubrique#Comme un champ BooleanField, mais autorise la valeur NULL comme choix possible. Préférez ce champ à un BooleanField avec l’option null=True. Le composant de formulaire par défaut de ce champ est un NullBooleanSelect.
PositiveIntegerFieldLien vers cette rubrique#Comme un champ IntegerField, mais doit être un entier positif ou zéro (0). Les valeurs de 0 à 2147483647 sont acceptées par toutes les base de données prises en charge par Django. La valeur 0 est acceptée pour des raisons de rétrocompatibilité.
PositiveSmallIntegerFieldLien vers cette rubrique#Comme un PositiveIntegerField, mais n’autorise que des valeurs plus petites qu’un certain plafond (dépendant du moteur de base de données). Toutes les valeurs de 0 à 32767 sont acceptées par toutes les bases de données prises en charge officiellement par Django.
SlugFieldLien vers cette rubrique#Slug est un terme anglophone de journalisme. Un slug est une brève étiquette d’un contenu, composée uniquement de lettres, de chiffres, de soulignements ou de tirets. Ils sont généralement utilisés dans les URL.
\nComme pour le champ CharField, vous pouvez indiquer le paramètre max_length (lisez les notes à propos de la portabilité entre bases de données de max_length). Si max_length n’est pas précisé, Django utilise la valeur 50 par défaut.
L’option Field.db_index est implicitement égale à True.
Il est souvent pratique de pouvoir automatiquement renseigner un SlugField en se basant sur la valeur d’un autre attribut. Vous pouvez le faire dans l’interface d’administration en utilisant prepopulated_fields.
Si la valeur est True, le champ accepte des lettres Unicode en plus des lettres ASCII de base. La valeur par défaut est False.
SmallIntegerFieldLien vers cette rubrique#Comme un IntegerField, mais n’autorise que des valeurs plus petites qu’un certain plafond (dépendant du moteur de base de données). Toutes les valeurs de -32768 jusqu’à 32767 sont acceptées par toutes les bases de données prises en charge officiellement par Django.
TextFieldLien vers cette rubrique#Un champ de texte long. Le composant de formulaire par défaut de ce champ est un Textarea.
Si vous indiquez un attribut max_length, celui-ci se répercute sur le composant Textarea du champ de formulaire généré automatiquement. Cependant, la limite n’est pas imposée au niveau du modèle, ni de la base de données. Pour cela, utilisez plutôt un champ CharField.
TimeFieldLien vers cette rubrique#Une heure, représentée en Python par une instance de datetime.time. Ce champ accepte les mêmes options d’auto-complétion qu’un champ DateField.
Le composant de formulaire par défaut de ce champ est un TextInput. L’interface d’administration ajoute des raccourcis JavaScript.
URLFieldLien vers cette rubrique#Un champ CharField pour les URL.
Le composant de formulaire par défaut de ce champ est un TextInput.
Comme pour les autres sous-classes de CharField, URLField accepte le paramètre facultatif max_length. Si vous ne renseignez pas la valeur de max_length, elle prend la valeur 200 par défaut.
UUIDFieldLien vers cette rubrique#Un champ pour stocker des identifiants universels uniques (UUID). Utilise la classe Python UUID. Avec PostgreSQL, le type de données uuid est employé, sinon c’est un type char(32).
Les identifiants universels uniques sont une bonne alternative aux champs AutoField pour les clés primaires primary_key. La base de données ne produit pas de UUID à votre place, c’est pourquoi il est recommandé d’utiliser default:
import uuid\nfrom django.db import models\n\nclass MyUUIDModel(models.Model):\n id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)\n # other fields\nNotez que nous passons bien un objet exécutable (sans les parenthèses) à default, et non pas une instance de UUID.
Field est une classe abstraite qui représente une colonne de table de base de données. Django utilise des champs pour créer une table de base de données (db_type()), pour faire correspondre des types Python à une base de données (get_prep_value()) et inversement (from_db_value()).
Un champ est donc une pièce essentielle dans différentes API de Django, notamment pour les modèles et les jeux de requête.
Dans les modèles, un champ est instancié comme attribut de classe et représente une colonne de table de base de données, voir Modèles. Il possède des attributs comme null et unique, ainsi que des méthodes que Django utilise pour faire correspondre la valeur du champ à des valeurs spécifiques à la base de données.
Un champ Field est une sous-classe de RegisterLookupMixin, ce qui fait qu’à la fois Transform et Lookup peuvent y être inscrits pour être exploités dans les requêtes QuerySet (par ex. nom_champ__exact="foo"). Toutes les :ref:expressions de requête intégrées <field-lookups>` sont inscrites par défaut.
Tous les types de champs fournis par Django, tels que CharField, sont des implémentations dérivées de Field. Si vous avez besoin d’un nouveau type de champ, vous pouvez soit hériter d’un des champs de Django ou écrire une classe Field à partir de zéro. Dans tous les cas, consultez Écriture de champs de modèles personnalisés.
Une description verbeuse du champ, par exemple pour l’application django.contrib.admindocs.
La description peut prendre la forme :
\ndescription = _("String (up to %(max_length)s)")\noù les paramètres sont interpolés à partir du __dict__ du champ.
Pour faire correspondre un champ Field à un type particulier d’une base de données, Django expose plusieurs méthodes :
Renvoie une chaîne nommant ce champ à l’usage du moteur de base de données spécifique. Par défaut, c’est le nom de la classe qui est renvoyé.
\nVoir Émulation de types de champs intégrés pour son utilisation dans des types de champs personnalisés.
\nRenvoie le type de donnée de la colonne de la base de données de la classe Field, prenant en compte l’objet connection.
Voir Types de base de données personnalisés pour son utilisation dans des types de champs personnalisés.
\nRenvoie le type de donnée de la colonne de la base de données, tel que ForeignKey et OneToOneField qui pointent vers Field, prenant en compte l’objet connection.
Voir Types de base de données personnalisés pour son utilisation dans des types de champs personnalisés.
\nIl existe trois situations principales où Django a besoin de faire interagir le moteur de base de données et les champs :
\nlorsqu’il interroge la base de données (valeur Python -> valeur pour le moteur de base de données)
lorsqu’il charge des données à partir de la base de données (valeur du moteur de base de données -> valeur Python)
lorsqu’il enregistre vers la base de données (valeur Python -> valeur pour le moteur de base de données)
Lors d’une interrogation, get_db_prep_value() et get_prep_value() sont utilisés :
value est la valeur actuelle de l’attribut de modèle, et la méthode doit renvoyer les données dans un format préparé spécialement pour être utilisé comme paramètre de la requête.
Voir Conversion d’objets Python en valeurs de requête pour son utilisation.
\nConvertit value vers une valeur spécifique au moteur de base de données. Par défaut, il renvoie value si prepared=True et get_prep_value() sinon.
Voir Conversion de valeurs de requête en valeurs de base de données pour son utilisation.
\nLors du chargement de données, from_db_value() est utilisé :
Convertit la valeur renvoyée par la base de données en un objet Python. C’est l’inverse de get_prep_value().
Cette méthode n’est pas utilisée pour la plupart des champs intégrés, car le moteur de base de données renvoie déjà le bon type Python, ou le moteur se charge lui-même de la conversion.
\nVoir Conversion de valeurs en objets Python pour son utilisation.
\n\nLors de l’enregistrement, pre_save() et get_db_prep_save() sont utilisés :
Comme pour get_db_prep_value(), mais appelé lorsque la valeur du champ doit être enregistrée dans la base de données. Renvoie par défaut get_db_prep_value().
Méthode appelée avant get_db_prep_save() pour préparer la valeur avant d’être enregistrée (par ex. pour DateField.auto_now).
model_instance est l’instance à laquelle appartient ce champ et add indique si l’instance est enregistrée dans la base de données pour la première fois.
Cette méthode doit renvoyer la valeur de l’attribut correspondant de model_instance pour ce champ. Le nom d’attribut est dans self.attname (défini par Field).
Voir Pré-traitement des valeurs avant enregistrement pour son utilisation.
\nLes champs reçoivent souvent leur valeur dans un type différent, que ce soit par la sérialisation ou par les formulaires.
\nConvertit la valeur dans le bon objet Python. Elle opère à l’inverse de value_to_string() et est également appelée dans clean().
Voir Conversion de valeurs en objets Python pour son utilisation.
\nEn plus de l’enregistrement dans la base de données, le champ doit aussi savoir comment sérialiser sa valeur :
\nConvertit obj en une chaîne. Utilisé pour sérialiser la valeur du champ.
Voir Conversion des données de champs pour la sérialisation pour son utilisation.
\nLors de l’utilisation de formulaires de modèles, le champ Field doit savoir quel champ de formulaire doit le représenter en appelant :
Renvoie le champ de formulaire django.forms.Field utilisé par défaut pour ce champ dans un formulaire ModelForm.
Par défaut, si form_class et choices_form_class valent les deux None, c’est un champ CharField qui sera renvoyé. Si le champ possède l’attribut choices et que choices_form_class n’est pas renseigné, ce sera un champ TypedChoiceField.
Voir Sélection du champ de formulaire pour un champ de modèle pour son utilisation.
\nRenvoie un tuple à 4 éléments avec suffisamment d’informations pour recréer le champ :
\nLe nom du champ dans le modèle.
Le chemin d’importation du champ (par ex. "django.db.models.IntegerField"). Il est recommandé d’indiquer la version la plus portable, donc moins le chemin est spécifique, mieux c’est.
Une liste de paramètres positionnels.
Un dictionnaire de paramètres nommés.
Cette méthode doit être ajoutée aux champs créés avant la version 1.7 afin de pouvoir migrer leurs données en utilisant les Migrations.
\nChaque instance Field contient plusieurs attributs qui permettent d’inspecter son comportement. Utilisez ces attributs plutôt que de vous baser sur des contrôles de type isinstance lorsque vous avez besoin d’écrire du code qui dépend de la fonctionnalité d’un champ. Ces attributs peuvent être utilisée conjointement avec l”API Model._meta pour préciser une recherche de types de champs spécifiques. Les champs de modèles personnalisés devraient implémenter ces drapeaux.
Drapeau booléen indiquant si le champ a été créé automatiquement, comme pour le champ OneToOneField utilisé dans un contexte d’héritage de modèles.
Drapeau booléen indiquant si le champ est associé à une colonne de base de données.
\nDrapeau booléen indiquant si un champ est utilisé pour appuyer la fonctionnalité d’un autre champ non masqué (par ex. les champs content_type et object_id qui constituent une relation GenericForeignKey). Le drapeau hidden est utilisé pour distinguer ce qui constitue le sous-ensemble public des champs du modèle de tous les champs du modèle.
Drapeau booléen indiquant si un champ contient des références à un ou plusieurs autres modèles pour sa fonctionnalité (par ex. ForeignKey, ManyToManyField, OneToOneField, etc.).
Renvoie le modèle dans lequel le champ est défini. Si un champ est défini dans la classe parent d’un modèle, model désigne alors la classe parente, et non pas la classe de l’instance.
Ces attributs sont utilisés pour interroger la cardinalité et d’autres détails d’une relation. Ces attributs sont présents sur tous les champs ; cependant, ils n’ont des valeurs booléennes (plutôt que None) que si le champ est de type relationnel (Field.is_relation=True).
Drapeau booléen qui vaut True si le champ est une relation plusieurs-à-plusieurs ; False sinon. Le seul champ inclus dans Django pour lequel cet attribut vaut True est ManyToManyField.
Drapeau booléen qui vaut True si le champ est une relation plusieurs-à-un, comme pour un champ ForeignKey ; False sinon.
Drapeau booléen qui vaut True si le champ est une relation un-à-plusieurs, comme pour GenericRelation ou la contrepartie d’une clé ForeignKey ; False sinon.
Drapeau booléen qui vaut True si le champ est une relation un-à-un, comme pour un champ OneToOneField ; False sinon.
Pointe vers le modèle en lien avec le champ. Par exemple, Author dans ForeignKey(Author, on_delete=models.CASCADE). Le related_model d’une clé GenericForeignKey vaut toujours None.