Django模型定义

2018-10-19  本文已影响0人  Am3

Django 模型定义

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

用 Python 代码来定义模型

示列代码：

from django.db import models

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

# 在数据库生成 blog_blogarticles 表

字段

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

字段名称的限制

字段类型的作用

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

模型字段类表

字段类 默认小组件 说明
AutoField N/A 根据 ID 自动递增的 IntegerField
BigIntegerField NumberInput 64 位整数，与 IntegerField 很像，但取值范围是 -9223372036854775808 到 9223372036854775807 。
BinaryField N/A 存储原始二进制数据的字段。只支持 bytes 类型。注意，这个字段的功能有限。
BooleanField CheckboxInput 真假值字段。如果想接受 null 值，使用 NullBooleanField 。
CharField TextInput 字符串字段，针对长度较小的字符串。大量文本应该使用 TextField 。有个额外的必须参数：max_length ，即字段的最大长度（字符个数）。
DateField DateInput 日期，在 Python 中使用 datetime.date 实例表示。有两个额外的可选参数： auto_now ，每次保存对象时自动设为当前日期 auto_now_add ，创建对象时自动设为当前日期。
DateTimeField DateTimeInput 日期和时间，在 Python 中使用 datetime.datetime 实例表示。与 DateField 具有相同的额外参数。
DecimalField TextInput 固定精度的小数，在 Python 中使用 Decimal 实例表示。有两个必须的参数： max_digits 和 decimal_places 。
DurationField TextInput 存储时间跨度，在 Python 中使用 timedelta 表示。
EmailField TextInput 一种 CharField ，使用 EmailValidator 验证输入。max_length 的默认值为 254 。
FileField ClearableFileInput 文件上传字段。详情见下面。
FilePathField Select 一种 CharField ，限定只能在文件系统中的特定目录里选择文件。
FloatField NumberInput 浮点数，在 Python 中使用 float 实例表示。注意， field.localize 的值为 False 时，默认的小组件是 TextInput 。
ImageField ClearableFileInput 所有属性和方法都继承自 FileField ，此外验证上传的对象是不是有效的图像。增加了 height 和 width 两个属性。需要 Pillow 库支持。
IntegerField NumberInput 整数。取值范围是 -2147483648 到 2147483647 ，在 Django 支持的所有数据库中可放心使用。
GenericIPAddressField TextInput IPv4 或 IPv6 地址，字符串形式（如 192.0.2.30 、2a02:42fe::4 ）。
NullBooleanField NullBooleanSelect 类似于 BooleanField ，但是 NULL 可作为其中一个选项。
PositiveIntegerField NumberInput 整数。取值范围是 0 到 2147483647 ，在 Django 支持的所有数据库中可放心使用。
SlugField TextInput 别名（slug）是报业术语，是某个事物的简短标注，只包含字母、数字、下划线或连字符。
SmallIntegerField NumberInput 类似于 IntegerField ，但是对值有限制。取值范围是 -32768 到 32767 ，在 Django 支持的所有数据库中可放心使用。
TextField Textarea 大段文本字段。如果指定了 max_length 选项，这一限制在自动生成的表单字段中会体现出来。
TimeField TextInput 时间，在 Python 中使用 datetime.time 实例表示。
URLField URLInput 用于输入 URL 的 CharField 。可选 max_length 选项。
UUIDField TextInput 用于存储通用唯一标识码。使用 Python 的 UUID 类。

文件和图片上传

文件上传

参数 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 路径时，就不用改前端了。

字段选项参数

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

选项 说明
null 如果为 True，Django 将空值以 NULL 存储到数据库中，默认值是 False， null 是数据库范畴的概念。
blank 如果为 True，则该字段允许为空白，默认值是 False， blank 是表单验证证范畴的。
choices 可迭代的对象（如列表或元组），由两个元组（包括自身）组成的可迭代对象构成（如 [(A, B), (A, B) …]），用于设定字段的选项。如果设定这个选项，默认的表单小组件将由标准的文本字段变成带选项的选择框。各元组中的第一个元素是真正在模型上设定的值，第二个元素是人类可读的名称。
db_column 字段使用的数据库列名称。如未指定，Django 将使用字段的名称。
db_index 设为 True 时，在字段上建立数据库索引。
default 字段的默认值
editable 设为 False 时，字段不在管理后台或其他 ModelForm 中显示。验证模型时也会跳过。默认为 True。
error_messages 用于覆盖字段抛出异常时的默认消息。值为一个字典，通过键指定想覆盖的错误消息。错误消息键包括 null、blank、invalid、invalid_choice、unique 和 unique_for_date。
primary_key 设为 True 时，指定字段为模型的主键。
unique 设为 True 时，在表中字段的值必须是唯一的。除了 ManyToManyField、OneToOneField 和 FileField 之外，其他字段都可以设定这个选项。
verbose_name 字段的人类可读名称。如果未设定，Django 将使用字段的属性名称（下划线转换成空格）自动生成一个。

关系

多对一 (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)
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.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）

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: 在模型中增加一个子类，如

模型元数据选项

选项 说明
abstract 设为 True 时表明模型是抽象基类。
app_label 如果定义模型的应用不在 INSTALLED_APPS 中，必须指定所属的应用。
db_table 模型使用的数据库表名称。
db_tablespace 模型使用的数据库表空间。默认为项目的 DEFAULT_TABLESPACE 设置（如果设定了）。如果数据库后端不支持表空间，忽略这个选项。
default_related_name 关联的对象回指这个模型默认使用的名称。默认为<model_name>_set。
get_latest_by 模型中可排序字段的名称，通常是一个 DateField、DateTimeField 或 IntegerField。
managed 默认为 True，即让 Django 在迁移中创建适当的数据库表，并在执行 flush 管理命令时把表删除。
order_with_respect_to 标记对象为可排序的，排序依据是指定的字段。
ordering 对象的默认排序，获取对象列表时使用。
permissions 创建对象时写入权限表的额外权限。
default_permissions 默认为 ('add', 'change', 'delete')。
proxy 设为 True 时，定义为另一个模型的子类的模型视作代理模型。
select_on_save 指明是否让 Django 使用 1.6 版之前的 django.db.models.Model.save() 算法。
unique_together 设定组合在一起时必须唯一的多个字段名称。
index_together 设定在一起建立索引的多个字段名称。
verbose_name 为对象设定人类可读的名称（单数）。
verbose_name_plural 设定对象的复数名称。

模型继承

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 类

抽象基类中的 related_name 和 related_query_name

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

上面的继承关系中：

如果没有在抽象基类中定义 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 = []

代理继承

代理模型的作用：

声明一个代理模型只需要将 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排序。

基类的限制

代理模型的管理器

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

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
上一篇 下一篇

猜你喜欢

热点阅读