Skip to main content

模型字段引用

本文档包含 Field 的所有API参考,包括 field optionsfield types Django提供。

参见

如果内置字段没有做到这一点,您可以尝试 django-localflavor文档),它包含对特定国家和文化有用的各种代码。

此外,你可以很容易地 编写自己的自定义模型字段

注解

技术上,这些模型在 django.db.models.fields 中定义,但为了方便,它们被导入 django.db.models;标准惯例是使用 from django.db import models 并将字段称为 models.<Foo>Field

字段选项

以下参数适用于所有字段类型。所有都是可选的。

null

Field.null

如果 True,Django将在数据库中将空值存储为 NULL。默认为 False

避免在基于字符串的字段(如 CharFieldTextField)上使用 null,因为空字符串值将始终存储为空字符串,而不是 NULL。如果基于字符串的字段具有 null=True,则意味着它对于“无数据”具有两个可能的值:NULL 和空字符串。在大多数情况下,对于“无数据”有两个可能的值是多余的: Django约定是使用空字符串,而不是 NULL

对于基于字符串和非字符串的字段,如果您希望在表单中允许空值,则还需要设置 blank=True,因为 null 参数只影响数据库存储(请参阅 blank)。

注解

当使用Oracle数据库后端时,值 NULL 将被存储以表示空字符串,而不管此属性。

如果要使用 BooleanField 接受 null 值,请改用 NullBooleanField

blank

Field.blank

如果 True,该字段允许为空。默认值为 False

请注意,这不同于 nullnull 纯粹是数据库相关的,而 blank 是与验证相关的。如果字段具有 blank=True,则表单验证将允许输入空值。如果字段具有 blank=False,则该字段将是必需的。

choices

Field.choices

一个可迭代的(例如,列表或元组)本身由恰好两个项目(例如 [(A, B), (A, B) ...])的迭代组成,以用作该字段的选择。如果给出了这一点,默认表单窗口小部件将是具有这些选项的选择框,而不是标准文本字段。

每个元组中的第一个元素是要在模型上设置的实际值,第二个元素是人类可读的名称。例如:

YEAR_IN_SCHOOL_CHOICES = (
    ('FR', 'Freshman'),
    ('SO', 'Sophomore'),
    ('JR', 'Junior'),
    ('SR', 'Senior'),
)

通常,最好在模型类中定义选择,并为每个值定义一个适当命名的常量:

from django.db import models

class Student(models.Model):
    FRESHMAN = 'FR'
    SOPHOMORE = 'SO'
    JUNIOR = 'JR'
    SENIOR = 'SR'
    YEAR_IN_SCHOOL_CHOICES = (
        (FRESHMAN, 'Freshman'),
        (SOPHOMORE, 'Sophomore'),
        (JUNIOR, 'Junior'),
        (SENIOR, 'Senior'),
    )
    year_in_school = models.CharField(
        max_length=2,
        choices=YEAR_IN_SCHOOL_CHOICES,
        default=FRESHMAN,
    )

    def is_upperclass(self):
        return self.year_in_school in (self.JUNIOR, self.SENIOR)

虽然可以在模型类外部定义选项列表,然后引用它,然后在模型类中定义每个选项的选项和名称,将所有信息与使用它的类保持在一起,并使选择容易引用例如,Student.SOPHOMORE 将在 Student 模型被导入的任何地方工作)。

您还可以将可用选项收集到可用于组织目的的命名组中:

MEDIA_CHOICES = (
    ('Audio', (
            ('vinyl', 'Vinyl'),
            ('cd', 'CD'),
        )
    ),
    ('Video', (
            ('vhs', 'VHS Tape'),
            ('dvd', 'DVD'),
        )
    ),
    ('unknown', 'Unknown'),
)

每个元组中的第一个元素是要应用于组的名称。第二个元素是一个2元组的迭代,每个2元组包含一个值和一个人类可读的选项名称。分组选项可以与单个列表(例如本示例中的 unknown 选项)中的未分组选项组合。

对于具有 choices 集合的每个模型字段,Django将添加一个方法来检索字段的当前值的人工可读名称。请参阅数据库API文档中的 get_FOO_display()

注意,选择可以是任何可迭代对象 - 不一定是列表或元组。这允许您动态构建选项。但是,如果你发现自己黑客 choices 是动态的,你可能最好使用一个合适的数据库表与 ForeignKeychoices 用于静态数据,如果有的话,变化不大。

除非 blank=Falsedefault 一起设置在字段上,否则将使用选择框呈现包含 "---------" 的标签。要覆盖此行为,请向包含 Nonechoices 添加元组;例如 (None, 'Your String For Display')。或者,您可以使用空字符串,而不是 None,这是有意义的 - 例如在 CharField

db_column

Field.db_column

要用于此字段的数据库列的名称。如果没有给出,Django将使用字段的名称。

如果您的数据库列名称是SQL保留字,或包含Python变量名中不允许的字符,特别是连字符 - 没关系。 Django在后台引用列和表名。

db_index

Field.db_index

如果 True,将为此字段创建数据库索引。

db_tablespace

Field.db_tablespace

要用于此字段索引的 数据库表空间 的名称(如果此字段已建立索引)。默认值是项目的 DEFAULT_INDEX_TABLESPACE 设置(如果设置)或模型的 db_tablespace (如果有)。如果后端不支持索引的表空间,则会忽略此选项。

default

Field.default

字段的默认值。这可以是值或可调用对象。如果可调用,它将在每次创建一个新对象时被调用。

默认值不能是可变对象(模型实例,listset 等),因为对该对象的同一实例的引用将用作所有新模型实例中的默认值。相反,在可调用中包装所需的默认值。例如,如果要为 JSONField 指定默认 dict,请使用函数:

def contact_default():
    return {"email": "to1@example.com"}

contact_info = JSONField("ContactInfo", default=contact_default)

lambda s不能用于像 default 这样的字段选项,因为它们不能是 通过迁移序列化。请参阅其他注意事项的文档。

对于映射到模型实例的 ForeignKey 等字段,默认值应为它们引用的字段的值(除非设置了 to_field,否则为 pk)而不是模型实例。

创建新模型实例并且未为字段提供值时,将使用默认值。当字段是主键时,当字段设置为 None 时,也使用默认值。

editable

Field.editable

如果 False,该字段将不会显示在管理员或任何其他 ModelForm。它们也在 模型验证 期间跳过。默认为 True

error_messages

Field.error_messages

error_messages 参数允许您覆盖字段将引发的默认消息。传入具有与要覆盖的错误消息匹配的键的字典。

错误消息键包括 nullblankinvalidinvalid_choiceuniqueunique_for_date。在下面的 Field types 部分中为每个字段指定了其他错误消息键。

help_text

Field.help_text

额外的“帮助”文本与窗体小部件一起显示。它对文档很有用,即使您的字段未在表单上使用。

请注意,此值是在自动生成的表单中转义的 not HTML。这使您可以在 help_text 中包含HTML,如果您愿意的话。例如:

help_text="Please use the following format: <em>YYYY-MM-DD</em>."

或者,您可以使用纯文本和 django.utils.html.escape() 来转义任何HTML特殊字符。确保您转义可能来自不受信任的用户的任何帮助文本,以避免跨站点脚本攻击。

primary_key

Field.primary_key

如果是 True,此字段是模型的主键。

如果您没有为模型中的任何字段指定 primary_key=True,Django将自动添加一个 AutoField 来保存主键,因此您不需要在任何字段上设置 primary_key=True,除非要覆盖默认主键行为。更多,见 自动主键字段

primary_key=True 意味着 null=Falseunique=True。对象上只允许使用一个主键。

主键字段为只读。如果更改现有对象上主键的值,然后保存,将在旧对象旁边创建一个新对象。

unique

Field.unique

如果是 True,该字段在整个表中必须是唯一的。

这是在数据库级别和模型验证。如果您尝试在 unique 字段中保存具有重复值的模型,则 django.db.IntegrityError 将由模型的 save() 方法生成。

此选项对除 ManyToManyFieldOneToOneFieldFileField 之外的所有字段类型有效。

注意,当 uniqueTrue 时,您不需要指定 db_index,因为 unique 意味着创建索引。

unique_for_date

Field.unique_for_date

将此设置为 DateFieldDateTimeField 的名称,以要求该字段对于日期字段的值是唯一的。

例如,如果您有一个具有 unique_for_date="pub_date" 的字段 title,则Django将不允许输入具有相同 titlepub_date 的两个记录。

请注意,如果将此设置为指向 DateTimeField,则只会考虑字段的日期部分。此外,当 USE_TZTrue 时,将在保存对象时在 当前时区 中执行检查。

这由 Model.validate_unique() 在模型验证期间强制执行,但不在数据库级别。如果任何 unique_for_date 约束涉及不是 ModelForm 的一部分的字段(例如,如果其中一个字段在 exclude 中列出或具有 editable=False),则 Model.validate_unique() 将跳过该特定约束的验证。

unique_for_month

Field.unique_for_month

unique_for_date,但需要字段是独一无二的月份。

unique_for_year

Field.unique_for_year

unique_for_dateunique_for_month

verbose_name

Field.verbose_name

字段的人工可读名称。如果没有给出详细名称,Django将使用字段的属性名称自动创建它,将下划线转换为空格。见 详细字段名称

validators

Field.validators

要为此字段运行的验证器列表。有关详细信息,请参阅 验证器文档

注册和获取查找

Field 实现 查找注册API。该API可用于自定义哪些查找可用于字段类,以及如何从字段获取查找。

字段类型

AutoField

class AutoField(**options)[源代码]

IntegerField 根据可用ID自动递增。你通常不需要直接使用这个;如果没有指定,主键字段将自动添加到模型中。见 自动主键字段

BigAutoField

class BigAutoField(**options)
New in Django 1.10.

一个64位整数,非常类似于 AutoField,除了它保证适合从 19223372036854775807 的数字。

BigIntegerField

class BigIntegerField(**options)[源代码]

一个64位整数,非常类似于 IntegerField,除了它保证适合从 -92233720368547758089223372036854775807 的数字。此字段的默认表单窗口小部件是 TextInput

BinaryField

class BinaryField(**options)[源代码]

用于存储原始二进制数据的字段。它只支持 bytes 分配。请注意,此字段的功能有限。例如,不能根据 BinaryField 值过滤查询集。也不可能在 ModelForm 中包括 BinaryField

滥用 BinaryField

虽然您可能会考虑将文件存储在数据库中,但在99%的情况下,它是不好的设计。此字段是 not,用于替换正确的 静态文件 处理。

BooleanField

class BooleanField(**options)[源代码]

真/假字段。

此字段的默认表单窗口小部件是 CheckboxInput

如果您需要接受 null 值,则使用 NullBooleanField

Field.default 未定义时,BooleanField 的默认值为 None

CharField

class CharField(max_length=None, **options)[源代码]

字符串字段,用于小到大字符串。

对于大量的文本,请使用 TextField

此字段的默认表单窗口小部件是 TextInput

CharField 有一个额外的必需参数:

CharField.max_length

字段的最大长度(以字符为单位)。 max_length在数据库级别和Django的验证中强制执行。

注解

如果您正在编写一个必须可移植到多个数据库后端的应用程序,那么您应该注意,有些后端存在 max_length 限制。有关详细信息,请参阅 数据库后端记录

MySQL用户

如果你使用这个字段与MySQLdb 1.2.2和 utf8_bin 排序规则(这是默认的 not),有一些问题需要注意。有关详细信息,请参阅 MySQL数据库笔记

CommaSeparatedIntegerField

class CommaSeparatedIntegerField(max_length=None, **options)[源代码]

1.9 版后已移除: 此字段已弃用,赞成 CharFieldvalidators=[ validate_comma_separated_integer_list ]

由逗号分隔的整数字段。如在 CharField 中,需要 max_length 参数,并且应该注意关于数据库可移植性的注释。

DateField

class DateField(auto_now=False, auto_now_add=False, **options)[源代码]

日期,由 datetime.date 实例在Python中表示。有一些额外的可选参数:

DateField.auto_now

每次保存对象时,自动将字段设置为现在。用于“最后修改”的时间戳。注意当前日期是使用 always;它不只是一个默认值,你可以覆盖。

该字段仅在调用 Model.save() 时自动更新。在以其他方式(例如 QuerySet.update())更新其他字段时,不会更新该字段,但您可以在此类更新中为字段指定自定义值。

DateField.auto_now_add

在首次创建对象时自动将字段设置为现在。用于创建时间戳。注意当前日期是使用 always;它不只是一个默认值,你可以覆盖。因此,即使在创建对象时为此字段设置了一个值,它也将被忽略。如果您想要修改此字段,请设置以下内容而不是 auto_now_add=True

此字段的默认表单窗口小部件是 TextInput。管理员添加一个JavaScript日历和一个“今天”的快捷方式。包括一个额外的 invalid_date 错误消息键。

选项 auto_now_addauto_nowdefault 是互斥的。这些选项的任何组合将导致错误。

注解

按照目前的实现,将 auto_nowauto_now_add 设置为 True 将使该字段具有 editable=Falseblank=True 设置。

注解

auto_nowauto_now_add 选项将始终在创建或更新时使用 默认时区 中的日期。如果你需要不同的东西,你可能想考虑简单地使用自己的可调用的默认值或覆盖 save(),而不是使用 auto_nowauto_now_add;或者使用 DateTimeField 而不是 DateField 并且决定如何处理在显示时间从日期时间到日期的转换。

DateTimeField

class DateTimeField(auto_now=False, auto_now_add=False, **options)[源代码]

日期和时间,由Python在 datetime.datetime 实例中表示。采用与 DateField 相同的额外参数。

此字段的默认表单窗口小部件是单个 TextInput。管理员使用两个单独的 TextInput 小部件与JavaScript快捷方式。

DecimalField

class DecimalField(max_digits=None, decimal_places=None, **options)[源代码]

一个固定精度的十进制数,由Python在 Decimal 实例中表示。有两个 需要 参数:

DecimalField.max_digits

数字中允许的最大位数。请注意,此数字必须大于或等于 decimal_places

DecimalField.decimal_places

要存储的数字的小数位数。

例如,要存储高达 999 的数字,分辨率为2位小数,请使用:

models.DecimalField(..., max_digits=5, decimal_places=2)

并且存储高达约十亿的数字,分辨率为10个小数位:

models.DecimalField(..., max_digits=19, decimal_places=10)

localizeFalseTextInput 时,此字段的默认表单窗口小部件为 NumberInput

注解

有关 FloatFieldDecimalField 类之间差异的更多信息,请参阅 FloatField与DecimalField

DurationField

class DurationField(**options)[源代码]

一个用于存储时间段的字段 - 由 timedelta 在Python中建模。当在PostgreSQL上使用时,使用的数据类型是 interval,在Oracle上,数据类型是 INTERVAL DAY(9) TO SECOND(6)。否则使用微秒的 bigint

注解

使用 DurationField 的算术在大多数情况下都有效。但是在除PostgreSQL之外的所有数据库上,将 DurationField 的值与 DateTimeField 实例上的算法进行比较将无法按预期工作。

EmailField

class EmailField(max_length=254, **options)[源代码]

检查值是否为有效电子邮件地址的 CharField。它使用 EmailValidator 来验证输入。

FileField

class FileField(upload_to=None, max_length=100, **options)[源代码]

文件上传字段。

注解

不支持 primary_keyunique 参数,如果使用 TypeError 将引发 TypeError

有两个可选参数:

FileField.upload_to

此属性提供了设置上传目录和文件名的方法,并且可以通过两种方式设置。在这两种情况下,值都传递到 Storage.save() 方法。

如果指定了字符串值,它可能包含 strftime() 格式,它将由文件上传的日期/时间(以便上传的文件不会填满给定的目录)替换。例如:

class MyModel(models.Model):
    # file will be uploaded to MEDIA_ROOT/uploads
    upload = models.FileField(upload_to='uploads/')
    # or...
    # file will be saved to MEDIA_ROOT/uploads/2015/01/30
    upload = models.FileField(upload_to='uploads/%Y/%m/%d/')

如果使用默认 FileSystemStorage,字符串值将附加到您的 MEDIA_ROOT 路径,以形成本地文件系统上将存储上传文件的位置。如果使用不同的存储,请检查存储的文档以了解其如何处理 upload_to

upload_to 也可以是可调用的,例如函数。这将被称为获取上传路径,包括文件名。此可调参数必须接受两个参数,并返回一个Unix样式的路径(带正斜线)以传递到存储系统。两个参数是:

论据

描述

instance

定义 FileField 的模型的实例。更具体地,这是当前文件被附加的特定实例。

在大多数情况下,此对象将不会保存到数据库,因此,如果它使用默认的 AutoField它可能尚未具有其主键字段的值

filename

最初提供给文件的文件名。在确定最终目的地路径时可以或不可以考虑这一点。

例如:

def user_directory_path(instance, filename):
    # file will be uploaded to MEDIA_ROOT/user_<id>/<filename>
    return 'user_{0}/{1}'.format(instance.user.id, filename)

class MyModel(models.Model):
    upload = models.FileField(upload_to=user_directory_path)
FileField.storage

存储对象,用于处理文件的存储和检索。有关如何提供此对象的详细信息,请参阅 管理文件

此字段的默认表单窗口小部件是 ClearableFileInput

在模型中使用 FileFieldImageField (见下文)需要几个步骤:

  1. 在您的设置文件中,您需要将 MEDIA_ROOT 定义为您希望Django存储上传文件的目录的完整路径。 (为了性能,这些文件不存储在数据库中。)将 MEDIA_URL 定义为该目录的基本公用URL。确保此目录可由Web服务器的用户帐户写入。

  2. FileFieldImageField 添加到模型中,定义 upload_to 选项以指定 MEDIA_ROOT 的子目录以用于上传的文件。

  3. 所有将存储在数据库中的是文件的路径(相对于 MEDIA_ROOT)。你最有可能想使用Django提供的方便的 url 属性。例如,如果您的 ImageField 称为 mug_shot,您可以获得您的图像的绝对路径在与 {{ object.mug_shot.url }} 的模板。

例如,假设您的 MEDIA_ROOT 设置为 '/home/media'upload_to 设置为 'photos/%Y/%m/%d'upload_to'%Y/%m/%d' 部分是 strftime() 格式; '%Y' 是四位数年份,'%m' 是两位数字,'%d' 是两位数日期。如果您在2007年1月15日上传文件,它将保存在目录 /home/media/photos/2007/01/15 中。

如果要检索上传文件的磁盘文件名或文件大小,可以分别使用 namesize 属性;有关可用属性和方法的更多信息,请参阅 File 类参考和 管理文件 主题指南。

注解

该文件将作为将模型保存在数据库中的一部分进行保存,因此在保存模型之前不能依赖磁盘上使用的实际文件名。

可以使用 url 属性获取上传文件的相对URL。在内部,这会调用底层 Storage 类的 url() 方法。

请注意,每当处理上传的文件时,都应该密切注意上传文件的位置和文件类型,以避免出现安全漏洞。 验证所有上传的文件,以便确保文件是你认为他们是。例如,如果您盲目地让某人将文件上传到Web服务器文档根目录中,那么有人可以上传CGI或PHP脚本,并通过访问您网站上的URL来执行该脚本。不要允许。

还要注意,即使上传的HTML文件,因为它可以由浏览器(虽然不是由服务器)执行,可以提出等同于XSS或CSRF攻击的安全威胁。

FileField 实例在数据库中创建为默认最大长度为100个字符的 varchar 列。与其他字段一样,您可以使用 max_length 参数更改最大长度。

FileFieldFieldFile

class FieldFile[源代码]

当您访问模型上的 FileField 时,您将获得一个 FieldFile 实例作为访问基础文件的代理。

FieldFile 的API与 File 的API相同,但有一个主要区别:由类包装的对象不一定是Python内置文件对象的包装器。 相反,它是 Storage.open() 方法的结果的包装器,它可以是 File 对象,也可以是 File API的自定义存储器实现。

除了继承自 File 的API(例如 read()write())之外,FieldFile 还包括几种可用于与底层文件交互的方法:

警告

此类的两个方法,save()delete(),默认保存数据库中关联的 FieldFile 的模型对象。

FieldFile.name

文件的名称,包括从关联的 FileFieldStorage 的根目录的相对路径。

FieldFile.size

基础 Storage.size() 方法的结果。

FieldFile.url

通过调用基础 Storage 类的 url() 方法来访问文件的相对URL的只读属性。

FieldFile.open(mode='rb')[源代码]

在指定的 mode 中打开或重新打开与此实例关联的文件。与标准的Python open() 方法不同,它不返回文件描述符。

由于底层文件在访问时隐式打开,因此除了重置指向底层文件的指针或更改 mode 之外,可能不需要调用此方法。

FieldFile.close()[源代码]

行为像标准的Python file.close() 方法,并关闭与此实例相关联的文件。

FieldFile.save(name, content, save=True)[源代码]

此方法接受文件名和文件内容,并将它们传递到字段的存储类,然后将存储的文件与模型字段关联。如果要手动将文件数据与模型上的 FileField 实例相关联,则使用 save() 方法来持久保存该文件数据。

需要两个必需的参数:name 是文件的名称,content 是包含文件内容的对象。可选的 save 参数控制在与此字段关联的文件已更改后是否保存模型实例。默认为 True

请注意,content 参数应该是 django.core.files.File 的实例,而不是Python的内置文件对象。您可以从这样的现有Python文件对象构建 File:

from django.core.files import File
# Open an existing file using Python's built-in open()
f = open('/path/to/hello.world')
myfile = File(f)

或者你可以从这样的Python字符串构造一个:

from django.core.files.base import ContentFile
myfile = ContentFile("hello world")

有关更多信息,请参阅 管理文件

FieldFile.delete(save=True)[源代码]

删除与此实例关联的文件,并清除字段上的所有属性。注意:如果在调用 delete() 时打开文件,此方法将关闭文件。

可选的 save 参数控制在与此字段关联的文件已删除后是否保存模型实例。默认为 True

请注意,删除模型时,不会删除相关文件。如果您需要清除孤立文件,您需要自己处理(例如,使用可以手动运行或计划通过例如cron定期运行的自定义管理命令)。

FilePathField

class FilePathField(path=None, match=None, recursive=False, max_length=100, **options)[源代码]

CharField,其选择仅限于文件系统上某个目录中的文件名。有三个特殊的论点,其中第一个是 需要

FilePathField.path

需要。该 FilePathField 应从中获取其选择的目录的绝对文件系统路径。示例:"/home/images"

FilePathField.match

可选的。 FilePathField 将用来过滤文件名的正则表达式,作为字符串。请注意,正则表达式将应用于基本文件名,而不是完整路径。示例:"foo.*\.txt$",它将匹配名为 foo23.txt 但不是 bar.txtfoo23.png 的文件。

FilePathField.recursive

可选的。 TrueFalse。默认为 False。指定是否应包括 path 的所有子目录

FilePathField.allow_files

可选的。 TrueFalse。默认为 True。指定是否应包括指定位置中的文件。这个或 allow_folders 必须是 True

FilePathField.allow_folders

可选的。 TrueFalse。默认为 False。指定是否应包括指定位置中的文件夹。这个或 allow_files 必须是 True

当然,这些参数可以一起使用。

一个潜在的缺点是 match 适用于基本文件名,而不是完整路径。所以,这个例子:

FilePathField(path="/home/images", match="foo.*", recursive=True)

...将匹配 /home/images/foo.png,但不匹配 /home/images/foo/bar.png,因为 match 适用于基本文件名(foo.pngbar.png)。

FilePathField 实例在数据库中创建为默认最大长度为100个字符的 varchar 列。与其他字段一样,您可以使用 max_length 参数更改最大长度。

FloatField

class FloatField(**options)[源代码]

在Python中由 float 实例表示的浮点数。

localizeFalseTextInput 时,此字段的默认表单窗口小部件为 NumberInput

FloatField vs. DecimalField

FloatField 类有时与 DecimalField 类混淆。虽然它们都代表实数,但它们代表的是不同的数字。 FloatField 在内部使用Python的 float 类型,而 DecimalField 使用Python的 Decimal 类型。有关两者之间的区别的信息,请参阅 decimal 模块的Python文档。

ImageField

class ImageField(upload_to=None, height_field=None, width_field=None, max_length=100, **options)[源代码]

继承 FileField 中的所有属性和方法,但也验证上传的对象是有效的图像。

除了可用于 FileField 的特殊属性,ImageField 还具有 heightwidth 属性。

为了方便查询这些属性,ImageField 有两个额外的可选参数:

ImageField.height_field

模型字段的名称,每次保存模型实例时,将自动填充图像的高度。

ImageField.width_field

每次保存模型实例时将自动填充图像宽度的模型字段的名称。

需要 Pillow 库。

ImageField 实例在数据库中创建为默认最大长度为100个字符的 varchar 列。与其他字段一样,您可以使用 max_length 参数更改最大长度。

此字段的默认表单窗口小部件是 ClearableFileInput

IntegerField

class IntegerField(**options)[源代码]

整数。从 -21474836482147483647 的值在Django支持的所有数据库中都是安全的。当 localizeFalseTextInput 时,此字段的默认表单窗口小部件为 NumberInput

GenericIPAddressField

class GenericIPAddressField(protocol='both', unpack_ipv4=False, **options)[源代码]

以字符串格式(例如 192.0.2.302a02:42fe::4)的IPv4或IPv6地址。此字段的默认表单窗口小部件是 TextInput

IPv6地址规范化遵循 RFC 4291#section-2.2 第2.2节,包括使用该节第3段中建议的IPv4格式,如 ::ffff:192.0.2.0。例如,2001:0::0:01 将归一化为 2001::1,而 ::ffff:0a0a:0a0a 归一化为 ::ffff:10.10.10.10。所有字符都转换为小写。

GenericIPAddressField.protocol

限制指定协议的有效输入。接受的值为 'both' (默认),'IPv4''IPv6'。匹配不区分大小写。

GenericIPAddressField.unpack_ipv4

解开IPv4映射地址(如 ::ffff:192.0.2.1)。如果启用此选项,则该地址将解包到 192.0.2.1。默认为禁用。只能在 protocol 设置为 'both' 时使用。

如果允许空值,则必须允许空值,因为空值存储为null。

NullBooleanField

class NullBooleanField(**options)[源代码]

BooleanField,但允许 NULL 作为选项之一。使用此代替 BooleanFieldnull=True。此字段的默认表单窗口小部件是 NullBooleanSelect

PositiveIntegerField

class PositiveIntegerField(**options)[源代码]

IntegerField,但必须是正或零(0)。从 02147483647 的值在Django支持的所有数据库中都是安全的。由于向后兼容性原因,接受值 0

PositiveSmallIntegerField

class PositiveSmallIntegerField(**options)[源代码]

PositiveIntegerField,但只允许在某个(数据库相关)点下的值。从 032767 的值在Django支持的所有数据库中都是安全的。

SlugField

class SlugField(max_length=50, **options)[源代码]

Slug 是一个报纸术语。 lug是一个短标签,只包含字母,数字,下划线或连字符。它们通常用于网址。

像CharField一样,您可以指定 max_length (也请阅读有关数据库可移植性和 max_length 的说明)。如果未指定 max_length,Django将使用默认长度50。

Field.db_index 设置为 True

根据某些其他值的值自动预填充SlugField通常很有用。您可以在管理员中使用 prepopulated_fields 自动执行此操作。

SlugField.allow_unicode
New in Django 1.9.

如果是 True,该字段除了ASCII字母外,还接受Unicode字符。默认为 False

SmallIntegerField

class SmallIntegerField(**options)[源代码]

IntegerField,但只允许在某个(数据库相关)点下的值。从 -3276832767 的值在Django支持的所有数据库中都是安全的。

TextField

class TextField(**options)[源代码]

大文本字段。此字段的默认表单窗口小部件是 Textarea

如果指定 max_length 属性,它将反映在自动生成的表单字段的 Textarea 窗口小部件中。但是不会在模型或数据库级别强制执行。使用 CharField

MySQL用户

如果您使用此字段与MySQLdb 1.2.1p2和 utf8_bin 排序规则(这是默认的 not),有一些问题需要注意。有关详细信息,请参阅 MySQL数据库笔记

TimeField

class TimeField(auto_now=False, auto_now_add=False, **options)[源代码]

一个时间,在Python中由 datetime.time 实例表示。接受与 DateField 相同的自动填充选项。

此字段的默认表单窗口小部件是 TextInput。管理员添加一些JavaScript快捷方式。

URLField

class URLField(max_length=200, **options)[源代码]

URL的 CharField

此字段的默认表单窗口小部件是 TextInput

像所有 CharField 子类一样,URLField 采用可选的 max_length 参数。如果不指定 max_length,则使用默认值200。

UUIDField

class UUIDField(**options)[源代码]

用于存储通用唯一标识符的字段。使用Python的 UUID 类。当在PostgreSQL上使用时,它以 uuid 数据类型存储,否则存储在 char(32) 中。

通用唯一标识符是 primary_keyAutoField 的良好替代。数据库不会为您生成UUID,因此建议使用 default:

import uuid
from django.db import models

class MyUUIDModel(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    # other fields

注意,可调用(省略括号)被传递给 default,而不是 UUID 的实例。

关系字段

Django还定义了一组表示关系的字段。

ForeignKey

class ForeignKey(othermodel, on_delete, **options)[源代码]

一个多对一的关系。需要位置参数:模型与之相关的类。

Changed in Django 1.9:

on_delete 现在可以用作第二个位置参数(以前它通常只作为关键字参数传递)。它将是Django 2.0中的必需参数。

要创建递归关系 - 一个与自身具有多对一关系的对象 - 使用 models.ForeignKey('self', on_delete=models.CASCADE)

如果需要在尚未定义的模型上创建关系,则可以使用模型的名称,而不是模型对象本身:

from django.db import models

class Car(models.Model):
    manufacturer = models.ForeignKey(
        'Manufacturer',
        on_delete=models.CASCADE,
    )
    # ...

class Manufacturer(models.Model):
    # ...
    pass

当模型被子类化为具体模型并且不是相对于抽象模型的 app_label 时,在 抽象模型 上以这种方式定义的关系被解析:

products/models.py
from django.db import models

class AbstractCar(models.Model):
    manufacturer = models.ForeignKey('Manufacturer', on_delete=models.CASCADE)

    class Meta:
        abstract = True
production/models.py
from django.db import models
from products.models import AbstractCar

class Manufacturer(models.Model):
    pass

class Car(AbstractCar):
    pass

# Car.manufacturer will point to `production.Manufacturer` here.

要引用在另一个应用程序中定义的模型,可以显式指定具有完整应用程序标签的模型。例如,如果上面的 Manufacturer 模型在另一个名为 production 的应用程序中定义,则需要使用:

class Car(models.Model):
    manufacturer = models.ForeignKey(
        'production.Manufacturer',
        on_delete=models.CASCADE,
    )

当解决两个应用程序之间的循环导入依赖关系时,这种引用可能很有用。

将在 ForeignKey 上自动创建数据库索引。您可以通过将 db_index 设置为 False 来禁用此功能。如果要为一致性而不是联接创建外键,或者如果要创建替代索引(如部分列或多列索引),则可能希望避免索引的开销。

数据库表示

在幕后,Django将 "_id" 附加到字段名称以创建其数据库列名称。在上面的例子中,Car 模型的数据库表将有一个 manufacturer_id 列。 (您可以通过指定 db_column 显式地更改)但是,您的代码不应该处理数据库列名称,除非您编写自定义SQL。您将始终处理模型对象的字段名称。

参数

ForeignKey 接受定义关系如何工作的细节的其他参数。

ForeignKey.on_delete

ForeignKey 引用的对象被删除时,Django将模拟由 on_delete 参数指定的SQL约束的行为。例如,如果您具有可空的 ForeignKey,并且希望在删除引用对象时将其设置为null:

user = models.ForeignKey(
    User,
    models.SET_NULL,
    blank=True,
    null=True,
)

1.9 版后已移除: on_delete 将成为Django 2.0中必需的参数。在旧版本中,它默认为 CASCADE

on_delete 的可能值在 django.db.models 中找到:

  • CASCADE[源代码]

    级联删除。 Django模拟SQL约束ON DELETE CASCADE的行为,并且还删除包含ForeignKey的对象。

  • PROTECT[源代码]

    通过提升 ProtectedErrordjango.db.IntegrityError 的子类)来防止删除引用的对象。

  • SET_NULL[源代码]

    设置 ForeignKey 为空;这只有在 nullTrue 时才可能。

  • SET_DEFAULT[源代码]

    ForeignKey 设置为其默认值;必须设置 ForeignKey 的默认值。

  • SET()[源代码]

    ForeignKey 设置为传递给 SET() 的值,或者如果传递callable,则调用它的结果。在大多数情况下,传递可调用对象是必要的,以避免在导入models.py时执行查询:

    from django.conf import settings
    from django.contrib.auth import get_user_model
    from django.db import models
    
    def get_sentinel_user():
        return get_user_model().objects.get_or_create(username='deleted')[0]
    
    class MyModel(models.Model):
        user = models.ForeignKey(
            settings.AUTH_USER_MODEL,
            on_delete=models.SET(get_sentinel_user),
        )
    
  • DO_NOTHING[源代码]

    不采取行动。如果您的数据库后端强制执行引用完整性,则将导致 IntegrityError,除非您手动将SQL ON DELETE 约束添加到数据库字段。

ForeignKey.limit_choices_to

当使用 ModelForm 或admin(默认情况下,查询集中的所有对象都可供选择)呈现此字段时,为此字段的可用选项设置限制。可以使用字典,Q 对象或可调用的返回字典或 Q 对象。

例如:

staff_member = models.ForeignKey(
    User,
    on_delete=models.CASCADE,
    limit_choices_to={'is_staff': True},
)

导致 ModelForm 上的相应字段仅列出具有 is_staff=TrueUsers。这在Django管理员中可能很有用。

可调用的表单可以是有帮助的,例如,当与Python datetime 模块结合使用以限制日期范围的选择。例如:

def limit_pub_date_choices():
    return {'pub_date__lte': datetime.date.utcnow()}

limit_choices_to = limit_pub_date_choices

如果 limit_choices_to 是或返回对 复杂查询 有用的 Q object,那么当该字段未在 raw_id_fields 中在模型的 ModelAdmin 中列出时,它将仅对管理员中可用的选项有影响。

注解

如果 limit_choices_to 使用可调用,则每次实例化新表单时都将调用它。它也可以在验证模型时被调用,例如通过管理命令或管理员。管理员构造查询集以在多种边缘情况下验证其形式输入多次,因此有可能您的可调用可能被调用多次。

ForeignKey.related_name

用于从相关对象返回到此对象的关系的名称。它也是 related_query_name 的默认值(用于来自目标模型的反向过滤器名称的名称)。有关完整的解释和示例,请参阅 相关对象文档。注意,在定义 抽象模型 上的关系时,必须设置此值;当你这样做 一些特殊的语法 可用。

如果你希望Django不要创建一个向后关系,请将 related_name 设置为 '+' 或以 '+' 结束。例如,这将确保 User 模型将不具有与该模型的后向关系:

user = models.ForeignKey(
    User,
    on_delete=models.CASCADE,
    related_name='+',
)
ForeignKey.related_query_name

用于来自目标模型的反向过滤器名称的名称。如果设置,它默认为 related_namedefault_related_name 的值,否则默认为模型的名称:

# Declare the ForeignKey with related_query_name
class Tag(models.Model):
    article = models.ForeignKey(
        Article,
        on_delete=models.CASCADE,
        related_name="tags",
        related_query_name="tag",
    )
    name = models.CharField(max_length=255)

# That's now the name of the reverse filter
Article.objects.filter(tag__name="important")

related_name 一样,related_query_name 通过 一些特殊的语法 支持应用程序标签和类插值。

ForeignKey.to_field

关系所关联的相关对象上的字段。默认情况下,Django使用相关对象的主键。如果引用其他字段,该字段必须具有 unique=True

ForeignKey.db_constraint

控制是否应在数据库中为此外键创建约束。默认是 True,这几乎肯定是你想要的;将此设置为 False 对于数据完整性可能非常不利。也就是说,这里有一些情况下,你可能想这样做:

  • 您的遗产数据无效。

  • 您正在分割数据库。

如果这被设置为 False,访问不存在的相关对象将引发其 DoesNotExist 异常。

ForeignKey.swappable

如果此 ForeignKey 指向可交换模型,则控制迁移框架的反应。如果它是 True - 默认 - 则如果 ForeignKey 指向与 settings.AUTH_USER_MODEL (或另一个可交换模型设置)的当前值匹配的模型,则该关系将使用对设置的引用存储在迁移中,而不是存储在模型中直。

如果您确定您的模型应始终指向交换模型 - 例如,如果它是专为您的自定义用户模型设计的配置文件模型,则您只想将其覆盖为 False

将它设置为 False 并不意味着您可以引用一个可交换的模型,即使它被交换出来 - False 只是意味着使用这个ForeignKey进行的迁移将始终引用您指定的确切模型(因此,如果用户尝试运行,它将失败与您不支持的用户模型,例如)。

如果有疑问,请将其默认为 True

ManyToManyField

class ManyToManyField(othermodel, **options)[源代码]

一个多对多的关系。需要一个位置参数:模型所关联的类,其工作原理与 ForeignKey 完全相同,包括 递归 关系。

可以使用字段的 RelatedManager 添加,删除或创建相关对象。

数据库表示

在幕后,Django创建一个中介连接表来表示多对多关系。默认情况下,将使用多对多字段的名称和包含它的模型的表名称生成此表名。由于某些数据库不支持超过一定长度的表名,这些表名将自动截断为64个字符,并将使用唯一性哈希。这意味着您可能会看到表名称,如 author_books_9cdf4;这是完全正常的。您可以使用 db_table 选项手动提供连接表的名称。

参数

ManyToManyField 接受一组额外的参数 - 所有可选 - 控制关系如何运作。

ManyToManyField.related_name

ForeignKey.related_name 相同。

ManyToManyField.related_query_name

ForeignKey.related_query_name 相同。

ManyToManyField.limit_choices_to

ForeignKey.limit_choices_to 相同。

当在具有使用 through 参数指定的自定义中间表的 ManyToManyField 上使用时,limit_choices_to 不起作用。

ManyToManyField.symmetrical

只用于ManyToManyFields的自定义。考虑下面的模型:

from django.db import models

class Person(models.Model):
    friends = models.ManyToManyField("self")

当Django处理此模型时,它标识它本身有一个 ManyToManyField,因此,它不会向 Person 类添加一个 person_set 属性。相反,假设 ManyToManyField 是对称的 - 也就是说,如果我是你的朋友,那么你是我的朋友。

如果您不希望与 self 的多对多关系中的对称性,请将 symmetrical 设置为 False。这将迫使Django为反向关系添加描述符,允许 ManyToManyField 关系是非对称的。

ManyToManyField.through

Django将自动生成一个表来管理多对多关系。但是,如果要手动指定中间表,则可以使用 through 选项指定表示要使用的中间表的Django模型。

此选项的最常见用途是当您要关联 具有多对多关系的额外数据

如果不指定显式 through 模型,则仍然有一个隐式 through 模型类,您可以使用它直接访问为保存关联而创建的表。它有三个字段链接模型。

如果源模型和目标模型不同,则会生成以下字段:

  • id:关系的主键。

  • <containing_model>_id:声明 ManyToManyField 的模型的 id

  • <other_model>_idManyToManyField 指向的模型的 id

如果 ManyToManyField 从和指向同一模型,则生成以下字段:

  • id:关系的主键。

  • from_<model>_id:指向模型(即源实例)的实例的 id

  • to_<model>_id:关系指向的实例的 id (即目标模型实例)。

此类可用于查询给定模型实例的关联记录,如同普通模型。

ManyToManyField.through_fields

仅在指定自定义中介模型时使用。 Django通常将确定使用中间模型的哪些字段以便自动建立多对多关系。但是,请考虑以下模型:

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=50)

class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(
        Person,
        through='Membership',
        through_fields=('group', 'person'),
    )

class Membership(models.Model):
    group = models.ForeignKey(Group, on_delete=models.CASCADE)
    person = models.ForeignKey(Person, on_delete=models.CASCADE)
    inviter = models.ForeignKey(
        Person,
        on_delete=models.CASCADE,
        related_name="membership_invites",
    )
    invite_reason = models.CharField(max_length=64)

Membership 具有对 Personpersoninviter)的 two 外键,这使得关系不明确,并且Django不知道使用哪个。在这种情况下,您必须使用 through_fields 显式指定Django应该使用哪些外键,如上例所示。

through_fields 接受2元组 ('field1', 'field2'),其中 field1ManyToManyField 定义的模型的外键的名称(在这种情况下是 group),field2 是目标模型的外键的名称(在这种情况下是 person) 。

当在中介模型上有多个外键与参与多对多关系的任何(或两个)模型时,must 指定 through_fields。这也适用于 递归关系,当使用中间模型并且有多于两个外键到模型,或者你想明确指定哪两个Django应该使用。

使用中间模型的递归关系总是被定义为非对称的 - 即,对于 symmetrical=False - 因此,存在“源”和“目标”的概念。在这种情况下,'field1' 将被视为关系的“来源”,'field2' 将被视为“目标”。

ManyToManyField.db_table

要为存储多对多数据而创建的表的名称。如果没有提供,Django将假定一个默认名称,基于以下名称:定义关系的模型的表和字段本身的名称。

ManyToManyField.db_constraint

控制是否应在数据库中为中间表中的外键创建约束。默认是 True,这几乎肯定是你想要的;将此设置为 False 对于数据完整性可能非常不利。也就是说,这里有一些情况下,你可能想这样做:

  • 您的遗产数据无效。

  • 您正在分割数据库。

通过 db_constraintthrough 是错误的。

ManyToManyField.swappable

如果此 ManyToManyField 指向可交换模型,则控制迁移框架的反应。如果它是 True - 默认 - 则如果 ManyToManyField 指向与 settings.AUTH_USER_MODEL (或另一个可交换模型设置)的当前值匹配的模型,则该关系将使用对设置的引用存储在迁移中,而不是存储在模型中直。

如果您确定您的模型应始终指向交换模型 - 例如,如果它是专为您的自定义用户模型设计的配置文件模型,则您只想将其覆盖为 False

如果有疑问,请将其默认为 True

ManyToManyField 不支持 validators

null 没有效果,因为在数据库级别无法要求关系。

OneToOneField

class OneToOneField(othermodel, on_delete, parent_link=False, **options)[源代码]

一对一的关系。在概念上,这类似于具有 unique=TrueForeignKey,但是关系的“反向”侧将直接返回单个对象。

Changed in Django 1.9:

on_delete 现在可以用作第二个位置参数(以前它通常只作为关键字参数传递)。它将是Django 2.0中的必需参数。

这是最有用的一个模型的主键,以某种方式“扩展”另一个模型;例如,通过从子模型到父模型添加隐式的一对一关系来实现 多表继承

需要一个位置参数:模型将与之相关的类。这与 ForeignKey 的工作原理完全相同,包括关于 递归 关系的所有选项。

如果不为 OneToOneField 指定 related_name 参数,Django将使用当前模型的小写名称作为默认值。

使用以下示例:

from django.conf import settings
from django.db import models

class MySpecialUser(models.Model):
    user = models.OneToOneField(
        settings.AUTH_USER_MODEL,
        on_delete=models.CASCADE,
    )
    supervisor = models.OneToOneField(
        settings.AUTH_USER_MODEL,
        on_delete=models.CASCADE,
        related_name='supervisor_of',
    )

您生成的 User 模型将具有以下属性:

>>> user = User.objects.get(pk=1)
>>> hasattr(user, 'myspecialuser')
True
>>> hasattr(user, 'supervisor_of')
True

如果相关表中的条目不存在,则在访问反向关系时引发 DoesNotExist 异常。例如,如果用户没有由 MySpecialUser 指定的主管:

>>> user.supervisor_of
Traceback (most recent call last):
    ...
DoesNotExist: User matching query does not exist.

此外,OneToOneField 接受 ForeignKey 接受的所有额外的参数,加上一个额外的参数:

True 并在继承自另一个 concrete model 的模型中使用时,表示该字段应该用作回到父类的链接,而不是通常通过子类化隐式创建的额外 OneToOneField

有关 OneToOneField 的使用示例,请参阅 一对一的关系

字段API参考

class Field[源代码]

Field 是表示数据库表列的抽象类。 Django使用字段创建数据库表(db_type()),将Python类型映射到数据库(get_prep_value()),反之亦然(from_db_value())。

因此,字段是不同Django API中的基础,尤其是 modelsquerysets

在模型中,字段被实例化为类属性并且表示特定的表列,参见 楷模。它有属性,如 nullunique,以及Django用于将字段值映射到数据库特定值的方法。

FieldRegisterLookupMixin 的亚类,因此 TransformLookup 可以登记在其上以在 QuerySet (例如 field_name__exact="foo")中使用。所有 内置查找 默认注册。

所有Django的内置字段,如 CharField,是 Field 的特定实现。如果您需要一个自定义字段,您可以子类化任何内置字段或从头开始编写 Field。在任一情况下,参见 编写自定义模型字段

description

字段的详细描述,例如用于 django.contrib.admindocs 应用程序。

描述可以是形式:

description = _("String (up to %(max_length)s)")

其中参数从字段的 __dict__ 插值。

要将 Field 映射到数据库特定类型,Django公开了几种方法:

get_internal_type()[源代码]

返回一个字符串,将此字段命名为后端特定用途。默认情况下,它返回类名。

有关在自定义字段中的用法,请参阅 模拟内置字段类型

db_type(connection)[源代码]

返回 Field 的数据库列数据类型,考虑 connection

有关在自定义字段中的用法,请参阅 自定义数据库类型

rel_db_type(connection)
New in Django 1.10.

返回指向 Field 的字段(如 ForeignKeyOneToOneField)的数据库列数据类型,并考虑 connection

有关在自定义字段中的用法,请参阅 自定义数据库类型

有三种主要情况,Django需要与数据库后端和字段交互:

  • 当它查询数据库(Python值 - >数据库后端值)

  • 当它从数据库加载数据(数据库后端值 - > Python值)

  • 当它保存到数据库(Python值 - >数据库后端值)

查询时,使用 get_db_prep_value()get_prep_value()

get_prep_value(value)[源代码]

value 是模型属性的当前值,方法应以已准备好用作查询中的参数的格式返回数据。

请参阅 将Python对象转换为查询值 的使用。

get_db_prep_value(value, connection, prepared=False)[源代码]

value 转换为后端特定值。默认情况下,如果 prepared=Trueget_prep_value() if是 False,则返回 value

请参阅 将查询值转换为数据库值 的使用。

当加载数据时,使用 from_db_value()

from_db_value(value, expression, connection, context)

将数据库返回的值转换为Python对象。这是 get_prep_value() 的相反。

此方法不用于大多数内置字段,因为数据库后端已返回正确的Python类型,或后端本身执行转换。

请参阅 将值转换为Python对象 的使用。

注解

出于性能原因,from_db_value 不实现为不需要它的字段(所有Django字段)的no-op。因此,您不能在定义中调用 super

保存时,使用 pre_save()get_db_prep_save()

get_db_prep_save(value, connection)[源代码]

get_db_prep_value() 相同,但是当字段值必须是 saved 到数据库时调用。默认情况下返回 get_db_prep_value()

pre_save(model_instance, add)[源代码]

get_db_prep_save() 之前调用以在保存之前准备值的方法(例如,对于 DateField.auto_now)。

model_instance 是此字段所属的实例,add 是实例是否第一次保存到数据库。

它应该从此字段的 model_instance 返回适当属性的值。属性名称在 self.attname 中(这是由 Field 设置的)。

请参阅 保存前预处理值 的使用。

字段通常从不同的序列或表单中接收不同的值。

to_python(value)[源代码]

将值转换为正确的Python对象。它作为 value_to_string() 的反向,并且也在 clean() 中被调用。

请参阅 将值转换为Python对象 的使用。

除了保存到数据库之外,字段还需要知道如何序列化其值:

value_to_string(obj)[源代码]

obj 转换为字符串。用于序列化字段的值。

请参阅 转换字段数据以进行序列化 的使用。

当使用 model forms 时,Field 需要知道应由哪个表单字段表示:

formfield(form_class=None, choices_form_class=None, **kwargs)[源代码]

返回 ModelForm 的此字段的默认 django.forms.Field

默认情况下,如果 form_classchoices_form_class 都是 None,则使用 CharField。如果字段有 choices 且未指定 choices_form_class,则使用 TypedChoiceField

请参阅 指定模型字段的表单字段 的使用。

deconstruct()[源代码]

返回具有足够信息的4元组,以重新创建字段:

  1. 模型上字段的名称。

  2. 字段的导入路径(例如,"django.db.models.IntegerField")。这应该是最便携的版本,所以较少的具体可能会更好。

  3. 位置参数列表。

  4. 关键字参数的dict。

此方法必须添加到1.7之前的字段以使用 迁移 迁移其数据。

字段属性引用

每个 Field 实例包含几个允许内省其行为的属性。当您需要编写取决于字段功能的代码时,使用这些属性而不是 isinstance 检查。这些属性可以与 Model._meta API 一起使用,以缩小对特定字段类型的搜索。自定义模型字段应该实现这些标志。

字段的属性

Field.auto_created

布尔标志,指示是否自动创建字段,例如模型继承使用的 OneToOneField

Field.concrete

布尔标志,指示字段是否具有与其相关联的数据库列。

Field.hidden

布尔标志,其指示是否使用字段来回复另一个非隐藏字段的功能(例如,构成 GenericForeignKeycontent_typeobject_id 字段)。 hidden 标志用于区分模型上的字段的公共子集构成模型上的所有字段。

注解

默认情况下,Options.get_fields() 排除隐藏字段。传入 include_hidden=True 以返回结果中的隐藏字段。

Field.is_relation

布尔标志,其指示字段是否包含对于其功能(例如,ForeignKeyManyToManyFieldOneToOneField 等)的对一个或多个其他模型的引用。

Field.model

返回定义字段的模型。如果一个字段在模型的超类上定义,model 将引用超类,而不是实例的类。

具有关系的字段的属性

这些属性用于查询关系的基数和其他详细信息。这些属性存在于所有字段上;然而,如果字段是关系类型(Field.is_relation=True),它们将只有布尔值(而不是 None)。

Field.many_to_many

如果字段具有多对多关系,则为 True 的布尔标志; False。Django中包含的唯一字段对应是 True 的是 ManyToManyField

Field.many_to_one

布尔标志,如果字段具有多对一关系,则为 True,例如 ForeignKeyFalse

Field.one_to_many

布尔标志,如果字段具有一对多关系(例如 GenericRelationForeignKey 的反向),则为 TrueFalse

Field.one_to_one

如果字段具有一对一关系,则为 True 的布尔标志,例如 OneToOneFieldFalse

Field.related_model

指向字段涉及的模型。例如,AuthorForeignKey(Author, on_delete=models.CASCADE)GenericForeignKeyrelated_model 总是 None