Python学习---ORM查询之基于对象的正向/反向/聚合/分组/Q/F查询

ORM查询之基于对象的正向查询与反向查询

对象形式的查询

# 正向查询

    ret1=models.Book.objects.first()
    print(ret1.title)
    print(ret1.price)
    print(ret1.publisher)
    print(ret1.publisher.name)  # ret1.publisher是book属性，是Publish对象,非queryset集合

# 反向查找

ret2=models.Publish.objects.last()
    print(ret2.name)
    print(ret2.city)

#如何拿到与它绑定的Book对象呢?

    print(ret2.book_set.all())  # ret2.book_set是一个queryset集合，all()可以省略
    print(ret2.book_set.all().values('title').distinct())  # 去重

ORM查询之基于条件的正向查询与反向查询

单表条件查询[双下划线实现表关联]：使用逗号分隔可以实现and的条件查询

#    models.Book.objects.filter(id__lt=10, id__gt=1)      # 获取id大于1 且 小于10的值
#    models.Book.objects.filter(id__in=[11, 22, 33])      # 获取id等于11、22、33的数据
#    models.Book.objects.exclude(id__notin=[11, 22, 33])  # not in
#    models.Book.objects.filter(title__contains="Python") # 模糊匹配
#    models.Book.objects.filter(name__icontains="ven")    # icontains大小写不敏感
#    models.Book.objects.filter(id__range=[1,12])         # 范围bettwen and
#    startswith，istartswith, endswith, iendswith,        # 以XXX开始/XXX结束

多表条件关联查询[双下划线实现表关联]

一对多[正向查询]: 使用逗号分隔可以实现and的条件查询，filter和values里面均可使用双下划线

#  models.Book.objects.filter(title='Python',id=5).values('publish__name').distinct()  
    # [{'publisher__city': '北京'}]  publish__name这里的Book里面的publish属性
#  models.Book.objects.filter(publish__id=5).values('title').distinct()  
    # Book查找出版社ID=5的书的名字
#  models.Book.objects.filter(publish__id=5).values('publish_name').distinct()  
    # Book查找出版社ID=5的出版社的名字

一对多[反向查询]：使用逗号分隔可以实现and的条件查询，filter和values里面均可使用双下划线

#  models.Publish.objects.filter(book__title='Python',book_id=5).values('name') .distinct()  
    # [{'name': 'H出版社'}] 查找跟Publish相关的Book的内容，book__title中的book就是Publish的关联表名

多对多[正向查询]：使用逗号分隔可以实现and的条件查询

#  models.Book.objects.filter(title='Python').values('author__name ') .distinct()  
#  models.Book.objects.filter(author__name='FTL').values('title') .distinct()  

多对多[反向查询]：使用逗号分隔可以实现and的条件查询

 #  models.Author.objects.filter(book__title='Python').values('name') .distinct() 

注意:

1、正向查找的book__title中的book是表名Book

2、正向查找的publish__city或者author__name中的publish,author是book表中绑定的字段【Book里面的属性】

3、一对多和多对多在这里用法没区别

ORM之聚合查询与分组查询

ORM之聚合查询与分组查询

聚合查询： aggregate(*args,**kwargs):可通过filter/Values过滤后聚合

通过对QuerySet进行计算，返回一个聚合值的字典。aggregate()中每一个参数都指定一个包含在字典中的返回值[键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的],即在查询集上生成聚合。

from django.db.models import Avg,Min,Sum,Max
>>> Book.objects.all().aggregate(Avg('price'))
{'price__avg': 34.35}     # 系统定义名称
>>> Book.objects.all().aggregate (average_price=Avg('price'))
{'average_price': 34.35}     # 自定义了名称
>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))  # 其他查询

分组查询：annotate(*args,**kwargs):可通过filter/Values过滤后分组

可以通过计算查询结果中每一个对象所关联的对象集合，从而得出总计值(也可以是平均值或总和)，即为查询集的每一项生成聚合。

from django.db.models import Avg,Min,Sum,Max
>>> Book.objects.values('author_name').annotate(Sum('price')) # 根据作者名分组后计算每个作者price

ORM之 F查询与Q查询

F查询： 只能适用于IntegerFiled  【使用了F查询，默认值是0】

from django.db.models import F
models.Book.objects.update(num=F('num') + 100)  

Q查询：

from django.db.models import Q
#1 Q对象(django.db.models.Q)可以对关键字参数进行封装，从而更好地应用多个查询
    q1=models.Book.objects.filter(Q(title__startswith='P')).all()
# 2、可以组合使用&,|操作符，当一个操作符是用于两个Q的对象,它产生一个新的Q对象。
    q2=models.Book.objects.filter(Q(name='HHH')|Q(name='FTL')).all()
    # 3、Q对象可以用~操作符放在前面表示否定，也可允许否定与不否定形式的组合
    Q(title__startswith='P') | ~Q(pub_date__year=2005)
# 4、应用：
    Book.objects.get(
         Q(title__startswith='P') and
        (Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))
    )
# 5、Q对象可以与关键字参数查询一起使用，不过一定要把Q对象放在关键字参数查询的前面。
    # 正确：
    Book.objects.get(
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
        title__startswith='P')
    # 错误：
    Book.objects.get(
        question__startswith='P',
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))

Q的信息补充

# 方式一： 直接用，不能动态实现
        models.UserInfo.objects.filter(Q(Q(username=u)&Q(pwd=p))|Q(Q(emial=u)&Q(pwd=p)))
# 方式二： 创建Q对象且指定连接connector  【适用于多个元素，因为可用for循环，可动态循环】
        con = Q()
        
        q1 = Q()
        q1.connector = 'AND'
        
        q1.children.append(('email', e))
        q1.children.append(('password', p))
        # Q(Q(email=e)&Q(pwd=p))      
        
        q2 = Q()
        q2.connector = 'AND'
        q2.children.append(('username', _value_dict['user']))
        q2.children.append(('password', _value_dict['pwd']))
        # Q(Q(username=u)&Q(pwd=p))
        
        con.add(q1, 'OR')
        con.add(q2, 'OR')
        
        models.UserInfo.objects.filter(con)

　　另外：

如果传递过来一个字典：那就可以进行组合搜索：
q1 = Q()
q2.connector = 'AND'
dict = {'id':1, 'username':'hhh', 'sex':'male', 'age':18}
for k,v in dict:
    q1.children.append((k, v))    #  此时字典里面的所有值进行and组合查询