Django之模型系统

Django模型简介

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

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

数据库的设置

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

引擎名称：django.db.backends.sqlite3

settings.py默认支持的数据库

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', #你的数据库端口

    }

}

　　

提示：

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），是为了解决面向对象与关系数据库存在的互不匹配的现象的技术。

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

ORM来源

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

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)
        - 二进制类型

　　

字段类型的参数

1、null=True
　　数据库中字段是否可以为空
2、primary_key = False
　　主键，对AutoField设置主键后，就会代替原来的自增 id 列
3、auto_now 和 auto_now_add
　　auto_now   自动创建---无论添加或修改，都是当前操作的时间
　　auto_now_add  自动创建---永远是创建时的时间
4、choices  性别选择常用
GENDER_CHOICE = (
        (u'M', u'Male'),
        (u'F', u'Female'),
    )
gender = models.CharField(max_length=2,choices = GENDER_CHOICE)
5、max_length
6、default　　默认值
7、name|db_column　　数据库中字段的列名
8、unique=True　　不允许重复，自建索引
9、db_index = True　　数据库索引
10、editable=True　　在Admin里是否可编辑
11、error_messages=None　　错误提示
12、auto_created=False　　自动创建
13、upload-to   上传到哪个位置,更多与image,filepath配合使用

#Admin相关
1、blank=True
　　django的 Admin 中添加数据时是否可允许空值
2、help_text　　在Admin中提示帮助信息
3、blank    Admin中是否允许用户输入为空
4、editable  Admin中是否可以编辑
5、verbose_name　　Admin中字段的显示名称
6、 error_messages  自定义错误信息（字典类型），从而定制想要显示的错误信息；
    字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
    如：{'null': "不能为空.", 'invalid': '格式错误'}
7、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对象最直接的两个特点：

1. 可迭代的
2. 可切片

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)))