一、创建模型
实例:
作者模型:一个作者有姓名和年龄
作者详细模型:把作者的详情放到详情表,包含生日,手机号,家庭住址等信息。作者详情模型和作者模型之间是一对一的关系(one-to-one)
出版商模型:出版商有名称,所在城市以及email。
书籍模型: 书籍有书名和出版日期,一本书可能会有多个作者,一个作者也可以写多本书,所以作者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版,所以出版商和书籍是一对多关联关系(one-to-many)。
模型建立如下:
class Book(models.Model):
id = models.AutoField(primary_key=True)
title = models.CharField(max_length=32)
publishDate = models.DateField()
price = models.DecimalField(max_digits=5, decimal_places=2)
# 与Publish建立一对多的关系,外键字段建立在多的一方
publish = models.ForeignKey(to="Publish", to_field="id", on_delete=models.CASCADE)
# 与Author建立多对多的关系,ManyTOManyField可以建在两个模型中的任意一个,自动创建第三张表
authors = models.ManyToManyField(to='Author',)
class Author(models.Model):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
age = models.IntegerField()
# 与AuthorDetail建立一对一的关系
authorDetail = models.OneToOneField(to="AuthorDetail", on_delete=models.CASCADE)
class Publish(models.Model):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
city = models.CharField(max_length=32)
email = models.EmailField()
class AuthorDetail(models.Model):
id = models.AutoField(primary_key=True)
birthday = models.DateField()
telephone = models.BigIntegerField()
addr = models.CharField(max_length=64)
生成表如下:
注意事项:
- 表的名称
myapp_modelName
,是根据 模型中的元数据自动生成的,也可以覆写为别的名称 id
字段是自动添加的- 对于外键字段,Django 会在字段名上添加"_id" 来创建数据库中的列名
- 这个例子中的
CREATE TABLE
SQL 语句使用PostgreSQL 语法格式,要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。 - 定义好模型之后,你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置,在其中添加
models.py
所在应用的名称。 - 外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL),你可以赋给它空值 None 。
字段选项
每个字段有一些特有的参数,例如,CharField需要max_length参数来指定VARCHAR
数据库字段的大小。还有一些适用于所有字段的通用参数。 这些参数在文档中有详细定义,这里我们只简单介绍一些最常用的:
1)null
如果为True,Django 将用NULL 来在数据库中存储空值。 默认值是 False.
(1)blank
如果为True,该字段允许不填。默认为False。
要注意,这与 null 不同。null纯粹是数据库范畴的,而 blank 是数据验证范畴的。
如果一个字段的blank=True,表单的验证将允许该字段是空值。如果字段的blank=False,该字段就是必填的。
(2)default
字段的默认值。可以是一个值或者可调用对象。如果可调用 ,每有新对象被创建它都会被调用。
(3)primary_key
如果为True,那么这个字段就是模型的主键。如果你没有指定任何一个字段的primary_key=True,
Django 就会自动添加一个IntegerField字段做为主键,所以除非你想覆盖默认的主键行为,
否则没必要设置任何一个字段的primary_key=True。
(4)unique
如果该值设置为 True, 这个数据字段的值在整张表中必须是唯一的
(5)choices
由二元组组成的一个可迭代对象(例如,列表或元组),用来给字段提供选择项。 如果设置了choices ,
默认的表单将是一个选择框而不是标准的文本框,而且这个选择框的选项就是choices 中的选项。
这是一个关于 choices 列表的例子:
YEAR_IN_SCHOOL_CHOICES = (
('FR', 'Freshman'),
('SO', 'Sophomore'),
('JR', 'Junior'),
('SR', 'Senior'),
('GR', 'Graduate'),
)
每个元组中的第一个元素,是存储在数据库中的值;第二个元素是在管理界面或 ModelChoiceField 中用作显示的内容。
在一个给定的 model 类的实例中,想得到某个 choices 字段的显示值,就调用 get_FOO_display 方法(这里的 FOO 就是 choices 字段的名称 )。例如:
from django.db import models
class Person(models.Model):
SHIRT_SIZES = (
('S', 'Small'),
('M', 'Medium'),
('L', 'Large'),
)
name = models.CharField(max_length=60)
shirt_size = models.CharField(max_length=1, choices=SHIRT_SIZES)
>>> p = Person(name="Fred Flintstone", shirt_size="L")
>>> p.save()
>>> p.shirt_size
'L'
>>> p.get_shirt_size_display()
'Large
二、添加表记录
一对多
# 方式一:
publish_obj = models.Publish.objects.get(id=1)
book_obj = models.Book.objects.create(title="性能测试案例分析", publishDate="2010-12-12", price=100, publish=publish_obj)
print(book_obj)
# 方式二:
models.Book.objects.create(title="Python全栈开发", publishDate="2015-05-05", price="150", publish_id=2)
# 方式三:
publish_obj = models.Publish.objects.get(name="邮电出版社")
book_obj = models.Book(title="未来简史", publishDate="2010-10-10", price=200, publish=publish_obj)
book_obj.save()
多对多添加记录:
书和作者是多对多的关系:一个书可以有多个作者,一个作者可以出版多本书
步骤:先找到书对象
再找到需要的作者对象
给书对象绑定作者对象(用add方法),也就是绑定多对多的关系
# --------------多对多添加--------------
# 方式一:
authordetail_obj = models.AuthorDetail.objects.create(birthday="2012-08-12", telephone="15912245678",addr="北京")
print(authordetail_obj)
author_obj = models.Author.objects.create(name="jacke", age=30, authorDetail_id=3)
print(author_obj)
pub_obj=models.Publish.objects.filter(name="机械工业出版社").first()
book_obj = models.Book.objects.create(title="人类简史",publishDate="2008-10-8", price="122", publish=pub_obj)
# 通过作者的名字django默认找到id
author_obj = models.Author.objects.filter(name="mike")[0]
tom_obj = models.Author.objects.filter(name="tom")[0]
jack_obj = models.Author.objects.filter(name="jacke")[0]
book_obj.authors.add(author_obj, tom_obj, jack_obj)
# 方式二:查出所有的作者
pub_obj = models.Publish.objects.filter(name="邮电出版社").first()
book_obj = models.Book.objects.create(title="零成本实现性能测试", publishDate="2018-08-08", price="225", publish=pub_obj)
author_obj = models.Author.objects.all()
# 绑定多对多关系
book_obj.authors.add(*author_obj)
解除绑定:remove:
# 将某个特定的对象从被关联对象集合中去除。
====== book_obj.authors.remove(*[])
# 解除多对多的关系(remove)
book_obj = models.Book.objects.filter(title="零成本实现性能测试").last() # 找到书对象
author_obj = models.Author.objects.filter(id__lt=3) # 找到符合条件的作者对象
book_obj.authors.remove(*author_obj) # 因为清除是多条,得加*
清除绑定:clear
#清空被关联对象集合。
# 清除关系方法(clear)
book_obj = models.Book.objects.filter(title="人类简史")
for book_obj_item in book_obj:
book_obj_item.authors.clear()
总结:remove和clear的区别
remove:得吧你要清除的数据筛选出来,然后移除
clear:不用查,直接就把数据都清空了。
各有应用场景
三、基于对象的跨表查询(相当于sql语句的where子查询)
一对一查询记录:author和authordetail是一对一的关系
正向查询(按字段author)
反向查询(按表名authordetail):因为是一对一的关系了,就不用set了
# 一对一的查询
# 正向查询:手机好为15812345678的作者的姓名
deital_obj = models.AuthorDetail.objects.filter(telephone="15812345678").first()
print(deital_obj.author.name)
# 反向查询:查询mike的手机号
mike_obj = models.Author.objects.filter(name="mike").first()
print(mike_obj.authorDetail.telephone)
一对多查询记录:
正向查询(按字段:publish):
反向查询(按表名:book_set):
# 一对多查询
# 正向查询:查询“零成本实现性能测试”这本书的出版社的地址
book_obj = models.Book.objects.filter(title="零成本实现性能测试")[0] # 找对象
print(book_obj.publish) # 拿到的是关联出版社的对象
print(book_obj.publish.city)
# 反向查询:查询邮电出版社出版过的所有书的价格和名字
pub_obj = models.Publish.objects.filter(name="邮电出版社")[0]
book_dic = pub_obj.book_set.all().values("price", "title")[0]
print(book_dic)
print(book_dic["price"])
# 查询邮电出版社出版过的所有书籍
publish = models.Publish.objects.get(name="邮电出版社") # get得到的直接是一个对象,不过get只能查看有一条记录
book_list = publish.book_set.all() # 与邮电出版社关联的所有书籍对象集合
for book_obj in book_list:
print(book_obj.title)
多对多查询记录:
正向查询(按字段:authors)
反向查询(按表名:book_set)
# 多对多查询
# 正向查询:查询“人类简史”的这本书的所有作者的姓名和年龄
book_obj = models.Book.objects.filter(title="人类简史").first()
auth_list = book_obj.authors.all()
for auth_obj in auth_list:
print(auth_obj.name, auth_obj.age)
# 反向查询:查询作者是Mike的这个人出了哪几本书的信息
mike_obj = models.Author.objects.filter(name="mike").first()
print(mike_obj.book_set.all().first().title) # 与该作者关联的所有书对象的集合
可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如,如果 Article model 中做一下更改:
publish = ForeignKey(Blog, related_name='bookList')
那么接下来就会如我们看到这般:
publish = models.Publish.objects.get(name="邮电出版社")
book_list=publish.bookList.all() # 与人民出版社关联的所有书籍对象集合
print(book_list)
四、基于双下划线的跨表查询
Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系,它能自动确认 SQL JOIN 联系。要做跨关系查询,就使用两个下划线来链接模型(model)间关联字段的名称,直到最终链接到你想要的 model 为止。(相当于用sql语句用join连接的方式,可以在settings里面设置,可查看sql语句)
一对多查询:
正向查询:按字段:publish
反向查询:按表名:book
练习1、查询邮电出版社出版过的所有的书的价格和名称
# 第一种方法
ret = models.Publish.objects.filter(name="机械工业出版社").values("book__price", "book__title")
print(ret)
# 第二种方法
ret2 = models.Book.objects.filter(publish__name="邮电出版社").values("price", "title")
print(ret2)
# 查询某出版社出版过的所有的书籍
ret2 = models.Book.objects.filter(publish__name="邮电出版社").all()
练习2、查询“人类简史”这本书的出版社的地址:filter先过滤,values显示要求的字段
# 练习2、查询“人类简史”这本书的出版社的地址:filter先过滤,values显示要求的字段
# 第一种方式
ret = models.Book.objects.filter(title="人类简史").values("publish__city")
print(ret)
# 第二种方式
ret2 = models.Publish.objects.filter(book__title="人类简史").values("city")
print(ret2)
多对多查询
正向查询:按字段authors
反向查询:按表名:book
# 练习1、查询mike出过的所有书的名字
# 方式一
ret = models.Author.objects.filter(name="mike").values("book__title")
print(ret)
# 方式二
ret2 = models.Book.objects.filter(authors__name="mike").values("title")
print(ret2)
# 练习2、查询手机号以158开头的作者出版过的所有书的名称以及出版社的名称
# 方式一
ret = models.AuthorDetail.objects.filter(telephone__startswith="158").first()
print(ret.author.book_set.all().values("title", "publish__name"))
print(ret)
# 方式二
ret = models.Book.objects.filter(authors__authorDetail__telephone__regex="158").values("title", "publish__name")
print(ret)
连续跨表查询:
# 练习3、查询邮电出版社出版过的所有书籍的名字以及作者的姓名
# 正向查询
ret = models.Book.objects.filter(publish__name='邮电出版社').values_list("title", "authors__name")
print(ret)
# 反向查询
ret = models.Publish.objects.filter(name="邮电出版社").values_list("book__title", "book__authors__age", "book__authors__name")
print(ret)
related_name
反向查询时,如果定义了related_name,则用reated_name替换表名,例如:
publish = ForeignKey(Blog, related_name='bookList')
# 练习: 查询人民出版社出版过的所有书籍的名字与价格(一对多)
# 反向查询 不再按表名:book,而是related_name:bookList
queryResult=Publish.objects
.filter(name="人民出版社")
.values_list("bookList__title","bookList__price")
五、聚合查询与分组查询
聚合:
aggregate(*args,**kwargs):只对一个组进行聚合
# 计算所有图书的平均价格
price_avg = models.Book.objects.all().aggregate(Avg('price'))
print(price_avg)
aggregate()是QuerySet 的一个终止子句,意思是说,它返回一个包含一些键值对的字典。键的名称是聚合值的标识符,值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定一个名称,可以向聚合子句提供它。
print(models.Book.objects.aggregate(average_price=Avg('price')))
{'average_price': 174.625}
如果你希望生成不止一个聚合,你可以向aggregate()子句中添加另一个参数。所以,如果你也想知道所有图书价格的最大值和最小值,可以这样查询:
print(models.Book.objects.aggregate(Avg('price'), Max('price'), Min('price')))
{'price__avg': 174.625, 'price__max': Decimal('225'), 'price__min': Decimal('100')}
分组:
##################### 单表分组查询 ############################
查询一个部门名称以及对应的员工数
sql语句:
select dep,Count(*) from emp group by dep;
ORM:
emp.objects.values("dep").annotate(c=Count("id")
##################### 多表分组查询 ############################
emp:
id name age salary dep_id
1 alex 12 2000 1
2 egon 22 3000 2
3 wen 22 5000 2
dep
id name
1 销售部
2 人事部
emp-dep:
id name age salary dep_id id name
1 alex 12 2000 1 1 销售部
2 egon 22 3000 2 2 人事部
3 wen 22 5000 2 2 人事部
sql语句:
select dep.name,Count(*) from emp left join dep on emp.dep_id=dep.id group by dep.id
ORM:
dep.objects.values("id").annotate(c=Count("emp")).values("name", "c")
annotate()为调用的QuerySet中每一个对象都生成一个独立的统计值(统计方法用聚合函数)。
总结 :跨表分组查询本质就是将关联表join成一张表,再按单表的思路进行分组查询。
查询练习:
(1) 练习:统计每一个出版社的最便宜的书
# 方式一
print(models.Book.objects.values("publish__name").annotate(MinPrice=Min('price'))) # 注意:values内的字段即group by字段,也就是分组
# 方式二
print(models.Publish.objects.all().annotate(minprice=Min("book__price")).values("name", "minprice"))
# 方式三
publish_list = models.Publish.objects.annotate(MinPrice=Min("book__price"))
for publish_obj in publish_list:
print(publish_obj.name, publish_obj.MinPrice)
(2) 练习:统计每一本书的作者个数
# 方式一
author_list = models.Book.objects.all().annotate(Count_author=Count("authors__name")).values("Count_author")
print(author_list)
# 方式二
book_list = models.Book.objects.all().annotate(authorNum=Count("authors__name"))
for book_obj in book_list:
print(book_obj.title, book_obj.authorNum)
(3) 统计每一本以py开头的书籍的作者个数
# (3) 统计每一本以py开头的书籍的作者个数:
book_list = models.Book.objects.all().filter(title__startswith="Py").annotate(authorNum=Count("authors__name"))
for book_obj in book_list:
print(book_obj.title, book_obj.authorNum)
(4) 统计不止一个作者的图书
author_obj = models.Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__gt=1)
print(author_obj)
(5) 根据一本图书作者数量的多少对查询集 QuerySet进行排序:
author_boj = models.Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors')
print(author_boj)
(6) 查询各个作者出的书的总价格:
ret = models.Author.objects.annotate(SumPrice=Sum("book__price")).values_list("name", "SumPrice")
print(ret)
六、F查询和Q查询
F查询
在上面所有的例子中,我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较,那该怎么做呢?
Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段,来比较同一个 model 实例中两个不同字段的值。
1、查看评论数大于阅读数的书
from django.db.models import F,Q
print(models.Book.objects.filter(commentNum__gt=F("readNum")))
2、修改操作也可以使用F函数,比如将id大于1的所有的书的价格涨价100元
print(models.Book.objects.filter(id__gt=1).update(price=F("price")+100))
3、Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作
# 查询评论数大于收藏数2倍的书籍
models.Book.objects.filter(commentNum__lt=F('keepNum')*2
Q查询:
filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询(例如OR 语句),你可以使用Q 对象。
1、查询id大于1并且评论数大于100的书
print(models.Book.objects.filter(nid__gt=1,commentNum__gt=100))
print(models.Book.objects.filter(nid__gt=1).filter(commentNum__gt=100))
print(models.Book.objects.filter(Q(nid__gt=1)&Q(commentNum__gt=100)))
2、查询评论数大于100或者阅读数小于200的书
print(models.Book.objects.filter(Q(commentNum__gt=100)|Q(readNum__lt=200)))
Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时,它产生一个新的Q 对象。
3、查询年份等于2017年或者价格大于200的书
print(models.Book.objects.filter(Q(publishDate__year=2017)|Q(price__gt=200)))
4、查询年份不是2017年或者价格大于200的书
print(models.Book.objects.filter(~Q(publishDate__year=2017)&Q(price__gt=200)))
注意:
查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数(关键字参数或Q 对象)都将"AND”在一起。但是,如果出现Q 对象,它必须位于所有关键字参数的前面。例如:
bookList=models.Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017), title__icontains="python" )