Django中ORM之查询表记录

查询相关API

from django.db import models

# Create your models here.
class Book(models.Model):
    title = models.CharField(max_length=32)
    publishDate = models.DateField()
    price = models.DecimalField(max_digits=5, decimal_places=2)

    #创建一对多的关联字段
    publish = models.ForeignKey("Publish")

    #创建多对多的关系
    authors = models.ManyToManyField("Author")

    def __str__(self):return self.title

class Publish(models.Model):
    nid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    email = models.EmailField()

class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()

class AuthorDetail(models.Model):
    addr = models.CharField(max_length=32)
    email = models.EmailField()
    author = models.OneToOneField("Author")

数据准备

　　一定区分object和QuerySet的区别

　　 #all() 查询所有结果
    book_list=Book.objects.all() #<QuerySet [<Book: book1>, <Book: book2>, <Book: book3>]>

    #filter()它包含了与所给筛选条件相匹配的对象
    book_list = Book.objects.filter(id=1) 　#<QuerySet [<Book: book1>]>

    #get() model对象 有且只有一个查询结果时才有意义 如果超过一个或者没有都会抛出异常
    book = Book.objects.get(id=2)     #<Book: book2>

    #order_by()  model对象 对查询结果排序
    book = Book.objects.all().order_by("-id") #<QuerySet [<Book: book3>, <Book: book2>, <Book: book1>]>

    #reverse()  对查询结果反向排序
    book = Book.objects.all().order_by("-id").reverse()

    #count()  返回匹配查询对象的数量
    book = Book.objects.all().order_by("-id").count()  #3

    #exists() 如果Queryset包含数据，则返回true，否则返回false
    book  = Book.objects.all().exists()   　　　　　　　　#True

    book = Book.objects.filter(id=20).exists()  #False

    #values()  返回一个valueQureyset 是一个可迭代的字典序列
    book = Book.objects.all().values("title") #<QuerySet [{‘title‘: ‘book1‘}, {‘title‘: ‘book2‘}, {‘title‘: ‘book3‘} ]>

    #values_list() 返回的是一个元组序列，values返回的是一个字典序列
    book = Book.objects.all().values_list("title")#<QuerySet [(‘book1‘,), (‘book2‘,), (‘book3‘,)]>

    #distinct() 从返回结果中剔除重复记录
    book = Book.objects.all().distinct()

    #first()  返回第一条记录
    book = Book.objects.all().first()  #<Book: book1>

    #last()  返回最后一条记录
    book = Book.objects.all().last()   　#<Book: book6>

    #exclude() 它包含了与所给筛选条件不匹配的对象
    book = Book.objects.all().exclude(id=2)  #<QuerySet [<Book: book1>, <Book: book3>, <Book: book4>]>

双下划线之单表查询

　　 #id 大于3且小于6的值
    book = Book.objects.filter(id__lt=6,id__gt=3) #<QuerySet [<Book: book4>, <Book: book5>]>

    #获取id等于1、2、3的数据
    book = Book.objects.filter(id__in=[1,2,3])  #<QuerySet [<Book: book1>, <Book: book2>, <Book: book3>]>

    # not in
    book = Book.objects.filter().exclude(id__in=[1,2,3]) #<QuerySet [<Book: book4>, <Book: book5>, <Book: book6>]>

    #icontains大小写不敏感
    book = Book.objects.filter(title__contains="book")
    book = Book.objects.filter(title__icontains="book")

    # 范围bettwen and
    book = Book.objects.filter(id__range=[1,4])

    #startswith，istartswith, endswith, isendswith　

基于对象的跨表查询

　　一对多查询：正向查询按字段，反向查询按‘表名小写_set’

    # 查询id=2的书籍的出版社的名称
    book_obj = Book.objects.filter(id=2).first()
    print(book_obj.publish.name)

    # 查询“邮电出版社”出版过的书籍名称
    publish_obj = Publish.objects.filter(name=‘邮电出版社‘).first()
    print(publish_obj.book_set.all())

　　多对多查询：正向查询按字段，反向查询按‘表名小写_set’

    # 查询book1所有作者的名字
    book_obj = Book.objects.filter(title="book1").first()
    print(book_obj.authors.values("name"))

    # 查询alex出版过的所有书籍名称
    author_obj = Author.objects.filter(name=‘alex‘).first()
    print(author_obj.book_set.all().values(‘title‘))

　　一对一查询：正向查询按字段，反向查询按‘表名小写’

 　　# 查询emai为[email protected]的作者的名字
    authordetail_obj = AuthorDetail.objects.filter(email="[email protected]").first()
    print(authordetail_obj.author.name)

    # 查询alex的email
    author_obj = Author.objects.filter(name=‘alex‘).first()
    print(author_obj.authordetail.email)

基于双下划线的跨表查询

　　Django提供了 一种直观而高效的方式在查询中表示关联关系，它能自动确认SQL JOIN联系。要做跨关系查询，就使用两个下划线来链接模型间关联字段的名称，直到最终链接到你想要的model为止

　　正向查询按字段，反向查询按表名

　　一对多

　　book_obj = Book.objects.filter(price=100).values("title","publish__name")

    temp = []
    for book in Book.objects.filter(price=100):

         temp.append({
             "title":book.title,
             "publish__name":book.publish.name,
         })

    # 查询人民出版社出版过的书籍名称
    publish_obj = Publish.objects.filter(name=‘人民出版社‘).values("book__title")

    temp= []
    for book in publish_obj.book_set.all():
        temp.append({
            "book_title":book.title
        })

　　多对多

    # 查询book1所有作者的名字
    book_obj = Book.objects.filter(title=‘book1‘).values("authors__name")

    # 查询alex出版过的所有书籍名称
    author_obj = Author.objects.filter(name=‘alex‘).values("book__title")

　　一对一

    # 查询手email以1开头的作者出版过的所有书籍名称以及出版社名称
    authordetail_obj = AuthorDetail.objects.filter(email__startswith="1").values("author__book__title","author__book__publish__name")

    # 查询alex的email
    author_obj = Author.objects.filter(name=‘alex‘).values("authordetail__email")

聚合查询与分组查询

聚合查询

from django.db.models import Avg
Book.objects.all().aggregate(Avg(‘price‘))    #{‘price__avg‘: 107.14285714285714}

　　aggregate()是QuerySet的一个终止子句，它返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想为聚合值指定一个名称，可以向聚合子句提供它

Book.objects.aggregate(average_price=Avg(‘price‘)) #{‘average_price‘: 107.14285714285714}

　　如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数

from django.db.models import Avg,Max,Min
Book.objects.aggregate(Avg(‘price‘),Max(‘price‘),Min(‘price‘))#{‘price__avg‘: 107.14285714285714, ‘price__max‘: Decimal(‘200.00‘), ‘price__min‘: Decimal(‘30.00‘)}

分组查询

　　为调用的QuerySet的每一个对象都生成一个独立的统计值

 　　# 查询每一个出版社的名称以及出版过的书籍个数
    queryset_result = Publish.objects.all().annotate(c=Count("book")).values("name","c")
    print(queryset_result)

    # 查询每一个作者的名字以及出版过的所有书籍的最高价格
    queryset_result = Author.objects.all().annotate(max_Price=Max("book__price")).values("name","max_Price")
    print(queryset_result)

    # 查询每一本书的名字，对应出版社名称以及作者的个数
    queryset_result = Book.objects.all().annotate(c=Count("authors")).values("title","publish__name","c")
    print(queryset_result)

    #根据一本图书作者数量的多少对查询集 QuerySet进行排序:
    Book.objects.annotate(num_authors=Count(‘authors‘)).order_by(‘num_authors‘)

F查询与Q查询

F查询

　　如果我们要对两个字段的值做比较的话可以使用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对象

　　Q对象可以使用&和|操作符组合起来，当一个操作符在两个Q对象上使用时，它产生一个新的Q对象

bookList=Book.objects.filter(Q(authors__name="a1")|Q(authors__name="a2"))

　　Q对象可以使用~操作符取反

bookList=Book.objects.filter(Q(authors__name="a1") & ~Q(publishDate__year=2017)).values_list("title")

　　查询函数可以混合使用Q对象和关键字参数，所有提供给查询函数的参数（关键字参数或对象）都将“AND”在一起，但是如果出现Q对象，它必须位于所有关键字参数的前面

 bookList=Book.objects.filter(Q(publishDate__year=2016)|Q(publishDate__year=2017),title__icontains="python" )

原文地址：https://www.cnblogs.com/iamluoli/p/8985131.html