Django ORM

一.单表操作
增删改查：
①Objects管理器,里面封装着增删改查的所有方法.
查：
models.类名.objects.all() 取所有
models.类名.objects.get() 取一个，取不到就报错
models.类名.objects.filter(条件) 根据条件查找，返回的是[object1, objdect2 ...]
models.类名.objects.exclude(条件) 排除满足条件的
models.类名.objects.first()
models.类名.objects.last()
增加：
Create方法有返回值，返回的是一个对象。

models.类名.objects.create(name="王永飞", age=18)
obj = models.类名(name="王永飞", age=18)
bj.save()
删除：models.类名.objects.filter(age=18).delete()
修改：models.类名.objects.filter(age=18).update(name="装嫩")
注意：单个对象不能调用update
obj = models.类名.objects.get(id=2)
obj.name = "一枝花"
obj.save()

二. ORM查询API
(1) 这些查询API只有返回数据对象的才可以”.”表结构中的字段,返回其他数据类型的都不可以”.”表结构中的字段,因为表是以类的形式写的,只有对象才可以用”.”调用属性.
(2) 返回对象的数据类型,之后不能够·其他的ORM查询API.
(3) 终止字句:终止字句是后面不能再继续”.”的API方法,count就是终止字句.
(4) 配合filter做查询的各种查询方法，如果后面不再点返回非QuerySet对象的方法，返回值是QuerySet。
(5) QuerySet的特点
a.可切片
①不支持不支持负的索引
②一旦切片就不能继续first()了
Cannot filter a query once a slice has been taken.
切片后的结果还是列表（queryset）
可迭代

articleList=models.Article.objects.all()
for article in articleList:
    print(article.title)

b.惰性查询
注意是惰性查询，不是惰性创建
创建的查询语句不会自动带来数据库的访问，查询语句需要求值时才会执行。

s=models.Book.objects.all()[:2]   # not hits database
print(s)   # hits database
# <QuerySet [<Book: Book object>, <Book: Book object>]>
for book in s:   # hits database
    print(book.title)   # hits database  
# 打印结果：
# linux宝典

（6）get方法的特点
get方法返回的是model对象，返回值只能由一个，如果超过一个或者没有返回值，则查询结果报错。

返回QuerySet的:

.all()
.filter()
括号中：字段1=值1，字段2=值2
其中逗号的作用表示：且
也表示：是同一条记录的字段
不传参数，表示取所有的
values()
返回值是列表套字典的形式
注意:传入的参数是表中的字段，而且传入必须是”字段”的形式。
.values_list()
返回值是列表套元组的形式
注意:传入的参数是表中的字段，而且传入必须是”字段”的形式。
exclude()
与所给筛选条件不匹配的对象
order_by()
对结果进行排序
在括号里面得值加负号，堆排序结果再次反序
reverse()
对结果进行反向排序
在括号里面得值加负号，堆排序结果再次反序
distinct()
从返回结果中剔除重复纪录

返回单个数据对象：

first()
返回第一条记录
last()
返回最后一条记录
get()
返回与所给筛选条件相匹配的对象，返回结果有且只有一个，
如果符合筛选条件的对象超过一个或者没有都会抛出错误

返回布尔值的：

exists()
如果QuerySet包含数据，就返回True，否则返回False
ret=Book.objects.all().first()
应用：以下ret=Book.objects.all().exists()虽然返回的是布尔值，但实际上代码再运行的时候，只要能够查询到一条，就返回为True,运行效率比较高。

ret=Book.objects.all().exists()
if ret:
    pass

返回数字的：

count()
注意：count取出来的是一个数字，不能再继续点下去

配合filter()来做各种查询。

id__gt=1 大于
id__lt=3 小于
id__in=[1,2,3] 在之内
是否在一个给定的列表中。
id__range=[1,5]
包含的范围。前包含，也后包含
name__contains="s"
icontains忽略大小写的包含匹配
name__icontains="s"
不忽略大小写的包含匹配
name__startwith="a"
startswith大小写敏感的以....开头。
name__endswith="x"
endswith大小写敏感的以....结尾。
first_day__year="2018"
cname__isnull=True *!
据 SQL 查询是空 IS NULL 还是非空 IS NOT NULL，返回相应的 True 或 False。

示例

# model.py
class Book():
    title=model.CharField(max_length=32)

单表操作：
添加：

book_obj=Book.objects.create(title="python",price=123)
book_obj=Book(title="python",price=123)
book_obj.save()

查询：

1.Book.objects.all()                          #  QuerySet()  [obj1,obj2,....]  
2.Book.objects.filter(price__gt=100,id__gt=5)  #  QuerySet()  [obj1,obj2,....]  
3.Book.objects.get(title="python")         #  model对象
4.Book.objects.exclude()
5.Book.objects.all().order_by("-price")
6.Book.objects.all().values("title","id","publish__name")          # QuerySet()    []  
7.Book.objects.all().values_list()     
8.Book.objects.all().values("title","id","publish__name").distinct()
9.Book.objects.all().count()             #终止子句
10.Book.objects.all().first()   model对象
11.Book.objects.all().last()    model对象
12.Book.objects.all()[2:5]

注意Values的原理

l=[]
for obj in Book.objects.all():
    temp={}
    temp["title"]=obj.title
    temp["id"]=obj.id
    temp["publish__name"]=obj.publish.name    # QuerySet()    []
    l.append(temp)

删除：

Book.objects.all().delete()

修改：

Book.objects.filter(id=1).update(title="linux")  --- 推荐       
obj=Book.objects.filter(id=1)[0]
obj.title="linux"
obj.save()

三.多表查询
表之间的关系

一对多
一对一
①对应关系：
类 --> 表
类的属性 --> 字段
实例对象 --> 一条数据（数据行）

②数据库层面：
外键对应另外一个表的一条记录

③ORM层面：
假如在models的某张表中外键是字段为“s”,那么在表中的字段为“s_id”
外键对应另外一个表的一个对象
Student_objs.s --->指的是对象
student_obj.s_id --> 具体的值

④正向查询与反向查询的定义
通过在models.py中foreignKey，或OneToOneField或ManyToMany所在表结构对应的表，查询另一张表叫做正向查询。反之叫做反向查询。

多对多
老师和班级
通过第三张表关联
Teacher表
id tname
1 Alex
2 Egon
3 yuan
Class表
id cname
1 1班
2 2班
3 3班
TeacherToClass
id teacher_id class_id
1 1 1
2 1 2
3 1 3
4 2 1
5 2 3
6 1 1

4.双下划线：
双下划线表示跨表,将两张表合在一起进行查询。
5.三种创建多对多关系的方法
①通过外键创建创建，自定义第三张表，通过外键关联上面两张表

class Class(models.Model):
    id = models.AutoField(primary_key=True)  # 主键
    cname = models.CharField(max_length=32)  # 班级名称
    first_day = models.DateField()  # 开班时间

class Teacher(models.Model):
    tname = models.CharField(max_length=32)

class Teacher2Class(models.Model):
    teacher = models.ForeignKey(to="Teacher")
    the_class = models.ForeignKey(to="Class")
    class Meta:
        unique_together = ("teacher", "the_class")

②通过ManyToMany创建
自动创建出的第三张表，django就会自动不允许有相同的记录（不用判断id）

class Class(models.Model):
    id = models.AutoField(primary_key=True)  # 主键
    cname = models.CharField(max_length=32)  # 班级名称
    first_day = models.DateField()  # 开班时间

class Teacher(models.Model):
    tname = models.CharField(max_length=32)
    # 通过ManyToManyField自动创建第三张表
    cid = models.ManyToManyField(to="Class", related_name="teachers")

③通过外键和ManyToMany创建
通过ManyToManyField和手动创建第三张表，相对于第二种方法优点是可以在第三张表中添加字段。

class Class(models.Model):
    id = models.AutoField(primary_key=True)  # 主键
    cname = models.CharField(max_length=32)  # 班级名称
    first_day = models.DateField()  # 开班时间

class Teacher(models.Model):
    tname = models.CharField(max_length=32
    cid = models.ManyToManyField(to="Class", through="Teacher2Class", through_fields=("teacher", "the_class"))

class Teacher2Class(models.Model):
    teacher = models.ForeignKey(to="Teacher")
    the_class = models.ForeignKey(to="Class")
    class Meta:
        unique_together = ("teacher", "the_class")

查询规则：
注意：下面的obj代表对象
①单表查询只在一张表里查各种字段
②一对一
正向查：obj.外键.属性
反向查：obj.表名
②一对多（外键）
正向：obj.外键.属性
反向查：obj.表名set.
注意：
如果在外键的字段中加了related_name属性，则按照该属性的值来反向查找
例如： publish = ForeignKey(Blog, related_name='bookList')
obj.表名set.则替换为obj.bookList.
③多对多
正向查：obj.多对多字段名.all() --> QuerySet()
反向查：obj.表名set.all() --> QuerySet()
④双下划线表示跨表查询
正向：关联的字段名另外一张表的字段名
反向：另外一张表的表名_另外一张表的字段名

聚合和分组
from django.db.models import Avg, Max, Min,sum,count
聚合查询就是在一张表中进行查询
①aggregate()是QuerySet 的一个终止子句。不能够再继续往下点了。
②返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。
③可以聚合值指定一个名称。

查询所有书籍中最高的价格

class Book(models.Model):
    price = models.CharField(max_length=32)

ret=Book.objects.all().aggregate(m=Max("price"))
print(ret)
打印结果：
Book.objects.all().aggregate(m=Max("price"))
{'m': '30'}
Ps:例子相当于sql语句 select Max("price") from book

分组查询：
分组的标准：
题目中有关键字“每”，一般要进行分组，关键字为annotate
如果是all()的话，则publish表中的每一条记录是分类标准，也可以filter筛选一些内容作为分类标准。
Publish.objects.all().annotate(c=Count("book__id")).values("c","book__title")
结果：
<QuerySet [{'book__title': 'go', 'c': 1}, {'book__title': 'python', 'c': 1}, {'book__title': 'linux', 'c': 1}, {'book__title': 'java', 'c': 1}, {'book__title': 'php', 'c': 1}]>
原生sql语句：
SELECT "app01_book"."title", COUNT("app01_book"."id") AS "c"
FROM "app01_publish" LEFT OUTER JOIN "app01_book" ON ("app01_publish"."id" = "app01_book"."publish_id")
GROUP BY "app01_publish"."id", "app01_publish"."name", "app01_book"."title" LIMIT 21; args=()

①在这里publish表和book表拼成一张表，以Publish表中的每一条记录为分组标准进行查询

②可以聚合值指定一个名称。此时相当于在拼成的表中添加了一个新的字段，字段的名称就是重新指定的名称**

③分类查出来的结果是QuerySet类型，可以继续点。

④注意：合成的那张表在pycharm里面看不到，在其他地方也没发现能看到。

⑤all()可以省去，简写为Publish.objects.annotate(c=Count("book__id")).values("c","book__title")**

1.每一个出版社出版过得书籍的最高价格*

ret=Publish.objects.all().annotate(m=Max("book__price")).values("name","m")

print(ret)

2.****每一个作者出版过的书籍的个数

ret=Author.objects.all().annotate(c=Count("book")).values("name","c")

找出最大值：
分组和聚合的区别：分组是找出每组的最大值，聚合是指出所有的值当中的最大值。

专题练习：

class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    # 与AuthorDetail建立一对一的关系
    ad = models.OneToOneField(to="AuthorDetail")

class AuthorDetail(models.Model):
    birthday = models.DateField()
    telephone = models.BigIntegerField()
    addr = models.CharField(max_length=64)

class Publish(models.Model):
    name = models.CharField(max_length=32)
    city = models.CharField(max_length=32)
    email = models.EmailField()

class Book(models.Model):
    title = models.CharField(max_length=32)
    publishDate = models.DateField()
    price = models.DecimalField(max_digits=5, decimal_places=2)
    keepNum = models.IntegerField()
    commentNum = models.IntegerField()

与Publish建立一对多的关系,外键字段建立在多的一方

publish = models.ForeignKey(to="Publish", to_field="nid")

与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表

authors = models.ManyToManyField(to='Author')

三个关联字段：

与AuthorDetail建立一对一的关系

ad = models.OneToOneField(to="AuthorDetail")

与Publish建立一对多的关系,外键字段建立在多的一方

publish = models.ForeignKey(to="Publish", to_field="nid")

与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表

authors = models.ManyToManyField(to='Author')

一对多：
正向查询按字段：publis
Book------------------------------->Publish
反向查询按表名小写_set

多对多：
正向查询按字段：authors
Book--------------------------------->Author
反向查询按表名小写_set

一对一
正向查询按字段：ad
Author------------------------->AuthorDetail
反向查询按表名小写

基于对象查询（子查询）

基于Queryset查询（join查询）

单表查询

查询id为1 的书籍的价格

Book.objects.filter(id=1).values("price")

多表查询

一对多

1 .查询python这本书的出版社的城市和email

book_obj=Book.objects.filter(title="python").first()
print(book_obj.publish.email,book_obj.publish.city)

2.查询北京出版社出版社过得所有书籍名称

publish_obj=Publish.objects.filter(name="南京出版社").first()
book_list=publish_obj.book_set.all() # Queryset[obj,obj]
for obj in book_list:
     print(obj.title)

多对多

查询go书籍的作者名称和年龄

book_obj=Book.objects.filter(title="go").first()
author_list=book_obj.authors.all()
for obj in author_list:
     print(obj.name,obj.age)

2.alex出版过得所有书籍的名称和价格

author_obj=Author.objects.filter(name="alex").first()
book_list=author_obj.book_set.all()
for obj in book_list:
     print(obj.title,obj.price)

一对一

1.查询alex的电话号码

author_obj = Author.objects.filter(name="alex").first()
print(author_obj.ad.telephone)

2.查询电话号码以123开头的作者名称

ad_obj=AuthorDetail.objects.filter(telephone__startswith=123).first()
print(ad_obj.author.name)

基于QuerySet和双下划线的多表查询
一对多
1.查询python这本书的出版社的城市和email

ret=Book.objects.filter(title="python").values("publish__city","publish__email")
print(ret)
values("publish__city"):
book_list=Book.objects.filter(title="python")
temp=[]
for obj in book_list:
    d={}
    d["publish__city"]=obj.publish.city
    d["publish__email"]=obj.publish.email
    temp.append(d)
    return temp  # <QuerySet [{'publish__city': '北京', 'publish__email': '123'}]>

2.查询北京出版社出版社过得所有书籍名称

ret=Publish.objects.all().values("book__title")
print(ret)
publish_list=Publish.objects.filter(name="北京出版社")
temp=[]
for obj in publish_list:
    book_list=obj.book_set.all()
        for book in book_list:
            d={}
            d["book__title"]=book.title
            temp.append(d)
return temp

多对多

1.查询go书籍的作者名称和年龄

ret=Book.objects.filter(title="go").values("authors__name","authors__age")
ret=Book.objects.filter(title="go").values_list("authors__name","authors__age")
print(ret)# [('alex', 33), ('egon', 38)]>

2.alex出版过得所有书籍的名称和价格

ret=Author.objects.filter(name="alex").values("book__title","book__price")

一对一

1.查询alex的电话号码

ret=Author.objects.filter(name="alex").values("ad__telephone")

查询电话号码以123开头的作者名称

ret=AuthorDetail.objects.filter(telephone__startswith=123).values("author__name")

print(ret)

扩展查询

1.查询python这本书的出版社的城市和email

ret=Book.objects.filter(title="python").values("publish__city")

ret=Publish.objects.filter(book__title="python").values("email","city")

2.查询go书籍的作者名称和年龄

ret=Book.objects.filter(title="go").values("authors__name", "authors__age")----基表是book
Author.objects.filter(book__title="go").values("name","age")------------------------基表是author

ORM 跨表查询

class Book(models.Model):
title = models.CharField( max_length=32)

publish=models.ForeignKey(to="Publish",to_field="id")
authors=models.ManyToManyField(to='Author',related_name='bookList')
class Publish(models.Model):

name=models.CharField( max_length=32)

class Author(models.Model):

    name=models.CharField( max_length=32)

    ad=models.OneToOneField("AuthorDetail")

class AuthorDetail(models.Model):

telephone=models.BigIntegerField()
基于对象查询（sql：子查询）

一对多的关系****(Publish--Book)

正向查询,按字段：

查询python这本书的出版社所在的名称

book_obj=Book.objects.filter(title="python").first()

print(book_obj.publish.name)

反向查询，按表名小写_set：

人民出版社出版过的所有书籍名称

publish_obj=Publish.objects.filter(name="人民出版社出版").first()

print(publish_obj.book_set.all())

for obj in publish_obj.book_set.all():

print(obj.title)

多对多的关系

正向查询,按字段：

python这本书所有作者的名字

book_obj=Book.objects.filter(title="python").first()

book_obj.authors.all()

反向查询，按表名小写_set：

alex出版过的所有书籍名称

alex=Author.objects.filter(name="alex").first()

alex.bookList.all()

一对一的关系

正向查询,按字段：

查询alex的手机号

alex=Author.objects.filter(name="alex").first()

alex.ad.telephone

反向查询：按表名小写

以151开头的手机号的作者的名字

ad=AuthorDetail.objects.get(telephone__startswith="151")

ad.author.name

基于****Queryset****和 __****（****sql****：****join****语句）****:

正向查询,按字段

反向查询，按表名小写

一对多的关系(Publish--Book)

查询python这本书的所在出版社的名称

Book.objects.filter(title="python").values("publish__name")

for obj in Book.objects.filter(title="python"):

temp={}

temp["publish__name"]=obj.publish.name

人民出版社出版过的所有书籍名称

Publish.objects.filter(name="人民出版社出版").values("book__title")

多对多的关系

python这本书所有作者的名字

Book.objects.filter(title="python").values("authors__name")

alex出版过的所有书籍名称

Author.objects.filter(name="alex").values("book__title")

一对一的关系

查询alex的手机号

Author.objects.filter(name="alex").values("ad__telephone")

以151开头的手机号的作者的名字

AuthorDetail.objects.filter(telephone__startswith="151").values("author__name")

扩展：

练习1：

查询python这本书的所在出版社的名称

Book.objects.filter(title="python").values("publish__name")

Publish.objects.filter(book__title="python").values("name")

练习2：

手机号以151开头的作者出版过的所有书籍名称以及出版社名称

Book.objects.filter(authors__ad__telephone__startswith="151").values("title","publish__name")

一对多的添加

class Publish(models.Model):

nid = models.AutoField(primary_key=True)

name = models.CharField(max_length=32)

city = models.CharField(max_length=32)

email = models.EmailField()

class Book(models.Model):

nid = models.AutoField(primary_key=True)

title = models.CharField(max_length=32)

publishDate = models.DateField()

price = models.DecimalField(max_digits=5, decimal_places=2)

publish = models.ForeignKey(to="Publish", to_field="nid")

注意：此时在另外一张表中数据不存在，也可以创建外键，手动在表格中添加也可以。

Book.objects.create(title="****金瓶眉****",publishDate="2012-12-12",price=665,publish_id=1)

publish_obj = Publish.objects.get(nid=1)

Book.objects.create(title="金瓶眉", publishDate="2012-12-12", price=665,publish=publish_obj)

多对多关系的增删改

class Author(models.Model):

name =models.CharField(max_length=12)

class Book(models.Model):

title =models.CharField(max_length=100)

authors = models.ManyToManyField("Author")

Author表

book 表

id title

1 python

book_authors

id book_id author_id

book_obj=Book.objects.create(title="python")

Alex=Author.objects.get(name="alex")

Egon=Author.objects.get(name="egon")

Wu=Author.objects.get(name="wu")

author_list=Author.objects.all()

注意：

(1)
Objects未封装add()，set()，remove()，clear()方法，使用着几个方法的时候不要用objects，否则会报错。
(2)如果在这些方法中传入多个数据，必须使用号进行打散。
(3)语法格式：对象.属性.方法
Add()方法
传入的参数对象，传入其他类型的参数，会报错
传入数据不是对象，必须使用打散使之变成对象，若只有一个数据直接传入即可,不必使用。
结果在第三张表（关联表）中创建数据
(4)代码步骤
首先确定是正查还是反查
获取对象
获取数据，将这些数据放到参数的位置
拼写代码进行操作
Create()方法
b=Book.objects.create(title="c++")------》》在book表中创建一条数据
e=b.authors.create(name="alex")-------》》通过字段在author表中创建一条数据
这两条记录的关系在第三张表中自动创建
Add()方法
book_obj.authors.add([alex,wu,egon])
book_obj.authors.add(author_list)
Remove()方法，
传入的参数是对象，传入的参数不是对象会报错。
传入多个数据必须置于列表当中，且必须打散，若只有一个数据直接传入即可,不必置于列表中。
结果在第三张表（关联表）中删除关联表中相应的记录，不影响其他表中的数据。
book_obj.authors.remove([alex,wu])
book_obj.authors.remove(egon)
Clear()方法
不必传入参数
把关联表中的记录全部删除，不影响其他的表
book_obj.authors.clear()
注意：支持反向查询的语法即：表名_set
b2=Author.objects.create(name="egon")------在author表中的创建一条记录
C2=b2.book_set.create(title="python")--------在Book表中创建一条记录

这两条记录的关系在第三张表中自动创建
d=Author(name="wu")
d.save(force_insert=True)------------不会在第三张表中自动创建
author_obj=Author.objects.filter(id=3).first()
book_list=Book.objects.all()
author_obj.book_set.add(*book_list)
（这里假设第三张表是空的）
author_obj=Author.objects.filter(id=3).first()
book_list=Book.objects.filter(id=3).first()
author_obj.book_set.remove(book_list)
Clear()方法
author_obj.book_set.clear()