Django 模型定义

Django 模型是使用 Python 代码对数据库中数据的描述，是数据的结构，包含数据的字段和操作方法。

用 Python 代码来定义模型

• 每个模型都是 django.db.models.Model 的子类
• Django 自动生成访问数据库的 API
• 一个模型对应数据库中的一张表（多对多关系时，会生成一张额外的表来管理两者之间的关系）
• 模型的属性对应的数据库表中的一列
• 属性的名称对应着列的名称
• 字段的类型对应着数据库中列的类型
• 数据库中生成的表，默认格式是 '应用名称 + 下划线 + 小写类名'
• 如果没有指定主键，Django 会自动为定义一个自增量整数主键字段，名字叫 ID

示列代码：

from django.db import models

class BlogArticles(models.Model):
    title = models.CharField(max_length=64)

# 在数据库生成 blog_blogarticles 表

字段

字段在 Python 中表现为类属性 , 是模型中必不可少的。

字段名称的限制

• 字段名称不能是 Python 保留字
• 由于 Django 中双下划线是查询语法，所以字段名称不能包含多个连续的下划线

字段类型的作用

模型中的字段都是 Field 类的实例，字段有以下作用：

• 决定数据库列的类型（如 INTEGER 、 VARCHAR ）
• 确定在 Django 的表单和管理后台中使用什么组件（widget）（如 <input type="text" />）。
• 在 Admin 后台和自动生成的表单中做最基本的数据验证
• 字段都接受选项参数

模型字段类表

文件和图片上传

文件上传

• FileField 不支持 primary_key 和 unique 选项，否则会抛出 TypeError
• FileField 实例对应的是 varchar 列，最大长度默认为 100 个字符。可以通过 max_length 修改
• 默认的 HTML 中表单小组件是 ClearableFileInput
• 数据库里不存储文件，保存的是字符串（相对于 MEDIA_ROOT 的文件路径）
• 查看图片或者文件在数据库中的路径： 对象.字段名.url

参数 upload_to 用于设置上传地址的目录和文件名，示列代码：

# 在 settings.py 中配置路径
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

# 在 models.py 文件中定义模型
from django.db import models
from django.contrib.auth.models import AbstractUser

class UserProfile(AbstractUser):
    # workgerber 上传到了 '/media/image/2018/10' 文件夹中
    workgerber = models.FileField(upload_to="image/%Y/%m", verbose_name='生产gerber文件')
    image = models.ImageField(upload_to="image/%Y/%m", default='image/default.png', verbose_name='用户头像')

upload_to 参数也可以接收一个回调函数，回调函数接受两个参数：

1. 实列， FileField 所在模型的实例
2. 文件名

如：

from django.db import models
from django.contrib.auth.models import User

# instance 是位置参数，代指 Articles 实列本身
# 下列代码中文件保存在 MEDIA_ROOT/uid_1/ 文件夹
# 实现了根据用户 ID 来将文件分开保存
def user_directory_path(instance, filename):
    return 'uid_{0}/{1}'.format(instance.user.id, filename)

class Articles(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE, default=1)
    up_file = models.FileField(upload_to=user_directory_path)

图片上传

ImageFiel 是用于保存图像的字段，方法和属性都继承 FileField , 增加了验证上传的对象是否为有效的图像。增加了 height 和width 两个属性。需要 Pillow 库支持。

MEDIA URL 路径设置

在 settings.py 中配置路径

MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

假如 models.py 中 ImageField 字段：

class MyModel(models.Model):
    image = models.ImageField(upload_to="image/%Y/%m")

此时如果上传 car.jpg 图片，那么图片在数据库中保存的路径为 image/2018/10/car.jpg。

如果想要在前端使用 MEDIA_URL ，需要在 settings.py > TEMPLATES > context_processors 中

添加 django.template.context_processors.media，

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')]
        ,
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                # '''''''
                'django.template.context_processors.media',  # 添加在这里
            ],
        },
    },
]

然后就可以在前端模版中使用 MEDIA_URL:

<img class="ui image" src="{{ MEDIA_URL }}{{ content.image }}">

这样后端更改 MEDIA_URL 路径时，就不用改前端了。

字段选项参数

通过字段选项，可以实现对字段的约束。

关系

多对一 (ForeignKey)

多对一关系，需要两个位置参数，一个是关联的模型，另一个是 on_delete 选项，外键要定义在多的一方，如：

from django.db import models

# 一个作者可以有多篇文章
class Articles(models.Model):
    author = models.ForeignKey(User, on_delete=models.CASCADE)

要创建一个递归的外键，即一个对象和自身的多对一关系，如：

class Comment(models.Model):
    title = models.CharField(max_length=64)
    body = models.CharField(max_length=256)
    # 一个评论下面可以有多个评论
    parent_comment = models.ForeignKey('self', on_delete=models.CASCADE，null=True, blank=True)

多对一（ForeignKey）的参数

ForeignKey.on_delete

当外键关联的对象被删除时，Django 将模仿 on_delete 执行相应的操作，如：

# 当删除作者时，不删除对应的文章,将作者设置为 null
author = models.ForeignKey(User, on_delete=models.SET_NULL, blank=True, null=True)

• CASCADE ：模拟 SQL 语言中的 ON DELETE CASCADE 约束，将定义有外键的模型对象同时删除。
• PROTECT : 阻止上面的删除操作，但是弹出 ProtectedError 异常。
• SET_NULL ：将外键字段设为 null，只有当字段设置了 null=True 时，方可使用该值。
• SET_DEFAULT : 将外键字段设为默认值。只有当字段设置了 default 参数时，方可使用。
• DO_NOTHING ：什么也不做。
• SET() ：设置为一个传递给 SET() 的值或者一个回调函数的返回值。

ForeignKey.limit_choices_to

限制外键所能关联的对象，参数只能在 ModelForm 和 admin 后台使用，值可以是一个字典、Q 对象或者一个返回字典或 Q 对象的函数调用，如：

staff_member = models.ForeignKey(
    User,
    on_delete=models.CASCADE,
    limit_choices_to={'is_staff': True},
)
# 在 ModelForm 的 staff_member 字段列表中，只会出现那些 is_staff=True 的 Users 对象

参考下面的方式，使用函数调用：

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

# 把可选对象限定到 pub_date 早于当前时间的对象中
limit_choices_to = limit_pub_date_choices

ForeignKey.related_name

反向操作时，使用的字段名，用于代替 '表名_set' 如： object. 表名_set.all(), 也是 related_query_name（目标模型使用的反向过滤器名称）的默认值，如：

ForeignKey.related_query_name

反向操作时，使用的连接前缀，用于替换'表名' 如： models.UserGroup.objects.filter（表名__字段名称 =1)

ForeignKey.to_field

默认情况下，外键都是关联到被关联对象的主键上。如果指定这个参数，可以关联到关联表的指定字段上，但是该字段必须具有 unique=True 属性。

ForeignKey.db_constraint

决定是否在数据库中为这个外键创建约束. 默认值为 True

ForeignKey.swappable

控制外键指向可交换的模型时迁移框架的反应,默认值为 True

多对多 (ManyToManyField)

多对多有一个必须的位置参数，关联的对象模型。

class Tags(models.Model):
    name = models.CharField(max_length=32)

class Articles(models.Model):
    title = models.CharField(max_length=32)
    tag = models.ManyToManyField(Tags, blank=True)

多对多除了生成各自的表以外，还会生成第三张表，用来管理双方的关系，可以用 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

只用于与自身进行关联的ManyToManyField. 例如下面的模型

from django.db import models

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

默认的情况下，django 中多对多关系是对称的，django 不会为 Person 类添加 person_set 属性用于反向关联，如果不需要对称关系可以将symmetrical 设置为 False，强制 Django 为反向关联添加描述符

ManyToManyField.through

Django 会自动生成一个表，用于管理多对多关系。如果想自定义中间表，可以通过 through 选项指定表示中间表的 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',   # 自定义中间表 ‘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",
    )
    # 增加进入时间
    date_joined = models.DateField()
    # 增加邀请理由
    invite_reason = models.CharField(max_length=64)

ManyToManyField.through_fields

上面的例子中。Membership 模型中包含三个关联 Person 的外键，Django 无法确定到底使用哪个作为和 Group 关联的对象。所以，必须显式的指定 through_fields 参数，用于定义关系。

through_fields 参数接受一个元组（'field1', 'field2'） field1 指向定义多对多模型的外键字段名称（Membership模型中的 group），field2 指向目标模型 的外键字段名称()（Membership模型中的 person）。

如果中间表中只有两个外键的话，可以不用指定 through_fields,django一般可以自动识别。

ManyToManyField.db_table

设置中间表的名称，不指定的话使用默认值

ManyToManyField.db_constraint

同 ForeignKey.db_constraint

ManyToManyField.swappable

同 ForeignKey.swappable

一对一(OneToOneField)

一对一,在概念上, 它类似于设置了 unique=True 的 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, related_name='supervisor_of'， on_delete=models.CASCADE)

'User' 模型便具有了以下属性：

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

一对一(OneToOneField)参数

OneToOneField 接受的参数与 ForeignKey 完全一样，此外还有一个 parent_link 参数。

管理器

• Django 模型至少有一个管理器，可以自定义管理器，定制访问数据库的方式
• 模型的管理器是 Django 模型用于执行数据库查询的对象
• 当定义模型类时没有指定管理器，则 Django 会为模型类提供一个名为 objects 的管理器
• 自定义管理器可能出于两方面的原因：添加额外的管理器方法和（或）修改管理器返回的 QuerySet。
• 添加额外的管理器方法是为了给模型添加 数据表 层功能

添加额外的管理器方法

当不满足默认的管理器方法时，可以给管理器添加额外的方法，新的管理器需要继承 django.db.models.Manager , 在 model 中将 新管理器 赋值给 objects 即可

class BookManager(models.Manager):
    def title_count(self, keyword):
        return self.filter(title__icontains=keyword).count()
        # BookManager 类扩展 django.db.models.Manager
        # self 代指管理器本身

class Book(models.Model):
    title = models.CharField(max_length=128)
    authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)
    publication_data = models.DateField(blank=True, null=True)
    objects = BookManager()
        # BookManager() 赋值给模型的objects 属性
        # 将BookManager()替换“默认”管理器

    def __str__(self):
        return self.title

如此，objects 出来的原来的方法外，还多了一个 title_count() 方法，如下调用：

In [4]: Book.objects.title_count('ava')
Out[4]: 1

In [6]: Book.objects.all()
Out[6]: <QuerySet [<Book: Python3 Cook Book>, <Book: Java>]># BookManager()除了有title_count方法外，也有默认的objects其它方法

修改管理器返回的查询集合（QuerySet）

• 如果想修改管理器返回的 QuerySet，需要覆盖 Manager.get_queryset() 方法。get_queryset() 方法需要返回一个 Query-Set
• Django 遇到的第一个管理器（按照在模型中定义的顺序）定义为“默认的”管理器。
• 同一个模型上可以使用多个管理器

class MaleManager(models.Manager):
    def get_queryset(self):
    return super(MaleManager, self).get_queryset().filter(gender='Male')

class FemaleManager(models.Manager):
    def get_queryset(self):
    return super(FemaleManager, self).get_queryset().filter(gender='Female')

class Person(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    gender = models.CharField(max_length=6,
                            choices=(
                                    ('Male', '男'),
                                    ('Female', '女')
                                    )
                            )
    people = models.Manager() # 默认管理器，选择全部对象
    men = MaleManager()       # 只选择 gender = Male 的对象
    women = FemaleManager()   # 只选择 gender = Female 的对象

模型方法

模型中自定义的方法为对象添加数据行层的功能。管理器的作用是执行数据表层的操作，而模型方法处理的是具体的模型实例。

自定义模型方法

from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    birth_date = models.DateField()

    def baby_boomer_status(self):
        # 返回一个人的出生日期与婴儿潮的关系
        import datetime
        if self.birth_date < datetime.date(1945, 8, 1):
            return "Pre-boomer"
        elif self.birth_date < datetime.date(1965, 1, 1):
            return "Baby boomer"
        else:
            return "Post-boomer"

    def _get_full_name(self):
        # 返回一个人的全名
        return '%s %s' % (self.first_name, self.last_name)

    # 使用 property 函数将类方法包装为属性
    full_name = property(_get_full_name)

重写预定义的模型方法

如果想在调用 save() 等预定义方法之前做些什么的话，可以重写这些方法，如：

# save()    将模型对象保存到数据表中
class Blog(models.Model):
    name = models.CharField(max_length=100)
    tagline = models.TextField()

    def save(self, *args, **kwargs):
        do_something()
        super(Blog, self).save(*args, **kwargs) # 调用 “真正的” save() 方法
        do_something_else()

需要在方法中继承超类方法 super(Blog, self).save(*args, **kwargs) ,否则不会保存到数据库

Meta选项

使用 class Meta: 在模型中增加一个子类，如

模型元数据选项

模型继承

Django 的模型和 Python 的类一样，支持继承，有 3 种继承方式：

• 抽象基类
• 多表继承
• 代理模型

抽象基类

基类模型不会创建数据表，在模型中的 Meta 类中添加 abstract=True 将普通模型转换为抽象基类。子模型会拥有基类模型中的全部字段。如：

from django.db import models

class BaseModel(models.Model):
    name = models.CharField(max_length=32)
    thickness = models.CharField(max_length=6)
    length = models.CharField(max_length=12)
    height = models.CharField(max_length=12)
    create_time = models.DateTimeField(auto_now=True)

    class Meta:
        abstract = True

class CustomerBoard(BaseModel):
    customer_code = models.CharField(max_length=12)

    def __str__(self):
        return '{}_{}'.format(self.customer_code, self.name)

上面的 CustomerBoard 模型拥有抽象基类 BaseModel 中所有的字段，如：

In[5]: board = CustomerBoard.objects.get(pk=1)
In[6]: board.name
Out[6]: 'first board'
In[7]: board.thickness
Out[7]: '1.0mm'
In[8]: board.create_time
Out[8]: datetime.datetime(2018, 10, 11, 13, 1, 2, 190123, tzinfo=<UTC>)

抽象基类的 Meta 类

• 当子类没有定义自己的 Meta 类，子类将会继承抽象基类的 Meta 类。
• 当抽象基类有的元数据，在子类没有的话，直接继承没有的元数据。
• 当抽象基类有的元数据，在子类同样有的话，直接覆盖基类的元数据。
• 子类可以先继承抽象基类中的 Meta 元数据，然后再定义自己的 Meta 类添加额外的元数据。
• 在子模型中 Meta 中添加 abstract = True ，可以把子类变成抽象基类

抽象基类中的 related_name 和 related_query_name

ForeignKey 或 ManyToManyField 字段上使用的 related_name 和 related_query_name 属性时，需要制定唯一的反向名称，但是如果在抽象基类这样做的话，会出现所有继承该抽象基类的子模型 related_name 和 related_query_name 完全相同，可以使用 '%(app_label)s' 和 '%(class)s'字符串来解决

• '%(app_label)s' 会被子类所在的 APP 的名字取代
• '%(class)s' 会被子类的名字取代

如，在 app common 中，common/models.py：

from django.db import models

class Base(models.Model):
    m2m = models.ManyToManyField(
        OtherModel,
        related_name="%(app_label)s_%(class)s_related",
        related_query_name="%(app_label)s_%(class)ss",
    )

    class Meta:
        abstract = True

class ChildA(Base):
    pass

class ChildB(Base):
    pass

在另外一个 app 中，rare/models.py：

from common.models import Base

class ChildB(Base):
    pass

上面的继承关系中：

• common.ChildA.m2m 字段的反向名称为 common_childa_related
• common.ChildB.m2m 字段的反向名称为 common_childb_related
• rare app 中 rare.ChildB.m2m 字段的反向名称为 rare_childb_related

如果没有在抽象基类中定义 related_name 属性，反向名称就是 小写子模型名称_set。

多表继承

多表继承中，父类和子类都会创建数据库，继承关系是通过子模型和它每个父类添加一个自动创建的 OneToOneField 链接来实现，如：

from django.db import models

class Place(models.Model):
    name = models.CharField(max_length=50)
    address = models.CharField(max_length=80)

class Restaurant(Place):
    serves_hot_dogs = models.BooleanField(default=False)
    serves_pizza = models.BooleanField(default=False)

父模型 Place 所有的字段在 Restaurant 中都是可以使用的，但是字段不会保存在 Restaurant 中，如：

>>> Place.objects.filter(name="Bob's Cafe")
>>> Restaurant.objects.filter(name="Bob's Cafe")

如果一个 Place 也是一个 Restaurant，可以使用 Place对象.restaurant 取到对应的Restaurant 对象

>>> p = Place.objects.filter(name="Bob's Cafe")
# If Bob's Cafe is a Restaurant object, this will give the child class:
>>> p.restaurant
<Restaurant: ...>

如果上面的 P 只是单纯的 Place 那 p.restaurant 会抛出 Restaurant.DoesNotExist

多表继承中的Meta类型

除了 ordering 和 get_latest_by 两个元数据外，其余的元数据都不会被子类继承。

如果不想继承父类的 ordering 和 get_latest_by 参数，需要在之类中重写或者禁用:

class ChildModel(ParentModel):
    # ...
    class Meta:
        # 清空排序
        ordering = []

代理继承

代理模型的作用：

• 可以创建、删除、更新代理模型的实例，并且所有的数据都可以像使用原始模型（非代理类模型）一样被保存。
• 可以在代理模型中改变默认的排序方式和默认的 manager 管理器 等等，而不会对原始模型产生影响。

声明一个代理模型只需要将 Meta 中 proxy 的值设为 True 。如：

from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

class MyPerson(Person):
    class Meta:
        proxy = True

    def do_something(self):
        # ...
        pass

MyPerson类和它的父类 Person 操作同一个数据表。Person 的任何实例都可以通过 MyPerson访问，反之亦然：

>>> p = Person.objects.create(first_name="foobar")
>>> MyPerson.objects.get(first_name="foobar")
<MyPerson: foobar>

也可以让父类模型正常查询，而代理排序，如：

class OrderedPerson(Person):
    class Meta:
        ordering = ["last_name"]
        proxy = True

现在，普通的Person查询是无序的，而 OrderedPerson查询会按照last_name排序。

基类的限制

• 代理模型必须继承自一个非抽象基类。 并且不能继承自多个非抽象基类
• 代理模型可以继承任意多个抽象基类，但前提是它们没有定义任何 model 字段
• 代理模型可以同时继承多个别的代理模型，但前提是这些代理模型继承同一个非抽象基类

代理模型的管理器

如果代理模型中没有定义管理器，代理模型就会从父类中继承管理器。如果代理模型中定义了管理器，它就会变成默认的管理器，不过定义在父类中的管理器仍然有效。

from django.db import models

class NewManager(models.Manager):
    # ...
    pass

class MyPerson(Person):
    objects = NewManager()

    class Meta:
        proxy = True

只是需要添加管理器而不是替换默认管理器时，可以创建一个含有新的管理器的基类，并且在继承时把他放在主基类的后面：

# Create an abstract class for the new manager.
class ExtraManagers(models.Model):
    secondary = NewManager()

    class Meta:
        abstract = True

class MyPerson(Person, ExtraManagers):
    class Meta:
        proxy = True