字段

字段选项

基本字段

复杂字段

SlugField

Slug是一个报纸术语。表示某事物的简短标签，仅包含字母，数字，下划线或连字符。它们通常在URL中使用，默认设置[db_index=True]开启索引。

TimeField、DateField、DateTimeField

分别是时间字段、日期字段，、日期和时间字段

from datetime import date
update_time=models.DateField(default=date.today)
或
from django.utils import timezone
update_time=models.DateField(default=timezone.now)

def __init__(self, verbose_name=None, name=None, auto_now=False,
             auto_now_add=False, **kwargs):
    self.auto_now, self.auto_now_add = auto_now, auto_now_add
    if auto_now or auto_now_add:
        kwargs['editable'] = False
        kwargs['blank'] = True
        super().__init__(verbose_name, name, **kwargs)

通过看初始化源码可以知道如果设置auto_now或auto_now_add以 True会导致该字段默认拥有editable=False和blank=True 属性

在auto_now和auto_now_add选项将始终使用的日期默认时区在创建或更新的时刻。如果您需要其他内容，则可能要考虑使用自己的可调用默认值或替代值。

DecimalField

固定精度的十进制数字，在Python中由 [Decimal]。有两个必需的参数：

# 表示存储最大位数为5位的，小数点后两位。如999.20,但是9999.20就不行
number=models.DecimalField(max_digits=5, decimal_places=2)

FileField和ImageField

需要注意的是primary_key不支持该参数，如果使用该参数将引发错误。FileField和ImageField实例在数据库中的类型是varchar ，默认最大长度为100个字符。与其他字段一样，您可以使用max_length参数更改最大长度。但是ImageField多了height和width属性。

# 文件将保存在MEDIA_ROOT/uploads目录下
file = models.FileField(upload_to='uploads/')
# 文件将保存在MEDIA_ROOT/uploads/2015/01/30目录下
file = models.FileField(upload_to='uploads/%Y/%m/%d/')

upload_to也可以是可调用的，例如函数。该可调用函数必须接受两个参数，并返回存储路径。这两个参数如下：

def file_directory_path(instance, filename):
    # 通过实现自定义上传路径，可以保证每个用户上传的文件都在自己编号的文件目录下
    return 'user_{0}/{1}'.format(instance.user.id, filename)

class SysFile(models.Model):
    user=models.ForeignKey(to=User, on_delete=models.CASCADE)
    file = models.FileField(upload_to=user_directory_path)

注意点

• MEDIA_ROOT表示系统文件存储的根目录，同时定义 MEDIA_URL为该目录的基本公共URL

• upload_to(是表示位于MEDIA_ROOT下子目录

• 存储在数据库中的所有文件都是该文件的路径（相对于MEDIA_ROOT）

  例如设置MEDIA_ROOT='/home/media'以及upload_to='photos/%Y/%m/%d'，文件名为test.txt如果上传时间为2021年04月01日，则该文件将保存在目录中/home/media/photos/2007/01/15/test.txt下，同时保存到数据库的是photos/2007/01/15/test.txt

FilePathField

FilePathField实例在数据库中创建为varchar 列，默认最大长度为100个字符。与其他字段一样，您可以使用max_length参数更改最大长度。选择仅限于文件系统上某个目录中的文件名。有一些特殊的参数，其中第一个是 必需的：

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

def images_path():
    return os.path.join(settings.LOCAL_FILE_DIR, 'images')

class SysFile(models.Model):
    file = models.FilePathField(path=images_path)

GenericIPAddressField

字符串格式的IPv4或IPv6地址（例如192.0.2.30)。

JSONField

Django 3.1的新功能。用于存储JSON编码数据的字段。在Python中，数据以其Python本机格式表示：字典，列表，字符串，数字，布尔值和 None。JSONFieldMariaDB 10.2.7 +，MySQL 5.7.8 +，Oracle，PostgreSQL和SQLite 3.9.0+受支持。

如果想设置将字段设置为default，请确保它是一个不变的对象（例如）str，或者是每次都返回一个新的可变对象的可调用对象（例如dict或函数）。提供像一个可变的默认对象default={}或default=[]所有股份模型实例之间的一个对象。

UUIDField

用于存储通用唯一标识符的字段。使用Python的UUID类。在PostgreSQL上使用时，它存储在uuid数据类型中，否则存储在 中char(32)。通用的唯一标识符是AutoField的很好替代primary_key。该数据库不会为您生成UUID，因此建议使用如下代码实现自动生成UUID

import uuid
from django.db import models

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

请注意，将可调用的对象传递给default，而不是的UUID实例

注意点

使用iexact、contains、icontains、startswith、istartswith、endswith、iendswith在PostgreSQL上查找时不带连字符则不会生效，因为PostgreSQL将它们存储在一个连字符的UUID数据类型类型。

关系字段

演示模型

• 一对多模型

    class User(models.Model):
        name=models.CharField(max_length=50)
  
    class Article(models.Model):
        name=models.CharField(max_length=50)
        user = models.ForeignKey(User, on_delete=models.CASCADE)
  

• 多对多默认中间模型

    class Person(models.Model):
        name = models.CharField(max_length=50)
  
    class Group(models.Model):
        name = models.CharField(max_length=128)
        members = models.ManyToManyField(Person)
  

• 多对多自定义中间模型

    class Person(models.Model):
        name = models.CharField(max_length=50)
  
    class Group(models.Model):
        name = models.CharField(max_length=128)
        # 由于中间表有两个外键(成员和邀请人)，在这种情况下，必须通过through_fields来指定django应该使用的外键是哪两个字段
        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)
  

RelatedManager

在讲关系字段前，先来了解下RelatedManager，RelatedManager是表示一对多或多对多相关上下文中使用的关联管理器

• add(objs,bulk = True,through_defaults = None)

  add()可以接受模型实例或字段值（通常为主键）作为*objs参数。但是使用多对多关系不会调用任何save()方法（该bulk参数不存在），而是使用QuerySet.bulk_create()来创建关系。如果在创建关系时需要执行一些自定义逻辑，请监听m2m_changed信号，该信号将触发pre_add并post_add执行操作。add()在已经存在的关系上使用不会重复该关系(即用户和组已经绑定过，再次绑定并不会重复插入) ，但仍会触发信号。

  对于多对多关系，如果需要，可使用through_defaults参数为新的中间模型实例指定额外的值 。您可以在through_defaults 字典中将可调用对象用作值，在django 3.1中进行了更改：through_defaults 值现在可以是可调用的。

  一对多模型

  >>> user = User.objects.get(id="xxx")
  >>> article = Article.objects.get(id="xxx")
  >>> user.article_set.add(article) # 关联用户和文章
  

  多对多默认中间模型

  >>> person = Person.objects.get(id="xxx")
  >>> group = Group.objects.get(id="xxx")
  >>> person.group_set.add(person)
  

  多对多自定义中间模型

  >>> person = Person.objects.get(id="xxx")
  >>> inviter = Person.objects.get(id="xxx")
  >>> group = Group.objects.get(id="xxx")
  >>> person.group_set.add(person,through_defaults={"inviter":inviter,"invite_reason":"xxxx"})
  

• create(through_defaults = None, **kwargs)

  一对多模型

  >>> user = User.objects.get(id="xxx")
  >>> user.article_set.create(name="文章一")
  

  多对多默认中间模型

  >>> person = Person.objects.get(id="xxx")
  >>> group = Group.objects.get(id="xxx")
  >>> person.group_set.create(name="xxx")
  

  多对多自定义中间模型

  >>> person = Person.objects.get(id="xxx")
  >>> inviter = Person.objects.get(id="xxx")
  >>> person.group_set.create(name="xxx",{through_defaults={"inviter":inviter,"invite_reason":"xxxx"}})
  

• remove(objs，bulk = True）

  从相关对象集中删除指定的模型对象

  对于多对多关系，remove()可以接受模型实例或字段值（通常为主键）作为*objs 参数。但是，使用将删除关系 QuerySet.delete()，这意味着没有模型save()方法被调用; m2m_changed如果您希望在删除关系后执行自定义代码，请监听信号。对于ForeignKey对象，此方法要求ForeignKey设置了null=True。如果该字段不能设置为None （NULL），则无法将一个对象从关系中删除而不将其添加到另一个对象中。在下面的一对多模型示例中，在模型Article没有设置user的属性null=True而执行 删除user.article_set()，这是无效的。

  对于ForeignKey对象，此方法接受一个bulk参数来控制如何执行该操作。如果True（默认），QuerySet.update()则使用。如果为bulk=False，save()则调用每个单独的模型实例的方法。这会触发 pre_save)和 post_save信号，并以牺牲性能为代价。

  对于多对多关系，bulk关键字参数不存在。

  一对多模型

  >>> user = User.objects.get(id="xxx")
  >>> article = Article.objects.get(id="xxx")
  >>> user.article_set.remove(article)
  

  多对多默认中间模型和多对多自定义中间模型

  >>> person = Person.objects.get(id="xxx")
  >>> group1 = Group.objects.get(id="xxx")
  >>> group2 = Group.objects.get(id="xxx")
  >>> person.group_set.remove(group)
  >>> person.group_set.remove([group1,group2])
  >>> person.group_set.remove([<group1_id>,<group2_id>])
  

• clear(bulk = True）

  从相关对象集中删除所有对象：

  请注意，这不会删除相关对象，而只是取消关联它们。就像一样remove()，clear()仅在ForeignKey位置可用 null=True并且还接受bulk关键字参数。对于多对多关系，bulk关键字参数不存在。

  一对多模型

  >>> user = User.objects.get(id="xxx")
  >>> user.article_set.clear()
  

  多对多默认中间模型和多对多自定义中间模型

  >>> person = Person.objects.get(id="xxx")
  >>> person.group_set.clear()
  

• set(objs,bulk = True,clear = False,through_defaults = None）

  替换相关对象集，此方法接受一个clear参数来控制如何执行该操作。如果False（默认），则会执行remove()删除集中缺少的元素而仅添加新元素。如果为clear=True，clear()则改为调用方法，然后立即添加整个集合。

  对于ForeignKey对象，set()仅接受模型实例的列表作为objs 参数，bulk 参数传递给add()和remove()。

  对于多对多关系，bulk关键字参数不存在。set()接受模型实例或字段值（通常是主键）的列表作为objs 参数。如果需要，可使用through_defaults参数为新的中间模型实例指定值 。在Django 3.1中进行了更改：through_defaults 值现在可以是可调用的。

  需要注意的是add()，create()，remove()，clear()，和 set()所有适用的数据库将立即更改为各类相关领域。换句话说，不需要save() 在关系的任何一端进行调用。如果您使用prefetch_related()的add()，remove()，clear()，和set()方法清除预取缓存。

  一对多模型

  >>> user = User.objects.get(id="xxx")
  >>> article1 = Article.objects.get(id="xxx")
  >>> article2 = Article.objects.get(id="xxx")
  >>> user.article_set.set([article1,article2])
  

  多对多默认中间模型

  >>> person = Person.objects.get(id="xxx")
  >>> group1 = Group.objects.get(id="xxx")
  >>> group2 = Group.objects.get(id="xxx")
  >>> person.group_set.set([group1,group2])
  >>> person.group_set.set([<group1_id>,<group2_id>])
  

  多对多自定义中间模型

  >>> person = Person.objects.get(id="xxx")
  >>> inviter = Person.objects.get(id="xxx")
  >>> group1 = Group.objects.get(id="xxx")
  >>> group2 = Group.objects.get(id="xxx")
  >>> person.group_set.set([group1,group2],{"inviter":inviter,"invite_reason":"xxxx"})
  >>> person.group_set.set([<group1_id>,<group2_id>],through_defaults={"inviter":inviter,"invite_reason":"xxxx"})
  

ForeignKey

准确的说是多对一关系。需要两个位置参数：外键关联的模型和on_delete选项。

from django.db import models
# 汽车
class Car(models.Model):
    # 如果需要在尚未定义的模型上创建关系，则可以使用模型的名称，而不是模型对象本身
    manufacturer = models.ForeignKey(to='Manufacturer',on_delete=models.CASCADE)
    # 模型已经创建
    manufacturer = models.ForeignKey(to=Manufacturer,on_delete=models.CASCADE)

# 制造商   
class Manufacturer(models.Model):
    pass

如果关联的模型是在另一个应用程序中定义的模型，可以显式指定完成的模型路径。例如，如果Manufacturer 上面的模型是在另一个名为production的应用程序中定义的，则需要按照如下操作：

from django.db import models
# 汽车
class Car(models.Model):
    # 如果需要在尚未定义的模型上创建关系，则可以使用模型的名称，而不是模型对象本身
    manufacturer = models.ForeignKey(to='production.Manufacturer',on_delete=models.CASCADE)

在解决两个应用程序之间的循环导入依赖关系时，上面这种称为惰性关系的引用可能会很有用。

django会为ForeignKey自动创建数据库索引，可以通过设置[db_index=False为禁用此功能。

属性

• db_column

  如果不设置该字段，Django默认会追加"_id"到字段名称以创建其数据库列名称。在上面的示例中，Car 模型的数据库表将具有manufacturer_id列。但是有的时候自定义sql的时候就需要设置该字段来指定明确数据表列名。

• on_delete

  on_delete用来控制当外键数据删除是预留什么操作

• limit_choices_to

  该字段主要是方便使用ModelForm和django-admin为该字段的可用选项设置一个限制（默认情况下，可以选择queryset中的所有对象）。可以使用字典， Q对象或返回字典或Q]对象的可调用对象。例如：

  # 只获取user的属性is_staff为True的用户
  staff = models.ForeignKey(User,on_delete=models.CASCADE,limit_choices_to={'is_staff': True},)
  

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

• related_name

  用来表示当前对象和关联对象的关系，同时它也是related_query_name用于目标模型的反向过滤器名称的名称）的默认值。如果您希望Django不要创建反向关系，请将设置 related_name为'+'或以结束'+'这将确保该User模型不会与此模型具有反向查询关系。

  class Article(models.Model):
      title = models.CharField(max_length=150, verbose_name='文章标题')
      # 不创建反向关系
      user = models.ForeignKey(User,on_delete=models.CASCADE,related_name='+') 
      # 未指定related_name的值，则默认值为<model_name>_set。如：article_set
      user = models.ForeignKey(User,on_delete=models.CASCADE) 
      # 指定related_name的值
      user = models.ForeignKey(User,on_delete=models.CASCADE,related_name="user_article")
  

  例如当需要查询某个用户所有文章可以通过以下方法进行查询

  # 未指定related_name的值
  >>> user=User.object.get(id="xxx")
  >>> user.article_set.all()
  # 指定related_name的值
  >>> user=User.object.get(id="xxx")
  >>> user.user_article.all()
  

• related_query_name

  用于目标模型的反向过滤器名称的名称。默认为related_name或 的值default_related_name，否则默认为模型的名称。

  例如查询哪些人写的文章名是xxx

• to_field

  指定关联外键哪个字段。默认情况下，Django使用相关对象的主键。如果您引用其他字段，则该字段必须具有unique=True。

• db_constraint

  是否应在数据库中为此外键创建约束。默认值为True，将此设置False不利于数据完整性。

• swappable

  默认值是True表示ForeignKeys指向与当前值settings.AUTH_USER_MODEL匹配的模型，则该关系将使用对该设置的引用（而不是直接指向该模型）存储在迁移中。仅False当您确定模型始终指向交换的模型时，才需要覆盖此设置。将其设置为False并不意味着即使已交换掉它也可以引用可交换模型-False意味着使用此ForeignKey进行的迁移将始终引用您指定的确切模型（因此，如果用户尝试与User一起运行，它将很难失败。例如，您不支持的模型）。如有疑问，请将其保留为默认值True。

  class User(AbstractUser):
      """
      Users within the Django authentication system are represented by this
      model.
  
      Username and password are required. Other fields are optional.
      """
      class Meta(AbstractUser.Meta):
          swappable = 'AUTH_USER_MODEL'
  

ManyToManyField

多对多关系。可以使用字段的添加，删除或创建相关对象ManyRelatedManager。在不知道，Django创建了一个中间联接表来表示多对多关系。默认情况下，该表名是使用“多对多”字段的名称和包含该表的模型的表名生成的。由于某些数据库不支持超过一定长度的表名，因此这些表名将被自动截断并使用唯一性哈希，例如author_books_9cdf。您可以使用该db_table选项手动提供联接表的名称。

属性

• symmetrical

  仅用于self上的ManyToManyFields的定义。考虑以下模型：当Django处理此模型时，它会确定 ManyToManyField自身具有，因此不会person_set向Person该类添加 属性。相反ManyToManyField假定s是对称的-也就是说，如果我是您的朋友，那么您就是我的朋友。如果您不希望与保持多对多关系中的对称性self，请将设置 symmetrical为False。这将迫使Django为反向关系添加描述符，从而允许ManyToManyField关系非对称。在Django 3.0中进行了更改：symmetrical=True允许使用中介模型指定递归多对多关系。

• through

  一般django会自动生成一个表来管理多对多关系，这个表具有三个用于链接模型的字段。

  如果源模型和目标模型不同，那么将生成以下字段：

如果源模型和目标模型相同，则将生成以下字段：

但是django自动生成的中间表就没办法就再添加数据了如创建时间、更新时间，像这样的情况，只能手动指定中间表，则可以使用该through选项指定表示要使用的中间表的模型。使用中间模型的递归关系无法确定反向访问器名称，因为它们是相同的。您需要为其中一个模型设置related_name 。如果您不希望Django不创建向后关系，请将设置related_name 为'+'。

• db_table

  如果没有自定义中间模型，django将根据定义关系的两个模型表和其关联字段的名称来定义表名和字段名，但是如果不想表数据由django来生成，则可以通过该字段来指定表名。

• through_fields

  中间模型必须包含一个到源模型的唯一外键，当出现多个外键，这个时候django就不知道怎么处理多对多关系了。这个时候就可以用您必须使用through_fields显式指定django应该用于关系的外键。如下代码所示：

  class Person(models.Model):
      name = models.CharField(max_length=50)
  
  class Group(models.Model):
      name = models.CharField(max_length=128)
      # 由于中间表有两个外键(成员和邀请人)，在这种情况下，必须通过through_fields来指定django应该使用的外键是哪两个字段
      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)
  

  ManyToManyField不支持validators。null没有作用，因为没有办法在数据库级别上要求关系。

对对多ORM操作

• 模型如下，且自定义了中间模型

  from django.db import models
  
  class Person(models.Model):
      name = models.CharField(max_length=128)
  
      def __str__(self):
          return self.name
  
  class Group(models.Model):
      name = models.CharField(max_length=128)
      members = models.ManyToManyField(Person, through='Membership')
  
      def __str__(self):
          return self.name
  
  class Membership(models.Model):
      person = models.ForeignKey(Person, on_delete=models.CASCADE)
      group = models.ForeignKey(Group, on_delete=models.CASCADE)
      date_joined = models.DateField()
      invite_reason = models.CharField(max_length=64)
  

   >>> zhangsan = Person.objects.create(name="zhangsan")
   >>> basketball = Group.objects.create(name="basketball")
   >>> m = Membership(person=zhangsan, group=basketball,date_joined=date(1962, 8, 16),invite_reason="play basketball")
   >>> m1.save()
   >>> basketball.members.all()
   <QuerySet [<Person: zhangsan Starr>]>
   >>> zhangsan.group_set.all()
   <QuerySet [<Group: basketball>]>

如下只要通过through_defaults为任何必填字段指定值，就可以使用add()， create()或 set()来创建关系

   >>> lisi = Person.objects.create(name="lisi")
   >>> basketball.members.add(lisi, through_defaults={'date_joined': date(1960, 8, 1),invite_reason="play basketball"})

   >>> basketball.members.create(name="George Harrison", through_defaults={'date_joined': date(1960, 8, 1)})

   >>> wangwu = Person.objects.create(name="wangwu")
   >>> jack = Person.objects.create(name="jack")

   >>> beatles.members.set([wangwu, jack], through_defaults={'date_joined': date(1960, 8, 1),invite_reason="play basketball"})

OneToOneField

一对一的关系。从概念上讲，实际上是相当于ForeignKey 设置了unique=True，但是反向查询将直接返回单个对象。如果您未指定的related_name参数，则 OneToOneFielddjango会将当前模型的小写名称用作默认值。

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

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

您得到的User模型将具有以下属性：

>>> user = User.objects.get(id='xxxxx')
>>> hasattr(user, 'VIPUser')
True
>>> hasattr(user, 'inviter')
True

属性

• parent_link

  继承关系在子 model 和它的每个父类之间都添加一个链接 (通过一个自动创建的 OneToOneField来实现)。
  父类里面的所有字段在 子model中也是有效的，只不过没有保存在数据库中的子model表中,在父类上使用parent_link=True声明自己的OneToOneField来覆盖隐式创建的OneToOneField