总结

    1. ORM表和表之间的关系
        1. 一对多           --> 外键(ForeignKey)
        2. 多对多           --> 另外一张关系表(ManyToManyField)
            1. 三种方式
                1. 自己建立第三张关系表，外键分别关联两个表
                    1. 优点
                        1. 可以扩充第三张关系标的字段
                    2. 缺点
                        1. 自己做连表查询
                2. 通过ORM内置的ManyToManyField，自动创建第三张关系表
                    1. 优点
                        1. 提供了很多连表操作的快捷方法--> all(), add(), set(), clear(), remove()
                    2. 缺点
                        1. 无法扩展第三张关系表
                
                3. 自己创建第三张关系表，通过ManyToManyField关联
                    1. 优点：
                        1. 既能够使用多对多查询的快捷方法all()，还能够自己扩展第三张关系表的字段
            2. 以后该用哪种？
                1. 当第三张关系表中不需要其他额外字段的时候，我们就用默认ManyToManyField就可以了
                2. 当第三张关系表中需要额外的字段时，我们就要用第三种方式，自己建立第三张关系表并且用ManyToManyField关联
            
            
        3. 一对一           --> OneToOneField    
            1. 当一张表里的字段非常多，并且某几个字段的查询频率远远大于其他字段的时候
            2. 把常用字段单独拆成一张表，查询的时候更快捷！

    2. ORM关联查询
        1. 基于对象的查询
            1. 正向查
                对象.关联字段
            2. 反向查
                1. 默认不设置related_name属性
                    1. 查找的对象是多个的时候（一对多或多对多时）
                        publisher_obj.book_set.all()
                    2. 查找的对象时一个的时候（一对一）
                        author_info_obj.author.name
                2. 设置related_name='books'属性
                    publisher_obj.books.all()
        
        2. 基于QuerySet的查询
            1. 正向查
                Book.objects.filter(id=1).values_list('publisher__name')
            2. 反向查
                1. 默认不设置related_name属性,默认就用类名的小写
                    Publisher.objects.filter(id=1).values_list('book__price')
                2. 设置related_name='books'属性
                    Publisher.objects.filter(id=1).values_list('books__price')

ForeignKey(一对多)操作

正向查找

对象查找（跨表）

语法：

　　对象.关联字段.字段

book_obj = models.Book.objects.first()  # 第一本书对象
print(book_obj.publisher)  # 得到这本书关联的出版社对象
print(book_obj.publisher.name)  # 得到出版社对象的名字

字段查找（跨表）

语法：

　　关联字段__字段

print(models.Book.objects.values_list("publisher__name"))

反向操作

对象查找(基于对象)

语法：　　

　　obj.表名_set

publisher_obj = models.Publisher.objects.first()  # 找到第一个出版社对象
books = publisher_obj.book_set.all()  # 找到第一个出版社出版的所有书
titles = books.values_list("title")  # 找到第一个出版社出版的所有书的书名

字段查找(基于QuerySet)

语法：

''表名__字段''

titles = models.Publisher.objects.values_list("book__title")

ManyToManyField(多对多)

class RelatedManager

"关联管理器"是在一对多或者多对多的关联上下文中使用的管理器。

它存在于下面两种情况：

外键关系的反向查询
多对多关联关系

简单来说就是当点后面的对象可能存在多个的时候就可以使用以下的方法。

方法

create()

创建一个新的对象，保存对象，并将它添加到关联对象集之中，返回新创建的对象。

models.Publisher.objects.first().book_set.create(name='圣经', number='48', price=33.5, publisher=1)

add()

把指定的model对象添加到关联对象集中。

author_objs = models.Author.objects.filter(id__lt=3)
models.Book.objects.first().authors.add(*author_objs)

添加id

>>> models.Book.objects.first().authors.add(*[1, 2])

set()

更新model对象的关联对象。

>>> book_obj = models.Book.objects.first()
>>> book_obj.authors.set([2, 3])

remove()

从关联对象集中移除执行的model对象

>>> book_obj = models.Book.objects.first()
>>> book_obj.authors.remove(3)

clear()

从关联对象集中移除一切对象。

>>> book_obj = models.Book.objects.first()
>>> book_obj.authors.clear()

注意：

对于ForeignKey对象，clear()和remove()方法仅在null=True时存在。

举个例子：

ForeignKey字段没设置null=True时，

class Book(models.Model):
    title = models.CharField(max_length=32)
    publisher = models.ForeignKey(to=Publisher)

没有clear()和remove()方法：

>>> models.Publisher.objects.first().book_set.clear()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'RelatedManager' object has no attribute 'clear'

当ForeignKey字段设置null=True时，

class Book(models.Model):
    name = models.CharField(max_length=32)
    publisher = models.ForeignKey(to=Class, null=True)

此时就有clear()和remove()方法：

>>> models.Publisher.objects.first().book_set.clear()

注意：

对于所有类型的关联字段，add()、create()、remove()和clear(),set()都会马上更新数据库。换句话说，在关联的任何一端，都不需要再调用save()方法。