Django框架(八) Django之ORM数据库操作
创建模型
实例:我们来假定下面这些概念,字段和关系
作者模型:一个作者有姓名和年龄。
作者详细模型:把作者的详情放到详情表,包含生日,手机号,家庭住址等信息。作者详情模型和作者模型之间是一对一的关系(one-to-one)
出版商模型:出版商有名称,所在城市以及email。
书籍模型: 书籍有书名和出版日期,一本书可能会有多个作者,一个作者也可以写多本书,所以作者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版,所以出版商和书籍是一对多关联关系(one-to-many)。
Book id title price publish 1 php 100 人民出版社 2 python 200 老男孩出版社 3 go 100 人民出版社 4 java 300 人民出版社 为了存储出版社的邮箱,地址,在第一个表后面加字段 Book id title price publish email addr 1 php 100 人民出版社 111 北京 2 python 200 老男孩出版社 222 上海 3 go 100 人民出版社 111 北京 4 java 300 人民出版社 111 北京 这样会有大量重复的数据,浪费空间 ####################################################################################
一对多:一个出版社对应多本书(关联信息建在多的一方,也就是book表中) Book id title price publish_id 1 php 100 1 2 python 200 1 3 go 100 2 4 java 300 1 Publish id name email addr 1 人民出版社 111 北京 2 沙河出版社 222 沙河 总结:一旦确定表关系是一对多:在多对应的表中创建关联字段(在多的表里创建关联字段) ,publish_id 查询python这本书的出版社的邮箱(子查询) select publish_id from Book where title=“python” select email from Publish where id=1 #################################################################################### 多对多:一本书有多个作者,一个作者出多本书 Book id title price publish_id 1 php 100 1 2 python 200 1 3 go 100 2 4 java 300 1 Author id name age addr 1 alex 34 beijing 2 egon 55 nanjing Book2Author id book_id author_id 1 2 1 2 2 2 3 3 2 总结:一旦确定表关系是多对多:创建第三张关系表(创建中间表,中间表就三个字段,自己的id,书籍id和作者id) : id book_id author_id # alex出版过的书籍名称(子查询) select id from Author where name='alex' select book_id from Book2Author where author_id=1 select title from Book where id =book_id #################################################################################### 一对一:对作者详细信息的扩展(作者表和作者详情表) Author id name age ad_id(UNIQUE) 1 alex 34 1 2 egon 55 2 AuthorDetail id addr gender tel gf_name author_id(UNIQUE) 1 beijing male 110 小花 1 2 nanjing male 911 杠娘 2 总结: 一旦确定是一对一的关系:在两张表中的任意一张表中建立关联字段+Unique
注意:关联字段与外键约束没有必然的联系(建管理字段是为了进行查询,建约束是为了不出现脏数据)
在Models创建如下模型
class Book(models.Model): nid = models.AutoField(primary_key=True) name = models.CharField(max_length=32) price = models.DecimalField(max_digits=5, decimal_places=2) publish_date = models.DateField() # 阅读数 # reat_num=models.IntegerField(default=0) # 评论数 # commit_num=models.IntegerField(default=0) publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE) authors=models.ManyToManyField(to='Author') def __str__(self): return self.name class Author(models.Model): nid = models.AutoField(primary_key=True) name = models.CharField(max_length=32) age = models.IntegerField() author_detail = models.OneToOneField(to='AuthorDatail',to_field='nid',unique=True,on_delete=models.CASCADE) class AuthorDatail(models.Model): nid = models.AutoField(primary_key=True) telephone = models.BigIntegerField() birthday = models.DateField() addr = models.CharField(max_length=64) 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()
生成的表如下:
注意事项:
- 表的名称
myapp_modelName
,是根据 模型中的元数据自动生成的,也可以覆写为别的名称 id
字段是自动添加的- 对于外键字段,Django 会在字段名上添加"_id" 来创建数据库中的列名
- 这个例子中的
CREATE TABLE
SQL 语句使用PostgreSQL 语法格式,要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句 - 定义好模型之后,你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置,在其中添加
models.py
所在应用的名称 - 外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL),你可以赋给它空值 None
新增或者删除字段
新增字段
第一步,在你要添加新字段的app的 models.py 文件中添加需要新增的字段
第二步,在终端命令行中python manage.py makemigrations AppTest(个人App文件名)
第三步,选择输入:1(这里要求你设置新建字段的默认值,它会在新建这个字段的同时把默认值也添加上去,)
第四步,如果不想让它有值,我们直接输''(中间没有空格),一样能达到效果,但是不能不设置默认值,(如果是数值类型呢,默认值为 ''不行,如果是年龄,需设置blank=True和null=True)
(blank:设置为True时,字段可以为空。设置为False时,字段是必须填写的。字符型字段CharField和TextField是用空字符串来存储空值的。如果为True,字段允许为空,默认不允许. null:设置为True时,django用Null来存储空值。日期型、时间型和数字型字段不接受空字符串。所以设置IntegerField,DateTimeField型字段可以为空时,需要将blank,null均设为True。如果为True,空值将会被存储为NULL,默认为False。如果想设置BooleanField为空时可以选NullBooleanField型字段。)
第五步,最后输入:python manage.py migrate
删除字段
只需要将想要删除的字段注释掉,再执行一遍两条命令
添加表记录
一对多的
方式1: publish_obj=Publish.objects.get(nid=1) book_obj=Book.objects.create(title="",publishDate="2012-12-12",price=100,publish=publish_obj) 方式2: book_obj=Book.objects.create(title="",publishDate="2012-12-12",price=100,publish_id=1)
核心:book_obj.publish与book_obj.publish_id是什么?
关键点: 一 book_obj.publish=Publish.objects.filter(id=book_obj.publish_id).first() 二 book_obj.authors.all() 关键点:book.authors.all() # 与这本书关联的作者集合 1 book.id=3 2 book_authors id book_id author_ID 3 3 1 4 3 2 3 author id name 1 alex 2 egon book_obj.authors.all() -------> [alex,egon]
# -----一对多添加 pub=Publish.objects.create(name='egon出版社',email='445676@qq.com',city='山东') print(pub) # 为book表绑定和publish的关系 import datetime,time now=datetime.datetime.now().__str__() now = datetime.datetime.now().strftime('%Y-%m-%d') print(type(now)) print(now) # 日期类型必须是日期对象或者字符串形式的2018-09-12(2018-9-12),其它形式不行 Book.objects.create(name='海燕3',price=333.123,publish_date=now,publish_id=2) Book.objects.create(name='海3燕3',price=35.123,publish_date='2018/02/28',publish=pub) pub=Publish.objects.filter(nid=1).first() book=Book.objects.create(name='测试书籍',price=33,publish_date='2018-7-28',publish=pub) print(book.publish.name) # 查询出版了红楼梦这本书出版社的邮箱 book=Book.objects.filter(name='红楼梦').first() print(book.publish.email)
多对多
# 当前生成的书籍对象 book_obj=Book.objects.create(title="追风筝的人",price=200,publishDate="2012-11-12",publish_id=1) # 为书籍绑定的做作者对象 yuan=Author.objects.filter(name="yuan").first() # 在Author表中主键为2的纪录 egon=Author.objects.filter(name="alex").first() # 在Author表中主键为1的纪录 # 绑定多对多关系,即向关系表book_authors中添加纪录 book_obj.authors.add(yuan,egon) # 将某些特定的 model 对象添加到被关联对象集合中。 ======= book_obj.authors.add(*[])
book = Book.objects.filter(name='红楼梦').first() egon=Author.objects.filter(name='egon').first() lqz=Author.objects.filter(name='lqz').first() # 1 没有返回值,直接传对象 book.authors.add(lqz,egon) # 2 直接传作者id book.authors.add(1,3) # 3 直接传列表,会打散 book.authors.add(*[1,2]) # 解除多对多关系 book = Book.objects.filter(name='红楼梦').first() # 1 传作者id book.authors.remove(1) # 2 传作者对象 egon = Author.objects.filter(name='egon').first() book.authors.remove(egon) #3 传*列表 book.authors.remove(*[1,2]) #4 删除所有 book.authors.clear() # 5 拿到与 这本书关联的所有作者,结果是queryset对象,作者列表 ret=book.authors.all() # print(ret) # 6 queryset对象,又可以继续点(查询红楼梦这本书所有作者的名字) ret=book.authors.all().values('name') print(ret) # 以上总结: # (1) # book=Book.objects.filter(name='红楼梦').first() # print(book) # 在点publish的时候,其实就是拿着publish_id又去app01_publish这个表里查数据了 # print(book.publish) # (2)book.authors.all()
多对多注意点
1.注意ManyToManyField()的设置位置;该实例中设置了Article模型中,在绑定两张表的时候,利用Article的对象a1进行绑定的,a1.publication.add()。但是不能使用Publication的对象p1进行绑定(p1.article.add())。
2.两张表之间的相互查询关系
查询a1这篇文章所属的出版社有哪些
print a1.publication.all()
查询某一出版社,所包含的所有文章有哪些
print p1.article_set.all()
多对多关系其它常用API:
book_obj.authors.remove() # 将某个特定的对象从被关联对象集合中去除。 ====== book_obj.authors.remove(*[]) book_obj.authors.clear() #清空被关联对象集合 book_obj.authors.set() #先清空再设置
基于对象的跨表查询
一对多查询(publish与book)
正向查询(按字段:publish)
# 查询主键为1的书籍的出版社所在的城市 book_obj=Book.objects.filter(pk=1).first() # book_obj.publish 是主键为1的书籍对象关联的出版社对象 print(book_obj.publish.city)
反向查询(按表名:book_set)
publish=Publish.objects.get(name="苹果出版社") #publish.book_set.all() : 与苹果出版社关联的所有书籍对象集合 book_list=publish.book_set.all() for book_obj in book_list: print(book_obj.title)
# 一对多正向查询 book=Book.objects.filter(name='红楼梦').first() print(book.publish)#与这本书关联的出版社对象 print(book.publish.name) # 一对多反向查询 # 人民出版社出版过的书籍名称 pub=Publish.objects.filter(name='人民出版社').first() ret=pub.book_set.all() print(ret)
一对一查询(Author 与 AuthorDetail)
正向查询(按字段:authorDetail):
egon=Author.objects.filter(name="egon").first() print(egon.authorDetail.telephone)
反向查询(按表名:author):
# 查询所有住址在北京的作者的姓名 authorDetail_list=AuthorDetail.objects.filter(addr="beijing") for obj in authorDetail_list: print(obj.author.name)
# 一对一正向查询 # lqz的手机号 lqz=Author.objects.filter(name='lqz').first() tel=lqz.author_detail.telephone print(tel) # 一对一反向查询 # 地址在北京的作者姓名 author_detail=AuthorDatail.objects.filter(addr='北京').first() name=author_detail.author.name print(name)
多对多查询 (Author 与 Book)
正向查询(按字段:authors):
# 眉所有作者的名字以及手机号 book_obj=Book.objects.filter(title="眉").first() authors=book_obj.authors.all() for author_obj in authors: print(author_obj.name,author_obj.authorDetail.telephone)
反向查询(按表名:book_set):
# 查询egon出过的所有书籍的名字 author_obj=Author.objects.get(name="egon") book_list=author_obj.book_set.all() #与egon作者相关的所有书籍 for book_obj in book_list: print(book_obj.title)
# 正向查询----查询红楼梦所有作者名称 book=Book.objects.filter(name='红楼梦').first() ret=book.authors.all() print(ret) for auth in ret: print(auth.name) # 反向查询 查询lqz这个作者写的所有书 author=Author.objects.filter(name='lqz').first() ret=author.book_set.all() print(ret)
注意:
你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如,如果 Article model 中做一下更改:
publish = ForeignKey(Book, related_name='bookList')
那么接下来就会如我们看到这般:
# 查询 人民出版社出版过的所有书籍 publish=Publish.objects.get(name="人民出版社") book_list=publish.bookList.all() # 与人民出版社关联的所有书籍对象集合
基于双下划线的跨表查询
Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系,它能自动确认 SQL JOIN 联系。要做跨关系查询,就使用两个下划线来链接模型(model)间关联字段的名称,直到最终链接到你想要的model 为止。
''' 正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表 '''
一对多查询
# 练习: 查询苹果出版社出版过的所有书籍的名字与价格(一对多) # 正向查询 按字段:publish queryResult=Book.objects .filter(publish__name="苹果出版社") .values_list("title","price") # 反向查询 按表名:book queryResult=Publish.objects .filter(name="苹果出版社") .values_list("book__title","book__price") 查询的本质一样,就是select from的表不一样
# 正向查询按字段,反向查询按表名小写 # 查询红楼梦这本书出版社的名字 # select * from app01_book inner join app01_publish # on app01_book.publish_id=app01_publish.nid ret=Book.objects.filter(name='红楼梦').values('publish__name') print(ret) ret=Publish.objects.filter(book__name='红楼梦').values('name') print(ret)
多对多查询
# 练习: 查询alex出过的所有书籍的名字(多对多) # 正向查询 按字段:authors: queryResult=Book.objects .filter(authors__name="yuan") .values_list("title") # 反向查询 按表名:book queryResult=Author.objects .filter(name="yuan") .values_list("book__title","book__price")
# 正向查询按字段,反向查询按表名小写 # 查询红楼梦这本书出版社的名字 # select * from app01_book inner join app01_publish # on app01_book.publish_id=app01_publish.nid ret=Book.objects.filter(name='红楼梦').values('publish__name') print(ret) ret=Publish.objects.filter(book__name='红楼梦').values('name') print(ret) # sql 语句就是from的表不一样 # -------多对多正向查询 # 查询红楼梦所有的作者 ret=Book.objects.filter(name='红楼梦').values('authors__name') print(ret) # ---多对多反向查询 ret=Author.objects.filter(book__name='红楼梦').values('name') ret=Author.objects.filter(book__name='红楼梦').values('name','author_detail__addr') print(ret)
一对一查询
# 查询alex的手机号 # 正向查询 ret=Author.objects.filter(name="alex").values("authordetail__telephone") # 反向查询 ret=AuthorDetail.objects.filter(author__name="alex").values("telephone")
# 查询lqz的手机号 # 正向查 ret=Author.objects.filter(name='lqz').values('author_detail__telephone') print(ret) # 反向查 ret= AuthorDatail.objects.filter(author__name='lqz').values('telephone') print(ret)
进阶练习(连续跨表)
# 练习: 查询人民出版社出版过的所有书籍的名字以及作者的姓名 # 正向查询 queryResult=Book.objects .filter(publish__name="人民出版社") .values_list("title","authors__name") # 反向查询 queryResult=Publish.objects .filter(name="人民出版社") .values_list("book__title","book__authors__age","book__authors__name") # 练习: 手机号以151开头的作者出版过的所有书籍名称以及出版社名称 # 方式1: queryResult=Book.objects .filter(authors__authorDetail__telephone__regex="151") .values_list("title","publish__name") # 方式2: ret=Author.objects .filter(authordetail__telephone__startswith="151") .values("book__title","book__publish__name")
# ----进阶练习,连续跨表 # 查询手机号以33开头的作者出版过的书籍名称以及书籍出版社名称 # author_datail author book publish # 基于authorDatail表 ret=AuthorDatail.objects.filter(telephone__startswith='33').values('author__book__name','author__book__publish__name') print(ret) # 基于Author表 ret=Author.objects.filter(author_detail__telephone__startswith=33).values('book__name','book__publish__name') print(ret) # 基于Book表 ret=Book.objects.filter(authors__author_detail__telephone__startswith='33').values('name','publish__name') print(ret) # 基于Publish表 ret=Publish.objects.filter(book__authors__author_detail__telephone__startswith='33').values('book__name','name') print(ret)
related_name
publish = ForeignKey(Blog, related_name='bookList')
# 练习: 查询人民出版社出版过的所有书籍的名字与价格(一对多) # 反向查询 不再按表名:book,而是related_name:bookList queryResult=Publish.objects .filter(name="人民出版社") .values_list("bookList__title","bookList__price")
反向查询时,如果定义了related_name ,则用related_name替换表名,例如:
聚合查询与分组查询
value在annotate前面时,相当于group by
,即models.表名.objects.values('group by 字段').annotate(统计字段)
value放在annotate后面时,相当于select
annotate前面没有value时,默认按当前表的主键分组
这里需要注意的是,values中的字段信息需要使用单引号进行包裹
如果只有一个符合条件的值,就是一个列表里面有一个字典.如果多个符合条件的值则是多个字典放在列表中
聚合
aggregate(*args, **kwargs)
# 计算所有图书的平均价格 from django.db.models import Avg Book.objects.all().aggregate(Avg('price')) #{'price__avg': 34.35}
aggregate()是QuerySet 的一个终止子句,意思是说,它返回一个包含一些键值对的字典。键的名称是聚合值的标识符,值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定一个名称,可以向聚合子句提供它。
Book.objects.aggregate(average_price=Avg('price')) #{'average_price': 34.35}
如果你希望生成不止一个聚合,你可以向aggregate()子句中添加另一个参数。所以,如果你也想知道所有图书价格的最大值和最小值,可以这样查询:
from django.db.models import Avg, Max, Min Book.objects.aggregate(Avg('price'), Max('price'), Min('price')) #{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}
# 查询所有书籍的平均价格 from django.db.models import Avg,Count,Max,Min ret=Book.objects.all().aggregate(Avg('price')) # {'price__avg': 202.896} # 可以改名字 ret=Book.objects.all().aggregate(avg_price=Avg('price')) # 统计平均价格和最大价格 ret=Book.objects.all().aggregate(avg_price=Avg('price'),max_price=Max('price')) # 统计最小价格 ret = Book.objects.all().aggregate(avg_price=Avg('price'), min_price=Min('price')) # 统计个数和平均价格 ret = Book.objects.all().aggregate(avg_price=Avg('price'), max_price=Max('price'),count=Count('price')) ret = Book.objects.all().aggregate(avg_price=Avg('price'), max_price=Max('price'),count=Count('nid')) print(ret)
分组
annotate()为调用的QuerySet中每一个对象都生成一个独立的统计值(统计方法用聚合函数)。
总结 :跨表分组查询本质就是将关联表join成一张表,再按单表的思路进行分组查询。
查询练习
练习:统计每一本书作者个数
from django.db.models import Avg, Max, Sum, Min, Max, Count book_list = models.Book.objects.all().annotate(author_num=Count("authors")) for book in book_list: print(book.name) print(book.author_num) book_list = models.Book.objects.all().annotate(author_num=Count("authors")).values('name','author_num') print(book_list)
练习:统计每一个出版社的最便宜的书
publishList=Publish.objects.annotate(MinPrice=Min("book__price")) for publish_obj in publishList: print(publish_obj.name,publish_obj.MinPrice)
annotate的返回值是querySet,如果不想遍历对象,可以用上valuelist:
queryResult= Publish.objects.annotate(MinPrice=Min("book__price")).values_list("name","MinPrice") print(queryResult)
练习:统计每一本以py开头的书籍的作者个数:
queryResult=Book.objects.filter(title__startswith="Py").annotate(num_authors=Count('authors'))
练习:统计不止一个作者的图书:(作者数量大于一)
ret=models.Book.objects.annotate(author_num=Count("authors")).filter(author_num__gt=1).values('name','author_num')
print(ret)
练习:根据一本图书作者数量的多少对查询集 QuerySet进行排序:
Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors')
练习:查询各个作者出的书的总价格:
ret=models.Author.objects.annotate(sum_price=Sum("book__price")).values("name", "sum_price") print(ret)
练习:查询每个出版社的名称和书籍个数
ret=models.Publish.objects.all().annotate(c=Count('book__name')).values('name','c') print(ret)
# ————————————单表下的分组查询 ''' 查询每一个部门名称以及对应的员工数 emp: id name age salary dep 1 alex 12 2000 销售部 2 egon 22 3000 人事部 3 wen 22 5000 人事部 ''' # select count(id) from emp group by dep # 示例一:查询每一个部门的名称,以及平均薪水 # select dep,Avg(salary) from app01_emp group by dep from django.db.models import Avg, Count, Max, Min ret=Emp.objects.values('dep').annotate(Avg('salary')) # 重新命名 ret=Emp.objects.values('dep').annotate(avg_salary=Avg('salary')) print(ret) # ---*******单表分组查询ORM总结:表名.objects.values('group by 的字段').annotate(聚合函数('统计的字段')) # 示例2 查询每个省份对应的员工数 ret=Emp.objects.values('province').annotate(Count('id')) ret=Emp.objects.values('province').annotate(c=Count('id')) print(ret) # 补充知识点: ret=Emp.objects.all() # select * from emp ret=Emp.objects.values('name') # select name from emp # ****单表下,按照id进行分组是没有任何意义的 ret=Emp.objects.all().annotate(Avg('salary')) print(ret) # ******多表分组查询 # 查询每一个出版社出版的书籍个数 ret=Book.objects.values('publish_id').annotate(Count('nid')) print(ret) # 查询每个出版社的名称以及出版社书的个数(先join在跨表分组) # 正向 ret=Publish.objects.values('name').annotate(Count('book__name')) ret=Publish.objects.values('nid').annotate(c=Count('book__name')).values('name','c') print(ret) # 反向 ret=Book.objects.values('publish__name').annotate(Count('name')) ret=Book.objects.values('publish__name').annotate(c=Count('name')).values('publish__name','c') print(ret) # 查询每个作者的名字,以及出版过书籍的最高价格 ret=Author.objects.values('pk').annotate(c=Max('book__price')).values('name','c') print(ret) # 跨表查询的模型:每一个后表模型.objects.value('pk').annotate(聚合函数('关联表__统计字段')).values() # 查询每一个书籍的名称,以及对应的作者个数 ret=Book.objects.values('pk').annotate(c=Count('authors__name')).values('name','c') print(ret) # 统计不止一个作者的图书 ret=Book.objects.values('pk').annotate(c=Count('authors__name')).filter(c__gt=1).values('name','c') print(ret)
F查询与Q查询
F查询
在上面所有的例子中,我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较,那该怎么做呢?
Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段,来比较同一个 model 实例中两个不同字段的值。
# 查询评论数大于收藏数的书籍 from django.db.models import F Book.objects.filter(commnetNum__lt=F('keepNum'))
Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
# 查询评论数大于收藏数2倍的书籍 Book.objects.filter(commnetNum__lt=F('keepNum')*2)
修改操作也可以使用F函数,比如将每一本书的价格提高30元:
Book.objects.all().update(price=F("price")+30)
Q查询
filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询(例如OR 语句),你可以使用Q 对象。
from django.db.models import Q Q(title__startswith='Py')
Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时,它产生一个新的Q 对象。
bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon"))
等同于下面的SQL WHERE 子句:
WHERE name ="yuan" OR name ="egon"
你可以组合& 和| 操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时,Q 对象可以使用~ 操作符取反,这允许组合正常的查询和取反(NOT) 查询:
查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数(关键字参数或Q 对象)都将"AND”在一起。但是,如果出现Q 对象,它必须位于所有关键字参数的前面。例如:
bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017), title__icontains="python")
# 查询评论数大于阅读数的书籍 from django.db.models import F,Q # select * from book where commit_num>read_num; # 这样肯定是不行的 # Book.objects.filter(commit_num__gt=read_num) ret=Book.objects.filter(commit_num__gt=F('reat_num')) print(ret) # 把所有书籍的价格加10 Book.objects.all().update(price=F('price')+10) # ----Q函数,描述一个与,或,非的关系 # 查询名字叫红楼梦或者价格大于100的书 ret=Book.objects.filter(Q(name='红楼梦')|Q(price__gt=100)) print(ret) # 查询名字叫红楼梦和价格大于100的书 ret = Book.objects.filter(Q(name='红楼梦') & Q(price__gt=100)) print(ret) # # 等同于 ret2=Book.objects.filter(name='红楼梦',price__gt=100) print(ret2) # 也可以Q套Q # 查询名字叫红楼梦和价格大于100 或者 nid大于2 ret=Book.objects.filter((Q(name='红楼梦') & Q(price__gt=100))|Q(nid__gt=2)) print(ret) # ----非 ret=Book.objects.filter(~Q(name='红楼梦')) print(ret) # Q和键值对联合使用,但是键值对必须放在Q的后面(描述的是一个且的关系) # 查询名字不是红楼梦,并且价格大于100的书 ret=Book.objects.filter(~Q(name='红楼梦'),price__gt=100) print(ret)