day55(* 神奇的双下划线查询 * orm创建外键关系)
今日内容概要
- 神奇的双下划线查询
- orm创建外键关系
- 外键字段的增删改查
- 正反向的概念
- 多表查询
- 聚合与分组查询
- F查询与Q查询
昨日内容回顾、
模板语法之过滤器：他类似于内置函数
1.语法结构
{{ 数据对象|过滤器名称:参数 }} 过滤器最多只能额外传输一个参数
2.常见过滤器(django模板语法提供了60+过滤器 我们了解几个即可)
首先看：
urls路由层代码：
urlpatterns = [
url(r'^admin/', admin.site.urls),
url('^index/',views.index)
]
vewis视图层代码：
def index(request):
w1='hello zqh 周一又犯困了？'
w2='床前明月 光疑是地上霜'
w3=''#（空字符串）
w4 = 666
w5 = '床前 明月 光疑 是地 上霜 举头 望明 月低 头思 故乡'
file_size = 8254
big_file=999999999
m=False
from datetime import datetime
time1 = datetime.today()
info='zqh$666$green$'
title = '<h1>标签标明吉博辕很大</h1>'
scripts1 = '<scripts>吉博辕很大</scripts>'
return render(request,'index1.html',locals())
html代码:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<p>{{ w1|length }}</p>
<p>{{ w2|length }}</p>
<p>{{ w3|length }}</p>
<p>{{ w4|add:222 }}</p>
<p>{{ w3|add:'举头望明月' }}</p>
<p>{{ w1|add:'明日复明日明日何其多' }}</p>
<p>{{ file_size|filesizeformat }}</p>
<p>{{ big_file|filesizeformat }}</p>
<p>{{ w1|default:'w1前面的值对应的布尔值是False' }}</p>
<p>{{ m|default:'m前面的值对应的布尔值是False' }}</p>
<p>{{ time1 }}</p>
<p>{{ time1|date:'Y-m-d' }}</p>
<p>{{ time1|date:'Y-m-d H:i:s' }}</p>
<p>{{w2|slice:'0:5'}}</p>
<p>{{w5|truncatewords:5}}</p>
<p>{{w5|truncatechars:5}}</p>
<p>{{info|cut:'$'}}</p>
<p>{{ title }}</p>
<p>{{ scripts1 }}</p>
<p>{{ title|safe }}</p>
<p>{{ scripts1|safe }}</p>
</body>
</html>
1<p>统计数据的长度:{{ s1|length }}</p>.#运行结果之后页面分别返回17和十还有零由此可见这个方法返回的是数据长度，没有的话返回零
2 <p>算术加法或者字符串加法:{{ w4|add:222 }}、{{ w3|add:'举头望明月' }}</p>
#结果分别是888和举头望明月因为w3是一个空字符串，有返回结果可知 此方法可知内部首先进行对如果都是数字直接进行加法运算出他们的和，如果都是字符串直接拼接在一起，也可以说是尾部追加从w1返回结果可知'hello zqh 周一又犯困了？明日复明日明日何其多'
3.将数字转成合适的文件计量单位:{{ file_size|filesizeformat }}，{{ big_file|filesizeformat }}#由返回结果可知此方法用来给你计算出最为适合的文件大小，返回结果分别为：
'8.1 KB 和953.7 MB'
4.此方法稍微有点鸡肋，#可以从返回结果看出就是用来判断对应的值是否为False：
1.：<p>{{ w1|default:'w1前面的值对应的布尔值是False' }}</p>
1.:<p>{{ m|default:'m前面的值对应的布尔值是False' }}</p>
结果1：hello zqh 周一又犯困了？
结果2：m前面的值对应的布尔值是False
5：<p>{{ time1|date:'Y-m-d' }}</p>我们一般常用的就是这个方法格式胡时间
<p>{{ time1 }}</p> 结果返回May 16, 2022, 5:51 p.m.
<p>{{ time1|date:'Y-m-d' }}</p> 结果返回2022-05-16
<p>{{ time1|date:'Y-m-d H:i:s' }}</p> 结果返回2022-05-16 17:51:23
6：<p>{{w2|slice:'0:5'}}</p>
就是简单的索引切片操作也比较好理解跟我们所学的索引是一样的结果并拿到了一句话'床前明月光'
7.按照空格截取指定个数的文本:{{ w5|truncatewords:5 }}（words是单词的意思）
床前 明月 光疑 是地 上霜 ...
8.<p>{{w5|truncatechars:5}}</p>
看着很像这两个方法这个方法的意思是按照字符个数截取文本(包含三个点):（chars是字符）
结果为：床前...
9；移除指定的字符：{{ info|cut:'$' }}移除指定字符
结果为：'zqh666green'
10. <p>是否取消转换:{{ title }}、{{ title|safe }}、{{ scripts1|safe }}、{{ res }}</p>，可以说是确定安全之后执行
最后一个|safe启发了我们以后用django开发全栈项目前端页面代码(主要指HTML代码)也可以在后端编写
all() # 查询所有数据 queryset
filter() # 根据条件筛选数据 多个条件默认是and关系 queryset
first() # 获取结果集中的第一个元素 数据对象
last() # 获取结果集中的最后一个元素 数据对象
values() # 可以看成是列表套字典 queryset
values_list() # 可以看成是列表套元组 queryset
exclude() # 取反操作 queryset
exists() # 判断结果集是否有值 布尔值
distinct() # 去重 queryset
order_by() # 排序 queryset
get() # 直接获取数据对象 数据对象
count() # 计数 int
create() # 创建数据
update() # 批量修改数据
delete() # 批量删除数据
"""
参数pk的含义:自动定位到当前表的主键字段
参数-的含义:用于排序中的升序与降序
今日内容详细
神奇的双下划线查询
别问怎么神奇，问就是比神奇宝贝回家神奇宝贝他妈给神奇宝贝开门还神奇
#models.py代码
from django.db import models
class User(models.Model):
uid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32, verbose_name='姓名')
pwd = models.IntegerField(verbose_name='密码')
age = models.IntegerField()
op_time = models.DateField(auto_now=True)
def __str__(self):
return '对象：%s' % self.name
"""auto_now:每次修改数据的时候都会自动修改时间
auto_now_add:数据被创建出来的时候会自动记录当前时间，之后如果没有人为干涉保持不变"""
外键字段的创建
"""
MySQL复习
关系的种类
一对多关系
多对多关系
一对一关系
关系的判断
换位思考
字段的位置
一对多关系 外键字段建在多的一方
多对多关系 外键字段建在第三张关系表中
一对一关系 外键字段建在任意一方都可以 但是推荐建在查询频率较高的表中
"""
django orm创建表关系
图书表
出版社表
作者表
作者详情表
关系判断
书与出版社
一本书不能对应多个出版社
一个出版社可以对应多本书
# 一对多关系 书是多 出版社是一 ForeignKey
'''django orm外键字段针对一对多关系也是建在多的一方 '''
书与作者
一本书可以对应多个作者
一个作者可以对应多本书
# 多对多关系 ManyToManyField
'''django orm外键字段针对多对多关系 可以不用自己创建第三张表'''
作者与作者详情
一个作者不能对应多个作者详情
一个作者详情不能对个多个作者
# 一对一关系 OneToOneField
'''django orm外键字段针对一对一关系 建在查询频率较高的表中'''
ManyToManyField不会在表中创建实际的字段 而是告诉django orm自动创建第三张关系表
ForeignKey、OneToOneField会在字段的后面自动添加_id后缀 如果你在定义模型类的时候自己添加了该后缀那么迁移的时候还会再次添加_id_id 所以不要自己加_id后缀
ps:三个关键字里面的参数
to用于指定跟哪张表有关系 自动关联主键
to_field\to_fields 也可以自己指定关联字段
#tests.py代码
from django.test import TestCase
# Create your tests here.
import os
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "djangoProjectday54.settings")
import django
django.setup()
from app01 import models
#
# models.User.objects.create(name='jason', age=18,pwd=111)
# models.User.objects.create(name='tony', age=28,pwd=222)
# models.User.objects.create(name='cks', age=38,pwd=333)
# models.User.objects.create(name='xhz', age=48,pwd=444)
# models.User.objects.create(name='cll', age=58,pwd=555)
# models.User.objects.create(name='wyx', age=68,pwd=666)
# models.User.objects.create(name='zmz', age=78,pwd=777)
# models.User.objects.create(name='ctx', age=88,pwd=888)
# models.User.objects.create(name='lsc', age=98,pwd=999)
# models.User.objects.create(name='zqh', age=108,pwd=000)
"""找寻年龄大于二十的用户__gt=大于"""
# res=models.User.objects.filter(age__gt=20)
"""找寻年龄小于二十的用户__lt=小于"""
# res=models.User.objects.filter(age__lt=20)
"""找寻年龄小于等于二十的用户__gte=小于等于"""
# res=models.User.objects.filter(age__gte=20)
"""找寻年龄大于等于二十的用户__lte=大于于等于"""
# res = models.User.objects.filter(age__lte=20)
"""2.查询年龄是18、28、38的用户 __in 等于成员运算"""
# res = models.User.objects.filter(age__in=[18, 28, 38])
""" # 3.查询年龄在18到58之间的用户 __range 范围查询"""
# res = models.User.objects.filter(age__range=[18, 58])
""" 4.查询姓名中包含字母x的用户 """
# res = models.User.objects.filter(name__contains='x')
"""区别在于 __contains 区分大小写 __icontains忽略大小写"""
# res = models.User.objects.filter(name__icontains='x')
""" startswith：大小写敏感的判断某个字段的值是否以某个值开始的"""
# res = models.User.objects.filter(name__startswith='W')
"""istartswith: 大小写不敏感的判断某个字段的值是否以某个值开始的"""
# res = models.User.objects.filter(name__istartswith='x')
"""iendswith： 不区分大小写判断某个字段的值中是否含有某个值，"""
# res=models.User.objects.filter(name__iendswith='Z')
"""regex大小写敏感的判断某字段的值是否满足正则表达式的条件;iregex：大小写不敏感的判断的判断某字段的值是否满足正则表达式的条件。"""
"""忽略"""
""".查询月份是2022年的数据 __year 按照年份筛选数据 """
# res=models.User.objects.filter(op_time__year=2022)
"""查询月份是5月的数据"""
res= models.User.objects.filter(op_time__month=5)
print(res)
外键字段的创建
"""
MySQL复习
关系的种类
一对多关系
多对多关系
一对一关系
关系的判断
换位思考
字段的位置
一对多关系 外键字段建在多的一方
多对多关系 外键字段建在第三张关系表中
一对一关系 外键字段建在任意一方都可以 但是推荐建在查询频率较高的表中
"""
django orm创建表关系
图书表
出版社表
作者表
作者详情表
关系判断
书与出版社
一本书不能对应多个出版社
一个出版社可以对应多本书
# 一对多关系 书是多 出版社是一 ForeignKey
'''django orm外键字段针对一对多关系也是建在多的一方 '''
书与作者
一本书可以对应多个作者
一个作者可以对应多本书
# 多对多关系 ManyToManyField
'''django orm外键字段针对多对多关系 可以不用自己创建第三张表'''
作者与作者详情
一个作者不能对应多个作者详情
一个作者详情不能对个多个作者
# 一对一关系 OneToOneField
'''django orm外键字段针对一对一关系 建在查询频率较高的表中'''
ManyToManyField不会在表中创建实际的字段 而是告诉django orm自动创建第三张关系表
ForeignKey、OneToOneField会在字段的后面自动添加_id后缀 如果你在定义模型类的时候自己添加了该后缀那么迁移的时候还会再次添加_id_id 所以不要自己加_id后缀
ps:三个关键字里面的参数
to用于指定跟哪张表有关系 自动关联主键
to_field\to_fields 也可以自己指定关联字段
#models.py代码
from django.db import models
# Create your models here.
class Book(models.Model):
"""图书表"""
title = models.CharField(max_length=32, verbose_name='书名')
price = models.DecimalField(max_length=8, decimal_places=2, verbose_name='价格')
publish_time = models.DateField(auto_now_add=True, verbose_name='出版时间')
"""一个书不能对应多个出版社，一个出版社能对应多本书，，，一对多 书是多出版社是一
Django orm外键字段也是建在多的一方 所以我们在下面创建外键字段"""
"""书与出版社的外键字段"""
publish = models.ForeignKey(to='Publish') # 一对多外键字段创建 括号里面参数表示 to=后面跟对应关系的表，默认与对应表主键字段做关联
"""属于作者的外键字段 多对多 自动出啊关键第三张表"""
authors = models.ManyToManyField(to="Author")
def __str__(self):
return '书籍对象：%s' % self.title
class Publish(models.Model):
"""出版社表"""
name = models.CharField(max_length=32, verbose_name='出版社名称')
addr = models.CharField(max_length=32, verbose_name='出版社地址')
def __str__(self):
return '出版对象:%s' % self.name
class Author(models.Model):
"""作者表"""
name = models.CharField(max_length=32, verbose_name='作者名')
age = models.IntegerField(verbose_name='年龄')
""" 作者与作者详情的外键字段 一对一
一个作者不能对应多个作者详情
一个作者详情不能对个多个作者
# 一对一关系 """
author_detail=models.OneToOneField(to="AuthorDetail")
def __str__(self):
return '作者名字：%s' % self.name
class AuthorDetail(models.Model):
"""作者详情"""
phone = models.BigIntegerField(verbose_name='手机号')
addr = models.CharField(max_length=64, verbose_name='家庭住址')
def __str__(self):
return '家庭住址：%s' % self.addr
test.py
from django.test import TestCase
# Create your tests here.
import os
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "djangoProjectday55.settings")
import django
django.setup()
import django
django.setup()
from app01 import models
"""新增关系字段"""
"""一对多 一对一 外键操作"""
"""针对一或者一对多都可以给直接写值，也可以直接给数据对象"""
"""可以直接传他的主键值"""
models.Book.objects.create(title='牛马百科全书', price=1234.22, publish_id=1)
models.Book.objects.create(title='牛马详解',price=1233.22,publish_id=2)
"""获取数据对象"""
publish_obj=models.Publish.objects.filter(pk=1).first()
models.Book.objects.create(title='牛马连城计划',price=2123.22,publish=publish_obj)
"""修改关系字段 书于出版社的外键字段"""
models.Book.objects.filter(pk=1).update(publish_id=3)
publish_obj=models.Publish.objects.filter(pk=3).first()
models.Book.objects.filter(pk=2).update(publish=publish_obj)
"""多对多段操作"""
"""对书和作者进行绑定关系"""
"""首先拿到书对象"""
book_obj = models.Book.objects.filter(pk=1).first()
""" 用 add 和作者表进行关联 进行添加"""
book_obj.authors.add(1)
"""可以进行多个添加直接写入主键值"""
book_obj.authors.add(1,2)
"""通理他也可以写入多个对象"""
author_obj1 = models.Author.objects.filter(pk=2).first()
author_obj2 = models.Author.objects.filter(pk=1).first()
book_obj.authors.add(author_obj2,author_obj1)
"""修改表关系 括号内必须是一个可迭代对象 元素同样支持主键值或者数据对象
"""
book_obj=models.Book.objects.filter(pk=1).first()
book_obj.authors.set([3,])
book_obj.authors.set([1,2])
author_abj1=models.Author.objects.filter(pk=3).first()
author_abj2=models.Author.objects.filter(pk=2).first()
book_obj.authors.set([author_abj1])
book_obj.authors.set([author_abj1,author_abj2])
""" 删除数据括号内可以放主键值也可以放数据对象 并且都支持多个"""
book_obj=models.Book.objects.filter(pk=1).first()
book_obj.authors.remove(2)
""" 4第三张关系表清空指定数据
book_obj.authors.clear()
括号内无需传值 直接清空当前表在第三张关系表中的绑定记录"""
多表查询
"""
MySQL多表查询思路
子查询
将SQL语句用括号括起来当做条件使用
连表操作
inner join\left join\right join\union
django orm本质还是使用的上述两种方法
子查询>>>:基于对象的跨表查询
连表操作>>>:基于双下划线的跨表查询
"""
# 正反向的概念
核心在于当前数据对象是否含有外键字段 有则是正向 没有则是反向
正向
eg:
由书籍查询出版社 外键字段在书籍表中 那么书查出版社就是'正向'
由书籍查询作者 外键字段在书籍表中 那么书查作者就是'正向'
由作者查询作者详情 外键字段在作者表中 那么也是'正向'
反向
eg:
由出版社查询书籍 外键字段不在出版社表 那么出版社查书就是'反向'
...
"""
查询口诀
正向查询按外键字段名
反向查询按表名小写
"""
# 编写orm跟编写SQL语句一样 不要总想着一步到位!!!
test.py
from django.test import TestCase
# Create your tests here.
import os
import sys
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "djangoProject1.settings")
import django
django.setup()
from app01 import models
#一对一和一对多 修改外键字段值
# models.Book.objects.filter(pk=1).update(publish_id=1)
# models.Book.objects.filter(pk=1).update(publish_id=2)
#多对多 修改对应关系
#1.添加对应关系
# book_obj = models.Book.objects.filter(pk=1).first() # 先获取对应的书籍对象
# book_obj.authors.add(2) # 将id为1的书籍与id为2的作者相关联
book_obj=models.Book.objects.filter(pk=2).first()
book_obj.authors.add(1)
book_obj2=models.Book.objects.filter(pk=3).first()
book_obj2.authors.add(1)
# book_obj.authors.clear() # 清空对应关系
# book_obj.authors.add(1,2) # 添加2条数据 将id为1的书籍分与id为1和id为2的作者相关联，如果有关系，就会跳过，添加没有的
#2.修改
# book_obj = models.Book.objects.filter(pk=1).first()
# (1,2)(1,3)(1,4)
# book_obj.authors.set([3,4,5])
#3.删除
# book_obj = models.Book.objects.filter(pk=1).first()
# book_obj.authors.remove(2) # 小括号李写的是关联表的id
#4.清空关系
# book_obj = models.Book.objects.filter(pk=1).first()
# book_obj.authors.clear()
#多表查询
#基于对象的跨表查询
#1.查询Python书籍对应的出版社
# book_obj = models.Book.objects.filter(title='Python')
# res = book_obj[0].publish # 返回的是一个对象
# print(res) # Publish object
# print(res.title) # 上海出版社
# print(res.id)
# 2.查询上海出版社出版的书籍
# p_obj = models.Publish.objects.filter(title='上海出版社').first()
# # res = p_obj.book_set # 反向查询表名小写+_+set 如book_set
# # print(res) # app01.Book.None
# res = p_obj.book_set.all() # 如果返回值可能是多条也可能是一条就必须加all()
# print(res) # <QuerySet [<Book: Book object>]>
# print(res[0].title) # Python
#######################################################
# 3.查询电话是1的作者(一对一)
# a_obj = models.AuthorDetail.objects.filter(phone=1).first()
# res = a_obj.author # 反向查询在一对一关系中表名小写就可以了
# print(res) # Author object
########################################################
#基于双下的跨表查询
# 1.查询Python书籍对应的出版社名称
# res = models.Book.objects.filter(title='Python').values('publish__title') # values()外键名+ __ + 要查找的字段名（出版社名称）
# print(res) # <QuerySet [{'publish__title': '上海出版社'}]>
# print(res[0].get('publish__title')) # 上海出版社
#2.查询作者张三的手机号和地址
# res = models.Author.objects.filter(name='张三').values('author_detail__phone','author_detail__addr')
# print(res) # <QuerySet [{'author_detail__phone': 1, 'author_detail__addr': '上海'}]>
#反向查询
#3.查询电话是1的作者的姓名
# res = models.AuthorDetail.objects.filter(phone=1).values('author__name')
# print(res) # <QuerySet [{'author__name': '张三'}]>
#双下划线查询扩展
#1.查询Python书籍对应的出版社名称
#第一种基于对象
# book_obj = models.Book.objects.filter(title='Python').first()
# res = book_obj.publish
# print(res) # Publish object
# print(res.title) # 上海出版社
# #第二种 基于双下划线
# res = models.Book.objects.filter(title='Python').values('publish__title')
# print(res) # <QuerySet [{'publish__title': '上海出版社'}]>
# print(res[0].get("publish__title")) # 上海出版社
# #第三种 基于双下划线扩展
res = models.Publish.objects.filter(book__title='Python')
print(res) # <QuerySet [<Publish: Publish object>]>
基于对象的跨表查询
"""基于对象的跨表查询本质就是子查询即分步操作即可"""
"""多表查询"""
""" 查询口诀
正向查询按外键字段名
反向查询按表名小写"""
"查询数据分析对应的出版社基于对象的查询也就是子查询进行分布操作"
"""首先获取书籍对象"""
# book_obj = models.Book.objects.filter(title='python全栈开发').first()
"""再使用跨表查询,"""
# res=book_obj.publish
# print(res)
"""查询python全栈开发对应的作者
1.还是先拿对象"""
# book_obj = models.Book.objects.filter(title='牛马百科全书').first()
# """再使用跨表查询"""
# res = book_obj.authors.all()
# print(res)
# book_obj = models.Book.objects.filter(title='linux云计算').first()
# res=book_obj.authors.all()
# print(res)
# 查询jason的详情信息
# author_obj=models.Author.objects.filter(name='jason').first()
# print(author_obj)
# res=author_obj.author_detail
# print(res)
"""查询北方出版社出版的书籍"""
# publish_obj=models.Publish.objects.filter(name='北方出版社').first()
# print(publish_obj)
# res=publish_obj.book_set.all()
# print(res)
"查询jason编写的书籍"
# author_obj=models.Author.objects.filter(name='zqh').first()
# print(author_obj)
# res=author_obj.book_set.all()
# print(res)
"查询电话是110的作者"
author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
res = author_detail_obj.author
print(res)
# 1.查询数据分析书籍对应的出版社
# 先获取书籍对象
# book_obj = models.Book.objects.filter(title='数据分析').first()
# 再使用跨表查询
# res = book_obj.publish
# print(res) # 出版社对象:北方出版社
# 2.查询python全栈开发对应的作者
# 先获取书籍对象
# book_obj = models.Book.objects.filter(title='python全栈开发').first()
# 再使用跨表查询
# res = book_obj.authors # app01.Author.None
# res = book_obj.authors.all()
# print(res) # <QuerySet [<Author: 作者对象:jason>, <Author: 作者对象:jerry>]>
# 3.查询作者jason的详情信息
# 先获取jason作者对象
# author_obj = models.Author.objects.filter(name='jason').first()
# 再使用跨表查询
# res = author_obj.author_detail
# print(res) # 作者详情对象:芜湖
基于双下划线的跨表查询
"""基于双下划线的跨表查询本质就是连表操作"""
# 基于双下划线的跨表查询
"""
查询数据分析书籍对应的价格和出版日期
models.Book.objects.filter(title='数据分析').values('price','publish_time')
"""
'''手上有什么条件就先拿models点该条件对应的表名'''
# 1.查询数据分析书籍对应的出版社名称
# res=models.Book.objects.filter(title='牛马详解').values('publish__name','publish__addr')
# print(res)
""" 2.查询python全栈开发对应的作者姓名和年龄"""
# res=models.Book.objects.filter(title='python全栈开发').values('authors__name','authors__age')
# print(res)
"""3.查询作者jzqh的手机号和地址"""
# res=models.Author.objects.filter(name='zqh').values('author_detail__phone','author_detail__addr')
# print(res)
"""4.查询南方出版社出版的书籍名称和价格"""
# res=models.Publish.objects.filter(name='南方出版社').values('book__price','book__title')
# print(res)
""" 5.查询jason编写的书籍名称和日期"""
# res=models.Author.objects.filter(name='jason').values('book__title','book__publish_time')
# print(res)
""" 6.查询电话是110的作者的姓名和年龄"""
res=models.AuthorDetail.objects.filter(phone=110).values('author__name','author__age')
print(res)
双下线查询扩展
"""基于双下划线的跨表查询的结果也可以是完整的数据对象"""
'''手上有条件所在的表可以不被models点 直接点最终的目标数据对应的表'''
# 1.查询数据分析书籍对应的出版社名称
# res=models.Book.objects.filter(title='牛马详解').values('publish__name','publish__addr')
# print(res)
""" 2.查询python全栈开发对应的作者姓名和年龄"""
# res=models.Book.objects.filter(title='python全栈开发').values('authors__name','authors__age')
# print(res)
"""3.查询作者jzqh的手机号和地址"""
# res=models.Author.objects.filter(name='zqh').values('author_detail__phone','author_detail__addr')
# print(res)
"""4.查询南方出版社出版的书籍名称和价格"""
# res=models.Publish.objects.filter(name='南方出版社').values('book__price','book__title')
# print(res)
""" 5.查询jason编写的书籍名称和日期"""
# res=models.Author.objects.filter(name='jason').values('book__title','book__publish_time')
# print(res)
""" 6.查询电话是110的作者的姓名和年龄"""
# res=models.AuthorDetail.objects.filter(phone=110).values('author__name','author__age')
# print(res)
"双下线查询扩展"
""" 1.查询数据分析书籍对应的出版社名称"""
# res=models.Publish.objects.filter(book__title='python全栈开发').values('name')
# print(res)
"""2.查询python全栈开发对应的作者姓名和年龄"""
# res=models.Author.objects.filter(book__title='python全栈开发').values('name','age')
# print(res)
"""3.查询作者jason的手机号和地址"""
# res=models.AuthorDetail.objects.filter(author__name='jason').values('phone','addr')
# print(res)
"""可能出现的不是疑问的疑问:如何获取多张表里面的字段数据"""
# res = models.Book.objects.filter(title='python全栈开发').values('authors__author_detail__phone', 'authors__name', 'title')
# print(res)
# res = models.Book.objects.filter(title='python全栈开发').values('authors__author_detail__phone')
# print(res)
"""5.查询jason编写的书籍名称和日期"""
# res = models.Book.objects.filter(authors__name='jason').values('title', 'publish_time')
# print(res)
"""4.查询东方出版社出版的书籍名称和价格"""
res = models.Book.objects.filter(publish__name='东方出版社').values('title', 'price')
print(res)
如何查看SQL语句
方式1:如果结果集对象是queryset 那么可以直接点query查看
方式2:配置文件固定配置
适用面更广 只要执行了orm操作 都会打印内部SQL语句
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· C#/.NET/.NET Core优秀项目和框架2025年2月简报
· Manus爆火，是硬核还是营销？
· 一文读懂知识蒸馏
· 终于写完轮子一部分：tcp代理 了，记录一下