Django之Model（一）--基础篇
0、数据库配置
django默认支持sqlite，mysql, oracle,postgresql数据库。Django连接数据库默认编码使用UTF8，使用中文不需要特别设置。
sqlite
django默认使用sqlite的数据库，默认自带sqlite的数据库驱
引擎名称：django.db.backends.sqlite3
mysql
引擎名称：django.db.backends.mysql
mysql引擎配置：
'defaults': {
'ENGINE': 'django.db.backends.mysql',
'NAME':'127.0.0.1',
'USER':'root',
'PASSWORD':'',
}
mysql引擎底层驱动的py3支持问题：
mysql驱动程序 MySQLdb(mysql python),Django默认使用改驱动，但改驱动在python3下存在兼容性问题。因此使用PyMySQL。 PyMySQL(纯python的mysql驱动程序) mysql驱动python3解决方法 找到项目名文件下的__init__,在里面写入： import pymysql pymysql.install_as_MySQLdb()
一、Model类定义
1、Model类创建
下面这个模型类将作为本篇博客的基础模型，所有的实例都基于此。
from django.db import models class Publisher(models.Model): name = models.CharField(max_length=30, verbose_name="名称") website = models.URLField() # book_set 反向关联一对多字段的Book def __unicode__(self): return self.name class Author(models.Model): name = models.CharField(max_length=30) # authordetail 反向关联一对一字段AuthorDetail表 # book_set 反向关联一对多字段的Book def __unicode__(self): return self.name class AuthorDetail(models.Model): sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),)) author = models.OneToOneField(Author) # author_id隐藏字段，正向关联一对一字段的Author对象的id class Book(models.Model): title = models.CharField(max_length=100) authors = models.ManyToManyField(Author) publisher = models.ForeignKey(Publisher,null=True) # publisher_id隐藏字段，正向关联一对多字段的Publisher对象的id price=models.DecimalField(max_digits=5,decimal_places=2,default=10) def __unicode__(self): return self.title
#coding:utf-8 from __future__ import unicode_literals from django.db import models class Publisher(models.Model): name = models.CharField(max_length=30, verbose_name="名称") website = models.URLField() def __unicode__(self): return self.name class Author(models.Model): name = models.CharField(max_length=30) def __unicode__(self): return self.name class AuthorDetail(models.Model): sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),)) author = models.OneToOneField(Author) class Book(models.Model): title = models.CharField(max_length=100) authors = models.ManyToManyField(Author,through='Book2Author') publisher = models.ForeignKey(Publisher) price=models.DecimalField(max_digits=5,decimal_places=2,default=10) def __unicode__(self): return self.title class Book2Author(models.Model): book = models.ForeignKey(Book) author = models.ForeignKey(Author) groupname = models.CharField(max_length=100) #默认多对多关系Django自动为我们创建了一张中间表，仅提供3个字段，两个关联表的外键字段和一个id字段。 #这种使用自定义中间表的方式，使得我们可以自定义的为中间表添加额外的字段。当我们需要为多对多关系提供额外字段时，用此方式。
2、同步数据库
模型表创建和更新的时候是要使用数据库迁移命令，使模型类的改变同步到数据库。
makemigrations #创建变更记录
migrate #同步到数据库
3、Model类（表）关系图：
名词说明：
正向查询，从定义关系字段的类中去查询关系对象的值或值的集合。举个栗子：从AuthorDetail类中查询关联字段author对象的值。
反向查询，从本类中查询被关联对象中的值或值的集合。举个栗子：从Author对象中查询被关联字段AuthorDetail对象的值。
4、字段类型：
1、models.AutoField 自增列 = int(11) 如果没有的话，默认会生成一个名称为 id 的列，如果要显示的自定义一个自增列，必须将给列设置为主键 primary_key=True。 2、models.CharField 字符串字段 必须 max_length 参数 3、models.BooleanField 布尔类型=tinyint(1) 不能为空，Blank=True 4、models.ComaSeparatedIntegerField 用逗号分割的数字=varchar 继承CharField，所以必须 max_lenght 参数 5、models.DateField 日期类型 date 对于参数，auto_now = True 则每次更新都会更新这个时间；auto_now_add 则只是第一次创建添加，之后的更新不再改变。 6、models.DateTimeField 日期类型 datetime 同DateField的参数 7、models.Decimal 十进制小数类型 = decimal 必须指定整数位max_digits和小数位decimal_places 8、models.EmailField 字符串类型（正则表达式邮箱） =varchar 对字符串进行正则表达式 9、models.FloatField 浮点类型 = double 10、models.IntegerField 整形 11、models.BigIntegerField 长整形 integer_field_ranges = { 'SmallIntegerField': (-32768, 32767), 'IntegerField': (-2147483648, 2147483647), 'BigIntegerField': (-9223372036854775808, 9223372036854775807), 'PositiveSmallIntegerField': (0, 32767), 'PositiveIntegerField': (0, 2147483647), } 12、models.IPAddressField 字符串类型（ip4正则表达式） 13、models.GenericIPAddressField 字符串类型（ip4和ip6是可选的） 参数protocol可以是：both、ipv4、ipv6 验证时，会根据设置报错 14、models.NullBooleanField 允许为空的布尔类型 15、models.PositiveIntegerFiel 正Integer 16、models.PositiveSmallIntegerField 正smallInteger 17、models.SlugField 减号、下划线、字母、数字 18、models.SmallIntegerField 数字 数据库中的字段有：tinyint、smallint、int、bigint 19、models.TextField 字符串=longtext 20、models.TimeField 时间 HH:MM[:ss[.uuuuuu]] 21、models.URLField 字符串，地址正则表达式 22、models.BinaryField 二进制 23、models.ImageField 图片 24、models.FilePathField 文件
5、字段选项：
1、null=True 数据库中字段是否可以为空 2、blank=True django的 Admin 中添加数据时是否可允许空值 3、primary_key = False 主键，对AutoField设置主键后，就会代替原来的自增 id 列 4、auto_now 和 auto_now_add auto_now 自动创建---无论添加或修改，都是当前操作的时间 auto_now_add 自动创建---永远是创建时的时间 5、choices 配置可选项 GENDER_CHOICE = ( (u'M', u'Male'), (u'F', u'Female'), ) gender = models.CharField(max_length=2,choices = GENDER_CHOICE) 6、max_length 最大长度 7、default 默认值 8、verbose_name Admin中字段的显示名称 9、name|db_column 数据库中的字段名称 10、unique=True 不允许重复 11、db_index = True 数据库索引 12、editable=True 在Admin里是否可编辑 13、error_messages=None 错误提示 14、auto_created=False 自动创建 15、help_text 在Admin中提示帮助信息 16、validators=[] 自定义数据格式验证 17、upload-to 上传文件路径
6、Model类的Meta（元数据）选项：
abstract=False True就表示模型是抽象基类 db_table = 'music_album' 自定义数库的表名称前缀 get_latest_by = "datefield_name" 根据时间字段datefield_name排序，latest()和earliest()方法中使用的默认字段。 db_tablespace 当前模型所使用的数据库表空间的名字。默认值是项目设置中的DEFAULT_TABLESPACE。如果后端并不支持表空间，这个选项可以忽略。 ordering = ['-fieldname'] 对象默认的顺序,字段前面带有'-'符号表示逆序，否则正序。排序会增加查询额外开销。 proxy = True 它作为另一个模型的子类，将会作为一个代理模型。 unique_together 设置联合唯一。ManyToManyField不能包含在unique_together中。 index_together 设置联合索引。 index_together = [ ["pub_date", "deadline"], ] 方便起见，处理单一字段的集合时index_together = ["pub_date", "deadline"] verbose_name 在Admin里，个易于理解的表名称，为单数：verbose_name = "pizza" verbose_name_plural 在Admin里显示的表名称，为复数：verbose_name_plural = "stories"，一般同verbose_name一同设置。
二、对象CURD操作
2.1 基础对象CURD（无关联字段）
1、增
方法一： author= Author(name="鲁迅") author.save() 方法二： 创建对象并同时保存对象的快捷方法，存在关系字段时无法用此方法创建。 create(**kwargs) Author.objects.create(name=u"鲁迅") 方法三： 批量创建 bulk_create(objs, batch_size=None) ret=Blog.objects.bulk_create([ Author(name="徐志摩"), Author(name="李白")]) 方法四： 存在就获取，不存在就创建 get_or_create(defaults=None,**kwargs)， defaults必须为一个字典，在创建时生效的默认值；**kwargs为查询条件。 创建对象时，使用**kwargs和defaults共同作用，取交集，defaults优先。 updated_values={"name":u"美猴王"} a、存在就获取，查询到结果多余一个出错MultipleObjectsReturned ret=Author.objects.get_or_create(name=u'徐志摩',defaults=updated_values) ret：(<Author: 徐志摩>, False) b、不存在就创建 ret=Author.objects.get_or_create(name=u'徐志摩',defaults=updated_values) ret：(<Author: 美猴王>, True) 方法五： 存在就更新，不存在就创建 update_or_create(defaults=None, **kwargs) a、存在就更新 updated_values={"name":u"猴王"} ret=Author.objects.update_or_create(defaults=updated_values,name=u"猴子") ret：(<Author: 猴王>, False) 根据给出的查询条件name=u"猴子"查找对象，查询到结果就使用defaults字典去更新对象。 b、不存在就创建 ret=Author.objects.update_or_create(defaults=updated_values,name=u"猴子1") ret：(<Author: 猴王>, True) defaults必须为一个字典，在创建时生效的默认值；**kwargs为查询条件。 创建对象时，使用**kwargs和defaults共同作用，取交集，defaults优先。
2、删
使用delete会查找出相关表中的有关联的数据行一并删除 方法一： Author.objects.filter(name="徐志摩").delete() (1, {u'otest.Book_authors': 0, u'otest.AuthorDetail': 0, u'otest.Author': 1}) 方法二： a9=Author.objects.get(name="鲁迅") a9.delete()
3、改
方法一： update(**kwargs)返回更新的行数，批量修改 ret=Author.objects.filter(name='秋雨').update(name="陶渊明") 方法二： 单条修改 a7=Author.objects.get(name="清风") a7.name=u"宋清风" a7.save()
4、查
a、查询结果非QuertSet
get(**kwargs) 在使用 get() 时，如果符合筛选条件的对象超过一个，就会抛出 MultipleObjectsReturned 异常。 在使用 get() 时，如果没有找到符合筛选条件的对象，就会抛出 DoesNotExist 异常。 from django.core.exceptions import ObjectDoesNotExist try: e = Entry.objects.get(id=3) b = Blog.objects.get(id=1) except ObjectDoesNotExist: print("Either the entry or blog doesn't exist.") in_bulk(id_list) 接收一个主键值列表，然后根据每个主键值所其对应的对象，返回一个主键值与对象的映射字典。 Author.objects.in_bulk([1,2,3]) {1: <Author: 苍松>, 2: <Author: 猴王>, 3: <Author: 宋清风>} first() 查询第一条，一般使用前先排序,或者确定其只有一条数据。 last() 查询最后一条，同上 count() 返回数据库中匹配查询(QuerySet)的对象数量。 count() 不会抛出任何异常。 exists() 如果 QuerySet 包含有数据，就返回 True 否则就返回 False。这可能是最快最简单的查询方法了。 latest(field_name=None) ，根据时间字段 field_name 得到最新的对象。 earliest(field_name=None)， 根据时间字段 field_name 得到最老的对象。
#F使用查询条件的值,进行数值计算 from django.db.models import F Book.objects.filter(id=1).update(price=F('price')+10)
b、查询结果为QuerySet
常用方法：
1、filter(**kwargs) 过滤，返回一个新的QuerySet，包含与给定的查询参数匹配的对象。 >>>q=Author.objects.filter(name=u"苍松") >>> q [<Author: 苍松>] 2、exclude(**kwargs) 反过滤，返回一个新的QuerySet，它包含不满足给定的查找参数的对象。功能与filter相反。 3、values(*fields) 返回一个新的QuerySet，但迭代时返回字典而不是模型实例对象。 *fields表示需要取哪些字段，空表示取所有字段。 >>> q=Author.objects.values("id") >>> q [{'id': 1}, {'id': 2}, {'id': 3}, {'id': 4}, {'id': 18}, {'id': 22}, {'id': 24}] 4、values_list(*fields, flat=False) 返回一个新的QuerySet，但迭代时返回元组而不是模型实例对象。 *fields表示需要取哪些字段，空表示取所有字段。flat=True表示返回的结果为单个值而不是元组，多个字段时不能使用flat。 >>> q=Author.objects.values_list("id") >>> q [(1,), (2,), (3,), (4,), (18,), (22,), (24,)] >>> q=Author.objects.values_list("id",flat=True) >>> q [1, 2, 3, 4, 18, 22, 24] 5、all() 返回当前 QuerySet所有对象。 6、select_related(*field) 返回一个QuerySet，使用JOIN语句连表查询。它会在执行查询时自动跟踪外键关系，一次读取所有外键关联的字段，并尽可能地深入遍历外键连接，以减少数据库的查询。但数据关系链复杂的查询需要慎用。仅对外键生效。 7、prefetch_related(*field) prefetch_related()的解决方法是，分别查询每个表，然后用Python处理他们之间的关系。外键和多对多都生效。 8、order_by(*fields) 排序，返回一个新的QuerySet，隐式的是升序排序，-name表示根据name降序 >>> q=Author.objects.order_by("name") >>> q [<Author: au>, <Author: 宋清风>, <Author: 猴王>, <Author: 美猴王>, <Author: 苍松>, <Author: 赵清风>, <Author: 陶渊明>] >>> q=Author.objects.order_by("-name") >>> q [<Author: 陶渊明>, <Author: 赵清风>, <Author: 苍松>, <Author: 美猴王>, <Author: 猴王>, <Author: 宋清风>, <Author: au>] 9、reverse() reverse()方法返回反向排序的QuerySet。 必须对一个已经排序过的queryset(也就是q.ordered=True)执行reverse()才有效果。 10、distinct([*fields]) 去重复。返回一个在SQL 查询中使用SELECT DISTINCT 的新QuerySet。
1、dates(field, kind, order='ASC') field 是你的 model 中的 DateField 字段名称。 kind 是 “year”, “month” 或 “day” 之一。 每个 datetime.date对象都会根据所给的 type 进行截减。 “year” 返回所有时间值中非重复的年分列表。 “month” 返回所有时间值中非重复的年／月列表。 “day” 返回所有时间值中非重复的年／月／日列表。 order, 默认是 ‘ASC’，只有两个取值 ‘ASC’ 或 ‘DESC’。它决定结果如何排序。 2、datetimes(field, kind, order=’ASC’) 返回一个 DateTimeQuerySet，参数与dates类似，多了"hour", "minute" ,"second" 3、none() 返回一个 EmptyQuerySet，它是一个运行时只返回空列表的 QuerySet。它经常用在这种场合：你要返回一个空列表，但是调用者却需要接收一个 QuerySet 对象。 4、defer(*fields) 将不想载入的字段的名称传给 defer() 方法，就可以做到延后载入。 在某些数据复杂的环境下，你的 model 可能包含非常多的字段，可能某些字段包含非常多的数据(比如，文档字段)，或者将其转化为Python对象会消耗非常多的资源。在这种情况下，有时你可能并不需要这种字段的信息，那么你可以让 Django 不读取它们的数据。 5、only(*fields) only() 方法或多或少与 defer() 的作用相反。如果你在提取数据时希望某个字段不应该被延后载入，而应该立即载入，那么你就可以做使用 only()方法。 6、多数据库切换using(alias) 单独使用无意义，配合其他查询集方法一起使用。 Author.objects.using('backup') 7、表锁定select_for_update(nowait=False) 单独使用无意义，配合其他查询集方法一起使用。 返回queryset，并将需要更新的行锁定，类似于SELECT … FOR UPDATE的操作。 entries = Entry.objects.select_for_update().filter(author=request.user) 所有匹配的entries都会被锁定直到此次事务结束。
特别的：QuerySet可以使用切片限制查询集。
切片后依旧获得QuerySet，并且不会触发数据库查询。 >>> a=Author.objects.all()[0:2] >>> type(a) <class 'django.db.models.query.QuerySet'> 设置步长值后，获得到List类型值。触发数据库查询 >>> a=Author.objects.all()[::2] >>> type(a) <type 'list'> 使用索引，数据对象，触发数据库查询 >>> Author.objects.all()[0] #等价于Author.objects.all()[0:1].get()
<Author: 苍松>
查看QuerySet的原始SQL语句
关于查看QuerySet的原始SQL语句，使用查询集的query对象。 >>> q=Author.objects.all() >>> print q.query SELECT "otest_author"."id", "otest_author"."name" FROM "otest_author"
c、查询条件（双下划线）
所有使用查询条件的查询和查询集过滤的方法(get,get_or_create,filter,exclude等)都可以使用双下划线组合出更复杂的查询条件。
另一种使用双下划线的情况就是跨表条件查询单情况，见下一节关联字段中跨表查询。
查询条件格式 field__条件类型，例如a=Author.objects.get(id__exact=1) 默认为精确匹配 例如：Author.objects.get(id=1)等价于Author.objects.get(id__exact=1) 一、精确匹配 exact 精确匹配: Blog.objects.get(id__exact=1) iexact 忽略大小写的精确匹配，Blog.objects.filter(name__iexact='blog7') 二、模糊匹配 （模糊匹配，仅PostgreSQL 和 MySQL支持. SQLite的LIKE 语句不支持大小写敏感特性，因此模糊匹配对于 SQLite无法对大敏感） contains 大小写敏感的内容包含测试:Blog.objects.filter(name__contains='blog7') icontains 大小写不敏感的内容包含测试: startswith 大小写敏感的内容开头 Blog.objects.filter(name__startswith="blog") endswith 大小写敏感的内容结尾 endswith. istartswith 大小写不敏感的内容开头 startswith. iendswith 大小写不敏感的内容结尾 endswith. 三、正则匹配 regex 大小写敏感的正则表达式匹配。 它要求数据库支持正则表达式语法，而 SQLite 却没有内建正则表达式支持，因此 SQLite 的这个特性是由一个名为 REGEXP 的 Python 方法实现的，所以要用到 Python 的正则库 re. Entry.objects.get(title__regex=r'^(An?|The) +') 等价于 SQL： SELECT ... WHERE title REGEXP BINARY '^(An?|The) +'; -- MySQL SELECT ... WHERE REGEXP_LIKE(title, '^(an?|the) +', 'c'); -- Oracle SELECT ... WHERE title ~ '^(An?|The) +'; -- PostgreSQL SELECT ... WHERE title REGEXP '^(An?|The) +'; -- SQLite iregex 忽略大小写的正则表达式匹配。 四、范围匹配 gt 大于: Blog.objects.filter(id__gt=3) gte 大于等于. lt 小于. lte 小于等于. ne 不等于. in 位于给定列表中: Blog.objects.filter(id__in=[1,3,5]) range 范围测试: Blog.objects.filter(name__range=('blog1','blog5')) 日期匹配： year 对 date/datetime 字段, 进行精确的 年 匹配:Polls.objects.filter(pub_date__year=2005). month day hour minute second 空值匹配 isnull True/False; 做 IF NULL/IF NOT NULL 查询:Blog.objects.filter(name__isnull=True)
d、 复杂查询条件，使用Q 对象进行复杂的查询
filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。
Q对象有两种使用方式，一种使用Tree模式。另一种是使用"|"和"&"符号进行与或操作。 Q构建搜索条件 from django.db.models import Q con = Q() q1 = Q() q1.connector = 'OR' q1.children.append(('id', 1)) q1.children.append(('id', 2)) #等价于Q(id=1) | Q(id=2) q2 = Q() q2.connector = 'AND' q2.children.append(('id', 1)) q2.children.append(('name__startswith', 'a')) #等价于Q(id=1) | Q(name__startswith='a') con.add(q1, 'AND') con.add(q2, 'AND') Q搜索可以和普通查询参数一起使用，但查询参数需要在最后。 Author.objects.filter(q1,id=26)
2.2关联字段CURD操作（一对一，一对多，多对多表关系操作）
一对一和多对多的表关系的增删改查 a1 = Author.objects.get(name="猴子") a2 = Author.objects.get(name="苍松") a3 = Author.objects.get(name="鲁迅") p1=Publisher.objects.get(name="机械出版社") p2=Publisher.objects.get(name="av") ==============正向关系操作=================================================== 增 b1=Book(title="红楼梦",price=10) b1.publisher=p1或者b1.publisher_id=1 #一对多 b1.save() 先保存book对象之后才能添加多对多关系 b1.authors.add(a1,a2)或者b1.authors=[a1,a2] #多对多 b1.save() 删 b1.publisher=None或者b1.publisher_id=None #一对多 b1.authors.remove(a1,a2) 实际上是删除关系表otest_book_authors中的一条数据 #多对多 b1.authors.clear() 清空所有关系 #多对多 查询
Book.objects.filter(publisher__name=u"机械出版社") #一对多，使用双下划线
Book.objects.filter(authors__name=u"苍松") #多对多，使用双下划线
获取字段值对象 b2.publisher #一对多，对象下面的字段值继续使用.获取。例如b2.publisher.name b1.authors.all() #多对多 ==============反向关系操作=================================================== 增 p1.book_set.add(b1) #一对多，会更新现有的关系。（一个对象只能有一个外键） a3.book_set.add(b1) #多对多 删 p1.book_set.remove(b1) #一对多 a3.book_set.remove(b1) #多对多 a3.book_set.clear() #多对多，清空所有关系 获取字段值对象 a2.book_set.all() #多对多 p1.book_set.all() #一对多 =============自定义中介模型方法=================================================== 中介模型add、create 、remove方法不可用。但是clear() 方法却是可用的，它可以清空某个实例所有的多对多关系。
三、使用原始SQL语句
Django提供两种方法使用原始SQL进行查询：一种是使用Manager.raw()方法，进行原始查询并返回模型实例；另一种直接执行自定义的SQL语句。
1、使用Manager.raw()方法
Manager.raw(raw_query, params=None, translations=None) raw_query SQL查询语句。 params 查询条件参数，是list或者dict translations 字段映射表，是一个dict。 Manager.raw()将查询结果映射到类字段，默认情况下映射到同名字段。返回结果是一个RawQuerySet。
如果在其他的表中有一些Author数据，你可以很容易地把它们映射成Author实例。
手动指定字段映射字典。 方法一：使用AS，其他字段自动应设至Author表中的同名字段。 na=Author.objects.raw("select name AS newname, id from otest_author") >>> na[0] <Author_Deferred_name: 苍松> . 方法二：使用translations name_map={"name":"newname} na=Author.objects.raw("select * from otest_author",translations=name_map) params参数防止SQL注入 方法一：使用list >>> na=Author.objects.raw("select * from otest_author where id =%s",[id]) >>> na[0] <Author: 苍松> 方法二：使用dict 注意：SQLite后端不支持字典，你必须以列表的形式传递参数。 字典使用%(key)s占位符（key替换成字典中相应的key值） p_dict={"id":1} na=Author.objects.raw("select * from otest_author where id =%(id)s",p_dict)
2.直接执行自定义的SQL
有时Manager.raw()方法并不十分好用，你不需要将查询结果映射成模型，或者你需要执行UPDATE、 INSERT以及DELETE查询。
#单数据库 from django.db import connection def my_custom_sql(self): cursor = connection.cursor() cursor.execute("UPDATE bar SET foo = 1 WHERE baz = %s", [self.baz]) cursor.execute("SELECT foo FROM bar WHERE baz = %s", [self.baz]) row = cursor.fetchone()
connection.close() return row #多数据库 from django.db import connections cursor = connections['my_db_alias'].cursor() # Your code here... 默认情况下，Python DB API会返回不带字段的结果，这意味着你得到的是一个列表，而不是一个字典。 def dictfetchall(cursor): "Returns all rows from a cursor as a dict" desc = cursor.description return [ dict(zip([col[0] for col in desc], row)) for row in cursor.fetchall() ] >>> cursor.execute("SELECT id, parent_id FROM test LIMIT 2"); >>> cursor.fetchall() ((54360982L, None), (54360880L, None)) >>> cursor.execute("SELECT id, parent_id FROM test LIMIT 2"); >>> dictfetchall(cursor) [{'parent_id': None, 'id': 54360982L}, {'parent_id': None, 'id': 54360880L}]
四、分组和聚合
Avg 平均值 Count(expression, distinct=False） 计算个数。如果distinct=True，Count将只计算唯一的值。默认值为False。 Max 最大值 Min 最小值 Sum 求和
方法一：使用annotate方法，先分组(group by)再聚合 from django.db.models import Count, Min, Max, Sum,Avg >>> Book.objects.values('publisher').annotate(counts_num=Count("*")) [{'publisher': 1, 'counts_num': 2}, {'publisher': 3, 'counts_num': 1}] >>> Book.objects.values('publisher').annotate(Avg("price")) [{'publisher': 1, 'price__avg': 12.5}, {'publisher': 3, 'price__avg': 11.0}] #得到分组的多个值列表 使用values('publisher')进行group by分组后，在使用聚合函数才有意义。 默认聚合名称filedname__聚合函数名,作为聚合字段名。 方法二：使用aggregate方法，先过滤再聚合 Book.objects.filter(publisher_id=1).aggregate(Count("id")) {'id__count': 2} #得到单个值
参考文档：
http://python.usyiyi.cn/django/index.html中文翻译1.8.2版中文不好的同学可以看这个
