django reverse_Django框架学习Day04 - 隔江千万里

最新推荐文章于 2024-01-22 23:30:34 发布

weixin_39614561

最新推荐文章于 2024-01-22 23:30:34 发布

阅读量88

点赞数

文章标签： django reverse django框架学习文档

[Django之ORM表高级操作、增删改查、外键字段连表查、单表查、跨表查、F/Q查询]

1.对表数据的添加、更新、删除

()  	# 添加
()		# 更新
()		# 删除

create()

# 对电影表添加一条数据
# create()  返回值就是当前被创建数据的对象本身
(title='西游记',price='2016-1-1')

 # 还可以直接传日期对象
from datetime import date
ctime = ()
(title='西游记', price=666.23, publish_time=ctime)

变态操作之批量插入数据

# 方式一
# 走1000次数据库，非常的慢
def ab_bc(request):
    # 插入1000条件数据
    for i in range(1,1001):
        (title='第%s本书'%i)

# 方式二
# 调用bulk_create()方法 插入10000条数据，走一次数据库
def ab_bc(request):
	book_list = []
    for i in range(1,10001):
        ((title='新的%s书'%i))
    .objects.bulk_create(book_list)  # 批量插入数据的方式

()

# update()  更新数据      返回值是受影响的行数
res = (pk=1).update(title='玉女心经')
print(res) 	# 1   受影响的条数

()

# delete()  删除数据    返回值(1, {'': 1})  受影响的表及行数
res = (pk=3).delete()
print(res)  # (1, {'': 1})

4.如何查看QuerySet对象执行的sql语句？

res = (pk=3).delete()
print()  # 获取res的sql执行语句

5.如何配置文件自动查看sql语句？

如果你想知道你对数据库进行操作时，Django内部到底是怎么执行它的sql语句时可以加下面的配置来查看

在Django项目的文件中，在最后复制粘贴如下代码：

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'',
        },
    },
    'loggers': {
        '': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

2. 单表查询13个操作

返回QuerySet对象的方法有：
            all()
            filter()
            exclude()
            order_by()
            reverse()
            distinct()
特殊的QuerySet：
			values()       返回一个可迭代的字典序列
			values_list()  返回一个可迭代的元组序列
返回具体对象的：
            get()
            first()
            last()	
返回布尔值的方法有：
			exists()
返回数字的方法有：
			count()

3.返回QuerySet对象的方法有：

() 查询所有结果

res = ()
print(res)

() 条件匹配

# 获取电影表中id为1的数据
# 不存在就返回空，而不是报错。get(id=1)不存在就直接报错
res = (id=1)
print(res)

() 取反(排除)

# 获取id为1之外的数据
res = (pk=1)
print(res)

() 排序

res = ('price')  # 默认是升序
res = ('-price')  # 减号就是降序

() 反转

res = ('price').reverse()  # 将次序反转

() 去重

# 去重:去重的前提 必须是由完全一样的数据的才可以
res = ('title','price').distinct()

() 获取指定字段对列表套字典

返回一个可迭代的字典序列

values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列

# values()   QuerySet对象  [{},{},{}]     获取指定字段对的数据
# 返回一个可迭代的字典序列
res = ('title','publish_time')

() 获取指定字段对** 列表套字典列表套元组

返回一个可迭代的元组序列

values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列

res = _list('title','price')
print(res)

直接获取对象，不存在就报错

# get()      直接获取对象本身  不推荐使用  当查询条件不存在的时候直接报错
res = (pk=1)
print(res)

() 取第一个元素对象

# first()    数据对象        取第一个元素对象
res = ().first()
print(res)

() 取最后一个元素对象

# last()    数据对象          取最后一个元素对象
res = ()
print(res)

()

# exists()   返回的是布尔值  判断前面的对象是否有数据
res = (pk=1000).exists()  # 不存在，Fslse
print(res)

res = (pk=1).exists()   # 存在，True

13.count() 统计数据条数

# 统计筛选之后数据的条数
res = ()
print(res)

四、神奇的双下线跨表查询

在python中我们进行逻辑判断会用到>、<、=、or之类的符号，那么在Django进行models数据操作的时候，我们表示：双下划线

__gt		: 大于
__lt		: 小于
__gte		: 大于等于
__lte		: 小于等于
__in		: 或
__rang		: 在...之间，顾头也顾尾
__contains	 ：模糊查询，区分大小写
__icontains	 ：模糊查询，不区分大小写
__year		: 查询年份
__month		： 查询月份

 # 神奇的双下划线查询
 	# 1.查询价格大于200的电影
    res = (price__gt=200)
    print(res)
    # 2.查询价格小于500的电影
    res = (price__lt=500)
    print(res)
    # 3.查询价格大于等于的电影
    res = (price__gte=)
    print()
    # 4.查询价格小于等于的电影
    res = (price__lte=500)
    print(res)
    # 5.查询价格是123 或666 或876
    res = (price__in=[123,666,876])
    print(res)
    # 6.查询价格在200到900之间的电影  顾头也顾尾
    res = (price__range=(200,900))
    print(res)
    # 7.查询电影名中包含字母p的电影
    res = (title__contains='p')  # 默认是区分大小写
    res = (title__icontains='p')  # i忽略大小写
   
	# 8.查询2014年出版的电影
    res = (publish_time__year=2014)
    # print(res)
    # 9.查询是1月份出版的电影
    res = (publish_time__month=1)
    print(res)

五、外键字段的增删改查

1.一对多

增直接写真实的表字段

# publish_id是外键字段
(title='三国演义',price=)

.增通过对象

# Publish 是modles中有关联的表
publish_obj = (pk=1)
(title='大话西游',price=)

.改直接筛选出来，直接改

.objects.filter(pk=1).update(publish_id=3)

. 改通过对象

# 先获取出版社表id为4的对象
publish_obj = (pk=4)
.objects.filter(pk=1).update(publish=publish_obj)

2.多对多

1.绑定关系 add

add专门给第三张关系表添加数据
    括号内即可以传数字也可以传对象  并且都支持传多个

# 1.获取书籍对象
book_obj = .objects.filter(pk=1).first()
# 2.书籍对象点‘.’外键字段就已经跨入第三张表中了。再用add添加绑定关系
(1,2,3)  # 给书籍绑定一个主键为1，2，3的作者

# 获取对象
author_obj = (pk=1)
author_obj1 = (pk=3)
# 添加绑定关系
(author_obj)
(author_obj,author_obj1)

2.移除绑定关系 remove

remove专门给第三张关系表移除数据
        括号内即可以传数字也可以传对象  并且都支持传多个

    # 按照具体外键的值进行删除
    book_obj = .objects.filter(pk=1).first()
    (2)
    (1,3)
    
    # 获取相关对象删除
    author_obj = (pk=2)
    author_obj1 = (pk=3)
    (author_obj)
    (author_obj,author_obj1)

3.修改绑定关系 set

# authors外键字段，Author类名
book_obj = .objects.filter(pk=1).first()
((3,))
((2,3))


author_obj = (pk=2)
author_obj1 = (pk=3)
([author_obj,author_obj1])   # 可迭代对象

4.清空关系

clear()  清空关系
    不需要任何的参数

book_obj = .objects.filter(pk=1).first()
()  # 去第三张表中清空书籍为1的所有数据

六、跨表查询

mysql中跨表查询的方式
        1.子查询  将一张表的查询结果当做另外一张表的查询条件
            正常解决问题的思路 分步操作
        2.链表查询
            inner join
            left join
            right join
            union

正反向的概念
        正向
            跨表查询的时候 外键字段是否在当前数据对象中 如果在
            查询另外一张关系表  叫正向
            
        反向
            如果不在叫反向
        
        口诀
            正向查询按外键字段
            反向查询按表名小写

1.基于对象的跨表查询(子查询):

# 1.查询书籍pk为1的出版社名称
    book_obj = .objects.filter(pk=1).first()
    print()
# 2.查询书籍pk为2的所有作者的姓名
	book_obj = .objects.filter(pk=2).first()
    author_list = ()
        for author_obj in author_list:
        print()
       
# 3.查询作者pk为1的电话号码
	author_obj = (pk=1).first()
    print()
 
# 4.查询出版社名称为东方出版社出版过的书籍
	publish_obj = (name='东方出版社').first()
	print(())
    
# 5.查询作者为jason写过的书
	author_obj = (name='jason').first()
    print(())
    
# 6.查询手机号为120的作者姓名
	author_detail_obj = (phone=120).first()
    print()

2.基于双下划线跨表查询(链表查询)

# 1.查询书籍pk为1的出版社名称
    # 正向
    res = .objects.filter(pk=1).values('publish__name')  # 写外键字段 就意味着你已经在外键字段管理的那张表中
    print(res)
    # 反向
    res = (book__pk=1)  # 拿出版过pk为1的书籍对应的出版社
    res = (book__pk=1).values('name')
    print(res)

# 2.查询书籍pk为1的作者姓名和年龄
    # 正向
    res = .objects.filter(pk=1).values('title','authors__name','authors__age')
    print(res)
    # 反向
    res = (book__pk=1)  # 拿出出版过书籍pk为1的作者
    res = (book__pk=1).values('name','age','book__title')
    print(res)
    
# 3.查询作者是jason的年龄和手机号
    # 正向
    res = (name='jason').values('age','author_detail__phone')
    print(res)
    # 反向
    res = (author__name='jason')  # 拿到jason的个人详情
    res = (author__name='jason').values('phone','author__age')
    print(res)

# 4.查询书籍pk为的1的作者的手机号
    # 正向
    # 只要表之间有关系  你就可以通过正向的外键字段或者反向的表名小写 连续跨表操作
    res = .objects.filter(pk=1).values('authors__author_detail__phone')
    print(res)
    # 反向
    res = (author__book__pk=1).values('phone')
    print(res)

3.聚合查询

from django.db.models import Max,Min,Avg,Count,Sum   # 导入模块

res = .objects.aggregate(avg_num=Avg('price'))
print(res)
# 查询价格最贵的书
res = .objects.aggregate(max_num=Max('price'))
print(res)
# 全部使用一遍
res = .objects.aggregate(Avg("price"), Max("price"), Min("price"),Count("pk"),Sum('price'))
print(res)

4.分组查询

    # 1.统计每一本书的作者个数
    res = .objects.annotate(author_num=Count('authors')).values('title','author_num')
    print(res)

    # 2.统计出每个出版社卖的最便宜的书的价格
    res = (min_price=Min('book__price')).values('name','min_price','book__title')
    print(res)

    # 3.统计不止一个作者的图书
    res = .objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title')
    print(res)

    # 4.查询各个作者出的书的总价格
    res = (price_sum=Sum('book__price')).values('name','price_sum')
    print(res)

查询

# 1.查询库存数大于卖出数的书籍
    res = .objects.filter(kucun__gt=F('maichu'))
    print(res)

# 2.将所有书的价格提高100
    res = .objects.update(price=F('price') + 100)

查询

','逗号隔开是and关系
'|'管道符是or的关系
'~'是not关系

filter() 等方法中逗号隔开的条件是与的关系。 如果你需要执行更复杂的查询(例如OR语句)，你可以使用Q对象。

示例1：

查询 卖出数大于100 或者 价格小于100块的

from django.db.models import Q
models.Product.objects.filter(Q(maichu__gt=100)|Q(price__lt=100))

# 1.查询书的名字是python入门或者价格是1000的书籍
    res = .objects.filter(title='python入门',price=1000)  # and关系
    res = .objects.filter(Q(title='python入门'),Q(price=1000))  # 逗号是and关系
    res = .objects.filter(Q(title='python入门')|Q(price=1000))  # |是or关系
    res = .objects.filter(~Q(title='python入门')|Q(price=1000))  # ~是not关系

的高阶用法

res = .objects.filter('title'='python入门')
q = Q()
q.connector = 'or'  # q对象默认也是and关系  可以通过connector改变or
(('title','python入门'))
(('price',1000))

res = .objects.filter(q)
print(res)

------------恢复内容开始------------