Django QuerySet和中介模型

笔记如下

一.QuerySet
QuerySet是什么？
类似列表里边存着对象
只和ORM有关系
from app01.models import Book

def qDemo(request):
    book_list = Book.objects.all()
    # 支持切片
    print(book_list[1:])
    # 支持遍历
    for book in book_list:
        print(book.id)
    # 惰性查询 （保证内存空间最大使用率）

    f = open('a.txt', 'r')
    for line in f.readlines():  # 一下全拿出来，内存可能装不下
        pass

    for line in f:  # 惰性求值，f充当迭代器对象，用一行取一行
        pass

    book_list = Book.objects.all()
    # 不用book_list。就不会执行sql语句,不走数据库。

    # 需要走数据库的操作(取决于用没用book_list里面的数据，即计算查询集)
    for book in book_list:  # 此时用到了就会走数据库去查询。
        print(book)

    print(book_list[1])

    if book_list:
        print('hello')

    ret = list(book_list)

    # 切片，序列化，缓存 ，list

    # 缓存机制
    book_list = Book.objects.all()

    for book in book_list:
        print(book.id)
    for book in book_list:
        print(book.id)

    # 打印两次，只走了一次数据库，查询一次就把结果放到book_list里缓存起来了

    book_list = Book.objects.all()

    for book in book_list:
        print(book.id)
    Book.objects.create(title='python')
    for book in book_list:
        print(book.id)

    # 两次用的都是第一次查询缓存的结果，新增的没有被用到。

    #  两次都去数据库查询
    for book in Book.objects.all():
        print(book)
    for book in Book.objects.all():
        print(book)

    # 优化QuerySet的缓存
    book_list = Book.objects.all()
    if book_list:  # 全查询出来，select * from db;
        print('里面有记录')

    # 上面我只想判断有没有，而他全查出来了
    if book_list.exists():  # 只取一条;
        print('里面有记录')

    # 缓存没问题，但是要限制量，当量非常大的时候怎么办？
    # 迭代器！
    book_list = Book.objects.all().iterator()
    print(type(book_list))  # <class 'generator'>

    for book in book_list:
        print(book)

    # 第二次打印的是空，因为生成器也是迭代器，取出一个少一个。

二.中介模型

class            student            courst

id name          id  name           id  name
1    s1          1    lcg            1   Go
                 2    ming           2   Python
s_c
id student_id  course_id
1       1         1
2       2         1
3       2         2
处理类似的多对多关系时，使用标准的ManyToManyField可以描述关系。
但是，有时你可能需要关联数据(score)到两个模型之间的关系上。
s_c
id student_id  course_id  score
1       1         1        80
2       2         1        90
3       2         2        100

ORM中介模型:

class Student(models.Model):
    name=...
class Course(models.Model):
    name=...
    students=models.ManyToMany("Student",through="Course_students")
    # through告诉ORM我自己去创建第三张表，不必给我自动创建，students这个字段我也用。
class Course_students(models.Model):
    student_id=mdoels.ForeignKey("Student")
    course_id=mdoels.ForeignKey("Course")
    score=models.IntegerFiled()

　　

总结：

QuerySet

惰性查询，缓存机制

查询优化：

if book_list.exists():
　　pass

缓存优化：book_list = Book.objects.all().iterator()

中介模型 多对多关系中，自己创建第三张表，并且保留关联字段（可使用ORM操作又扩展了第三张表的字段）

students=models.ManyToMany("Student",through="Course_students")

注意：
添加操作：
给python课程添加两个学生aa,bb
if 不是中介模型：
c=Course(name="python")
c.students.add('aa','bb')

if 使用中介模型：
Course_students实例对象的方法创建多对多关系