Django之模型系统

时间 2019-11-18

标签 django 模型系统栏目 Python 繁體版

原文原文链接

Django模型简介

Django 模型是与数据库相关的，与数据库相关的代码通常写在 models.py 中python

Django 支持 sqlite3, MySQL, oracle,PostgreSQL等数据库，只须要在settings.py中配置便可，不用更改models.py中的代码，丰富的API极大的方便了使用。mysql

数据库的设置

在Django中，django默认使用sqlite的数据库，django默认自带sqlite的数据库驱动git

引擎名称：django.db.backends.sqlite3正则表达式

settings.py默认支持的数据库sql

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

若是要改成mysql数据库，则修改成以下设置：数据库

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.mysql', 

        'NAME': 'books',    #你须要连接数据库的名称

        'USER': 'root',   #数据库主机受权的用户名

        'PASSWORD': '', #数据库受权的用户密码

        'HOST': '', #你的数据库主机，留空默认为localhost

        'PORT': '3306', #你的数据库端口

    }

}

提示：django

NAME即数据库的名字，在mysql链接前该数据库必须已经建立，而上面的sqlite数据库下的db.sqlite3则是项目自动建立

USER和PASSWORD分别是数据库主机受权的用户名和密码。

设置完后，再启动咱们的Django项目前，咱们须要激活咱们的mysql。

而后，启动项目，会报错：no module named MySQLdb

这是由于django默认你导入的驱动是MySQLdb，但是MySQLdb对于py3有很大问题，因此咱们须要的驱动是PyMySQL

因此，咱们只须要找到项目目录文件下的__init__,在里面写入：

import pymysql
pymysql.install_as_MySQLdb()


前提是安装了pymysql模块

ORM介绍

什么是ORM？

对象关系映射（Object Relational Mapping，简称ORM），是为了解决面向对象与关系数据库存在的互不匹配的现象的技术。数组

简单来讲，就是用面向对象的方式去操做数据库的建立表以及增删改查等操做。oracle

ORM来源

当咱们与一个面向对象的系统工做，还有的对象模型和关系数据库之间的不匹配。 app

ORM主要是解决面向对象的设计方式和关系型数据库之间的关联，O/R 的o（object）主要面向对象设计，然而数据库是relational的

所以在分析业务的时候会以对象的角度来看待问题。所以才有ORM.开发人员在整个代码设计都将遵循对象的思惟模式.

面向对象是从软件工程基本原则(如耦合、聚合、封装)的基础上发展起来的，而关系数据库则是从数学理论发展而来的，两套理论存在显著的区别。为了解决这个不匹配的现象,对象关系映射技术应运而生。

什么是耦合，聚合，封装

耦合：耦合指各个模块以前的关联程度

聚合：是指一个模块内部各个部分之间的关联程度

封装原则：隐藏对象的属性和实现细节，仅对外公开借口，而且控制访问级别

在面向对象方法中，用类来实现上面的要求。用类实现封装，用封装来实现高内聚，低耦合。

用ORM的好处

让业务代码访问对象，而不是数据库表。

隐藏了面向对象的逻辑SQL查询详情。

基于业务概念，而不是数据库结构的实体。

应用程序的快速开发。

防止了sql注入

Django的ORM相关操做

类映射模型

每一个类对应一个表。类的属性就是数据库的表和类型

在(models.py文件中写)

简单示例一段代码

from django.db import models
class Publisher(models.Model):
    name = models.CharField(max_length=30, verbose_name="名称")
    address = models.CharField("地址", max_length=50)
    def __str__(self):        
        return self.name
# verbose_name表示显示的别名，相似数据的select as 操做 
# verbose也能够不写跟address同样直接起别名，可是必须放在一个位置

__str__表示：用一个字段替代类自己做为返回值

类模型的字段类型

1. models.AtuoField() 自增列，若不写Django自动添加，若要自定义自增列，必须设置为主键primary_key=True
2. BigAutoField(AutoField)
        - bigint自增列，必须填入参数 primary_key=True

        注：当model中若是没有自增列，则自动会建立一个列名为id的列
        from django.db import models

        class UserInfo(models.Model):
            # 自动建立一个列名为id的且为自增的整数列
            username = models.CharField(max_length=32)

        class Group(models.Model):
            # 自定义自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)

3. models.CharField() 字符串字段，必填参数max_length，在数据层和表单验证中均起做用，用来限定字段的长度
4. models.IntegerField() 整型
5. models.BigIntegerField() 长整型
    对应的变化范围：
    integer_field_ranges = {
　　　　'SmallIntegerField': (-32768, 32767),
　　　　'IntegerField': (-2147483648, 2147483647),
　　　　'BigIntegerField': (-9223372036854775808, 9223372036854775807),
　　　　'PositiveSmallIntegerField': (0, 32767),
　　　　'PositiveIntegerField': (0, 2147483647),
　　}

#自定义无符号整数字段

        class UnsignedIntegerField(models.IntegerField):
            def db_type(self, connection):
                return 'integer UNSIGNED'

        PS: 返回值为字段在数据库中的属性，Django字段默认的值为：
            'AutoField': 'integer AUTO_INCREMENT',
            'BigAutoField': 'bigint AUTO_INCREMENT',
            'BinaryField': 'longblob',
            'BooleanField': 'bool',
            'CharField': 'varchar(%(max_length)s)',
            'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
            'DateField': 'date',
            'DateTimeField': 'datetime',
            'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
            'DurationField': 'bigint',
            'FileField': 'varchar(%(max_length)s)',
            'FilePathField': 'varchar(%(max_length)s)',
            'FloatField': 'double precision',
            'IntegerField': 'integer',
            'BigIntegerField': 'bigint',
            'IPAddressField': 'char(15)',
            'GenericIPAddressField': 'char(39)',
            'NullBooleanField': 'bool',
            'OneToOneField': 'integer',
            'PositiveIntegerField': 'integer UNSIGNED',
            'PositiveSmallIntegerField': 'smallint UNSIGNED',
            'SlugField': 'varchar(%(max_length)s)',
            'SmallIntegerField': 'smallint',
            'TextField': 'longtext',
            'TimeField': 'time',
            'UUIDField': 'char(32)',

6. models.FloatField() 浮点型
7. models.BooleanField() 布尔型=tinyint(1)，不能为空 Blank=True
8. NullBooleanField(Field):
        - 能够为空的布尔值
9. TextField(Field)
        - 文本类型

10. EmailField(CharField)：
        - 字符串类型，Django Admin以及ModelForm中提供验证机制

11. IPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制

12. GenericIPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
        - 参数：
            protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
            unpack_ipv4， 若是指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启刺功能，须要protocol="both"

13. URLField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证 URL

14. SlugField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、链接符（减号）

15. CommaSeparatedIntegerField(CharField)
        - 字符串类型，格式必须为逗号分割的数字

16. UUIDField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证

17. FilePathField(Field)
        - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
        - 参数：
                path,                      文件夹路径
                match=None,                正则匹配
                recursive=False,           递归下面的文件夹
                allow_files=True,          容许文件
                allow_folders=False,       容许文件夹

18. FileField(Field)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage

19. ImageField(FileField)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
            width_field=None,   上传图片的高度保存的数据库字段名（字符串）
            height_field=None   上传图片的宽度保存的数据库字段名（字符串）

20. DateTimeField(DateField)
        - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

21. DateField(DateTimeCheckMixin, Field)
        - 日期格式      YYYY-MM-DD

22. TimeField(DateTimeCheckMixin, Field)
        - 时间格式      HH:MM[:ss[.uuuuuu]]

23. DurationField(Field)
        - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型

24. FloatField(Field)
        - 浮点型 通常不经常使用，由于要精确

25. DecimalField(Field)
        - 10进制小数
        - 参数：
            max_digits，小数总长度
            decimal_places，小数位长度

26. BinaryField(Field)
        - 二进制类型

字段类型的参数

一、null=True
　　数据库中字段是否能够为空
二、primary_key = False
　　主键，对AutoField设置主键后，就会代替原来的自增 id 列
三、auto_now 和 auto_now_add
　　auto_now   自动建立---不管添加或修改，都是当前操做的时间
　　auto_now_add  自动建立---永远是建立时的时间
四、choices  性别选择经常使用
GENDER_CHOICE = (
        (u'M', u'Male'),
        (u'F', u'Female'),
    )
gender = models.CharField(max_length=2,choices = GENDER_CHOICE)
五、max_length
六、default　　默认值
七、name|db_column　　数据库中字段的列名
八、unique=True　　不容许重复，自建索引
九、db_index = True　　数据库索引
十、editable=True　　在Admin里是否可编辑
十一、error_messages=None　　错误提示
十二、auto_created=False　　自动建立
1三、upload-to   上传到哪一个位置,更多与image,filepath配合使用

#Admin相关
一、blank=True
　　django的 Admin 中添加数据时是否可容许空值
二、help_text　　在Admin中提示帮助信息
三、blank    Admin中是否容许用户输入为空
四、editable  Admin中是否能够编辑
五、verbose_name　　Admin中字段的显示名称
六、 error_messages  自定义错误信息（字典类型），从而定制想要显示的错误信息；
    字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
    如：{'null': "不能为空.", 'invalid': '格式错误'}
七、validators=[]
自定义错误验证（列表类型），从而定制想要的验证规则
from django.core.validators import RegexValidator
from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
 MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
 如：
     test = models.CharField(
         max_length=32,
         error_messages={
             'c1': '优先错信息1',
             'c2': '优先错信息2',
             'c3': '优先错信息3',
         },
         validators=[
             RegexValidator(regex='root_\d+', message='错误了', code='c1'),
             RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
             EmailValidator(message='又错误了', code='c3'), ]
     )

元信息

class UserInfo(models.Model):
    nid = models.AutoField(primary_key=True)
    username = models.CharField(max_length=32)
    class Meta:
        # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
        db_table = "table_name"

        # 联合索引
        index_together = [
            ("pub_date", "deadline"),
        ]

        # 联合惟一索引
        unique_together = (("driver", "restaurant"),)

        # admin中显示的表名称
        verbose_name   相似as别名

        # verbose_name加s
        verbose_name_plural

    更多：https://docs.djangoproject.com/en/1.10/ref/models/options/
注:
1.触发Model中的验证和错误提示有两种方式：
    a. Django Admin中的错误信息会优先根据Admiin内部的ModelForm错误信息提示，若是都成功，才来检查Model的字段并显示指定错误信息
    b. 调用Model对象的 clean_fields 方法，如：
        # models.py
        class UserInfo(models.Model):
            nid = models.AutoField(primary_key=True)
            username = models.CharField(max_length=32)

            email = models.EmailField(error_messages={'invalid': '格式错了.'})

        # views.py
        def index(request):
            obj = models.UserInfo(username='11234', email='uu')
            try:
                print(obj.clean_fields())
            except Exception as e:
                print(e)
            return HttpResponse('ok')

       # Model的clean方法是一个钩子，可用于定制操做，如：上述的异常处理。

2.Admin中修改错误提示
    # admin.py
    from django.contrib import admin
    from model_club import models
    from django import forms


    class UserInfoForm(forms.ModelForm):
        username = forms.CharField(error_messages={'required': '用户名不能为空.'})
        email = forms.EmailField(error_messages={'invalid': '邮箱格式错误.'})
        age = forms.IntegerField(initial=1, error_messages={'required': '请输入数值.', 'invalid': '年龄必须为数值.'})

        class Meta:
            model = models.UserInfo
            # fields = ('username',)
            fields = "__all__"


    class UserInfoAdmin(admin.ModelAdmin):
        form = UserInfoForm

    admin.site.register(models.UserInfo, UserInfoAdmin)

关系映射（表关系）模式

经常使用的有三种：

一对多（one-to-many）
多对多（many-to-many）
一对一（one-to-one）

一对一的关系（one－to－one）：相似于每一个人和他的身份证之间的关系

用简单实际环境介绍其余模型，以下：

出版商模型：出版商有名称，地址，所在城市，省，国家和网站。

书籍模型：书籍有书名和出版日期，一本书可能会有多个做者，一个做者也能够写多本书，因此做者和书籍的关系就是多对多的关联关系（many－to－many），一本书只应该由一个出版商出版，因此出版商和书籍是一对多关联关系（one－to－many），也被称做外键。

先介绍一张表，对表记录的增删改查

ORM之单表操做

表记录的添加

在models.py 建一个类，叫Author

from django.db import models
class Author(models.Model):
    name = models.CharField(max_length=33)
    age = models.IntegerField()

其次

生成数据库脚本
python manage.py makemigrations


迁移数据库
python manage.py migrate

添加表记录的两种方式

在视图函数里写

第一种create方式：

from django.shortcuts import render,HttpResponse
from app01.models import *
# Create your views here.

def author(request):

    Author.objects.create(name="xixi",age=20)
    Author.objects.create(**{"name": "xiaoxi","age":19})

    return HttpResponse("表记录添加成功")


跟python函数的参数组kwargs用法相似

name表示表的字段，等号后面表示记录

第二种方式save：

def author(request):

    # Author.objects.create(name="xixi",age=20)
    # Author.objects.create(**{"name": "xiaoxi","age":19})

    # save方式一
    au = Author(name="yj",age=20)
    au.save()

    #save方式二
    thor = Author()
    thor.name="lq"
    thor.age=21
    thor.save()

    return HttpResponse("表记录添加成功")


save方式相似 ——类实例化

表记录删除delete()

from django.shortcuts import render,HttpResponse
from app01.models import *
# Create your views here.

def author(request):

    Author.objects.filter(id=1).delete()
    return HttpResponse("删除成功，id=1的记录")

#django为默认有一个id主键的字段


filter过滤出id=1的那个对象，相似sql 的where

一会介绍filter

表记录的修改

第一种方式get() save()方式

from django.shortcuts import render,HttpResponse
from app01.models import *
# Create your views here.

def author(request):

    thor = Author.objects.get(id=2)
    thor.name = "无语"
    thor.save()

    return HttpResponse("修改id=2 的name的记录")

第二种方式update()方式

from django.shortcuts import render,HttpResponse
from app01.models import *
# Create your views here.

def author(request):

    thor = Author.objects.get(id=2)
    thor.name = "无语"
    thor.save()

    return HttpResponse("修改id=2 的name的记录")

一会介绍get()操做，和 filter()操做，以及区别

表记录查询

查询的方法以下

类名.objects.查询的API

例如：

from django.shortcuts import render,HttpResponse
from app01.models import *
# Create your views here.

def author(request):


   
    ret1 = Author.objects.filter(id=2)
    print(ret1)
    #自已在项目运行的查看结果
    return HttpResponse("查询")

查询的API

1.filter(**kwargs):      它包含了与所给筛选条件相匹配的QuerySet对象
ret1 = Author.objects.filter(id=2)
    print(ret1)


2.all():                 查询全部结果,至关于查询表全部的表记录，只不过查询的是QuerySet对象
ret = Author.objects.all()
    print(ret)
    for i in ret:
        print(i.id,i.name,i.age)


3.get(**kwargs):         返回与所给筛选条件相匹配的类对象，返回结果有且只有一个，若是符合筛选条件的对象超过一个或者没有都会抛出错误。
    ret2 = Author.objects.get(id=2)
    print(ret2)  #Author object
    print(ret2.name)  #对象属性
    # 查询id=2的这条记录对象

立刻写QuerySet对象，先写对查询结果的处理

对查询结果的处理API

注：get没有如下方法

语法以下

类名.objects.查询的API.相应处理的API

1.values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后获得的并非一系列 model的实例化对象，而是一个可迭代的字典序列
例如：
result = Author.objects.filter(id=2).values()
    print(result)

2.exclude(**kwargs):     它包含了与所给筛选条件不匹配的Queryset对象
例如：
result = Author.objects.filter(id=2).exclude()
    print(result)
除了id=2，其余全部Queryset对象


3.order_by(*field):      对查询结果排序

4.reverse():             对查询结果反向排序

5.distinct():            从返回结果中剔除重复纪录

6.values_list(*field):   它与values()很是类似，它返回的是一个元组序列，values返回的是一个字典序列

7.count():              返回数据库中匹配查询(QuerySet)的对象数量。

8.first():               返回第一条记录

9.last():                返回最后一条记录

10.exists():             若是QuerySet包含数据，就返回True，不然返回False。

get和filter的区别

get 返回与所给筛选条件相匹配的类对象，返回结果有且只有一个，若是符合筛选条件的对象超过一个或者没有都会抛出错误。

filter 它包含了与所给筛选条件相匹配的QuerySet对象

get不能对查询结果作处理

聚合查询和分组查询

1.聚合查询aggregate(*args,**kwargs)

聚合查询至关于sql的聚合函数

经过对QuerySet进行计算，返回一个聚合值的字典。aggregate()中每个参数都指定一个包含在字典中的返回值。即在查询集上生成聚合

使用查询首先要在视图函数里面导入相关聚合接口的API

例如：

from django.db.models import Avg,Min,Sum,Max

简单示例：

from django.shortcuts import render,HttpResponse
from django.db.models import Avg,Min,Sum,Max
from app01.models import *
# Create your views here.

def author(request):

    #查询做者的总年龄
    TOTAL = Author.objects.all().aggregate(Sum("age"))
    print(TOTAL) #结果是这样{'age__sum': 101}


    return HttpResponse("聚合查询")

aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的
标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。
若是你想要为聚合值指定一个名称，能够向聚合子句提供它,则使用:
TOTAL = Author.objects.all().aggregate(SUM=Sum("age"))
    print(TOTAL) #结果是这样{'SUM': 101}

其余的聚合查询，跟上面差很少

2.分组查询annotate(*args,**kwargs):

能够经过计算查询结果中每个对象所关联的对象集合，从而得出总计值(也能够是平均值或总和)，即为查询集的每一项生成聚合。

就是sql语句的group by，在sql语句中的group by：

GROUP BY是SELECT语句的从句，用来指定查询分组条件，主要用来对查询的结果进行分组，相同组合的分组条件在结果集中只显示一行记录。使用GROUP BY从句时候，经过添加聚合函数（主要有COUNT()、SUM、MAX()、MIN()等）可使数据聚合。

我建立的这个单表很差举例，就简单看用annotate用法：

from django.shortcuts import render,HttpResponse
from django.db.models import Avg,Min,Sum,Max
from app01.models import *
# Create your views here.

def author(request):

    TOTAL = Author.objects.values("age").annotate(Sum("age"))
    print(TOTAL)

QuerySet

Author.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会立刻执行sql，而是当调用QuerySet的时候才执行。所以Queryset是惰性

QuerySet特色

对于QuerySet对象最直接的两个特色：

可迭代的
可切片

objs=models.Book.objects.all()#[obj1,obj2,ob3...]

#迭代
for obj in objs:#每一obj就是一个行对象
     print("obj:",obj)

#切片
 print(objs[1])
print(objs[1:4])
print(objs[::-1])

QuerySet的高效使用

当一个表里面有上亿条记录的时候，用 models.xxx.objects.all() 所有读取到内存时候，这会对内存特别浪费，更糟糕的是，巨大的queryset可能会锁住系统进程，

使程序崩溃，要避免在遍历数据的同时产生queryset cache，可使用iterator()方法来获取数据，处理完数据就将其丢弃。

objs = models.xxx.objects.all().iterator()
        # iterator()能够一次只从数据库获取少许数据，这样能够节省内存
for obj in objs:
       print(obj.name)
#BUT,再次遍历没有打印,由于迭代器已经在上一次遍历(next)到最后一次了,没得遍历了
for obj in objs:
        print(obj.name)

 #固然，使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。因此使
#用iterator()的时候要小心，确保你的代码在操做一个大的queryset时没有重复执行查询

总结:
queryset的cache是用于减小程序对数据库的查询，在一般的使用下会保证只有在须要的时候才会查询数据库。
使用exists()和iterator()方法能够优化程序对内存的使用。不过，因为它们并不会生成queryset cache，可能
会形成额外的数据库查询。

ORM之一对多关系

Django 使用 django.db.models.ForeignKey 定义多对一关系。和使用其它字段类型同样：在模型当中把它作为一个类属性包含进来。

ForeignKey 须要一个位置参数：与该模型关联的类。

好比，一辆汽车（Car）有一个制造商（Manufacturer） —— 可是一个制造商（Manufacturer） 生产不少汽车（Car），每一辆汽车（Car） 只能有一个制造商（Manufacturer）

from django.db import models

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

class Car(models.Model):
    manufacturer = models.ForeignKey(Manufacturer)

ORM之多对多关系　

ManyToManyField 用来定义多对多关系，用法和其余Field 字段类型同样：在模型中作为一个类属性包含进来。

ManyToManyField 须要一个位置参数：和该模型关联的类。

例如，一个披萨能够有多种馅料 ，一种馅料 也能够位于多个披萨上。以下展现：

from django.db import models

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

class Pizza(models.Model):
    # ...
    toppings = models.ManyToManyField(Topping)

在哪一个模型中设置 ManyToManyField 并不重要，在两个模型中任选一个便可 —— 不要两个模型都设置。

一般，ManyToManyField 实例应该位于能够编辑的表单中。要结合实际

多对多关系中的其余字段

处理相似搭配 pizza 和 topping 这样简单的多对多关系时，使用标准的ManyToManyField 就能够了。可是，有时你可能须要关联数据到两个模型之间的关系上。

例如，有这样一个应用，它记录音乐家所属的音乐小组。咱们能够用一个ManyToManyField 表示小组和成员之间的多对多关系。可是，有时你可能想知道更多成员关系的细节，好比成员是什么时候加入小组的。

对于这些状况，Django 容许你指定一个中介模型来定义多对多关系。你能够将其余字段放在中介模型里面。源模型的ManyToManyField 字段将使用through 参数指向中介模型

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)
    group = models.ForeignKey(Group)
    date_joined = models.DateField()
    invite_reason = models.CharField(max_length=64)

中介模型的限制：

中介模型必须有且只有一个外键到源模型（上面例子中的Group），或者你必须使用ManyToManyField.through_fields 显式指定Django 应该在关系中使用的外键。若是你的模型中存在不止一个外键，而且through_fields没有指定，将会触发一个无效的错误。对目标模型的外键有相同的限制（上面例子中的 Person）。
对于经过中介模型与本身进行多对多关联的模型，容许存在到同一个模型的两个外键，但它们将被当作多对多关联中一个关系的两边。若是有超过两个外键，一样你必须像上面同样指定through_fields，不然将引起一个验证错误。
使用中介模型定义与自身的多对多关系时，你必须设置 symmetrical=False

ORM之多表操做

多表基本操做

增长

跟单表操做同样

第一种：create方式

第二种：
        1.类实例化
        2.save()

删除

1.clear

2.remove

修改

update

set,重置某一列的

查询

select

总结：多表的增删改查，基本同样，应用（__双下线）进行多表操做，

关联条件查询(__双下划线)

经常使用条件查询

字段__条件=相应查询格式或则内容

__exact    #j精确匹配

__gt=    #大于（经常使用数字）
__gte=  #大于等于
__in=[,,,]   #in查询  子查询   就是sql语句的in查询
_isnull=True/False   值为 True 或 False, 至关于 SQL语句IS NULL和IS NOT NULL.
__lt   #小于
__lte   #小于等于
__range=(start,end)   #范围测试（包含于之中）。  至关于BETWEEN  AND

__startswith=    #以什么开头
__istartswith=    #不区分大小写的开头
__endswith=    #以什么结尾
__contains=     #模糊查询   相似sql语句的LIKE
__regex=r'^(An?|The) +'    #自定义正则表达式查询
__search=    一个Boolean类型的全文搜索，以全文搜索的优点。这个很像 contains ，可是因为全文索引的优点，以使它更显著的快。  相似sql语句的match

关联查询

关联字段__另外一张的表的关联字段__相应条件=相应查询的格式或则内容

F查询和Q查询

若是咱们想将模型的一个字段与同一个模型的另一个字段进行比较该怎么办

用上面的关联条件查询，这时候确定是办不到的，这是后就不要用到F查询了

在这里引用官方实例

from django.db import models

class Blog(models.Model):
    name = models.CharField(max_length=100)
    tagline = models.TextField()

    def __str__(self):              # __unicode__ on Python 2
        return self.name

class Author(models.Model):
    name = models.CharField(max_length=50)
    email = models.EmailField()

    def __str__(self):              # __unicode__ on Python 2
        return self.name

class Entry(models.Model):
    blog = models.ForeignKey(Blog)
    headline = models.CharField(max_length=255)
    body_text = models.TextField()
    pub_date = models.DateField()
    mod_date = models.DateField()
    authors = models.ManyToManyField(Author)
    n_comments = models.IntegerField()
    n_pingbacks = models.IntegerField()
    rating = models.IntegerField()

    def __str__(self):              # __unicode__ on Python 2
        return self.headline

提示自已插入测试数据

F查询

提示：F查询——专门取对象中某列值（字段）的操做

示例：

 from django.db.models import F  #必须导入

#为了查找comments 数目多于pingbacks 的Entry，咱们将构造一个F() 对象来引用pingback 数目，并在查询中使用该F() 对象：
Entry.objects.filter(n_comments__gt=F('n_pingbacks'))

Django 支持对F() 对象使用加法、减法、乘法、除法、取模以及幂计算等算术操做，两个操做数能够都是常数和其它F() 对象。

#为了查找comments 数目比pingbacks 两倍还要多的Entry，咱们将查询修改成：

 Entry.objects.filter(n_comments__gt=F('n_pingbacks') * 2)

注：F查询一样也能够跨表关联查询

Q查询

filter() 等方法中的关键字参数查询都是一块儿进行“AND” 的。若是你须要执行更复杂的查询（例如OR 语句）

这时候就须要用到Q对象查询

class Poll(models.Model):
    question = models.CharField(max_length=100)
    put_date = models.DateField()

Q查询——对对象的复杂查询

示例：

from django.db.models import Q  #必须导入

#下面的Q 对象封装一个LIKE 查询：
Q(question__startswith='What')

Q 对象可使用& 和| 操做符组合起来。当一个操做符在两个Q 对象上使用时，它产生一个新的Q 对象。

#下面的语句产生一个Q 对象，表示两个"question__startswith" 查询的“OR” 

Q(question__startswith='Who') | Q(question__startswith='What')

它等同于下面的SQL WHERE 子句：
WHERE question LIKE 'Who%' OR question LIKE 'What%'

能够组合& 和| 操做符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可使用~ 操做符取反

Q(question__startswith='Who') | ~Q(pub_date__year=2005)

每一个接受关键字参数的查询函数（例如filter()、exclude()、get()）均可以传递一个或多个Q 对象做为位置（不带名的）参数。若是一个查询函数有多个Q 对象参数，这些参数的逻辑关系为“AND"。例如：

Poll.objects.get(
    Q(question__startswith='Who'),
    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
)

以翻译成这个SQL：
SELECT * from Poll WHERE question LIKE 'Who%'
    AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')

提示：

查询函数能够混合使用Q 对象和关键字参数。全部提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一块儿。可是，若是出现Q 对象，它必须位于全部关键字参数的前面。例如：

#合法
Poll.objects.get(
    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
    question__startswith='Who')

Q对象在前面



#不合法
Poll.objects.get(
    question__startswith='Who',
    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))