models
单表查询
增的两种方式
第一种方式
models.User.objects.create(name='json',age=15,register_time='2014-5-6')
# 第二种方式
res=models.User(name='zc',age=18,register_time='2015-5-6')
res.save()
删除
res = models.User.objects.filter(pk=1).delete()
print(res)
修改：
第一种
models.User.objects.filter(pk=3).update(name='zc好帅')
第二种
res = models.User.objects.filter(pk=3)
res.name = 'zzz'
res.save()
常见的查询方式
| 方法 | 描述 |
|---|---|
| 1. all() | 查询所有数据 |
| 2. filter() | 带有过滤条件的查询 |
| 3. get() | 直接拿数据对象 但是条件不存在直接报错 |
| 4. first() | 拿queryset里面第一个元素 |
| 5. last() | 拿queryset里面最后一个元素 |
| 6. values() | 可以指定获取的数据字段 |
| 7.values_list() | 可以指定获取的数据字段，列表套元祖 |
| 8. distinct() | 去重 |
| 9 .order_by() | 默认升序 |
| 10.reverse() | 反转的前提是 数据已经排过序了 |
| 11.count() | 统计当前数据的个数 |
| 12.exclude() | 排除在外 |
| 13.exists() | 是否存在，返回的是布尔值 |
1. res=models.User.objects.all()
print(res)
2. res = models.User.objects.filter(pk=2)
print(res) # <QuerySet [<User: zc好帅>]>
3. res = models.User.objects.get(pk=5)
print(res)
4. res = models.User.objects.all().first()
print(res) # zc好帅
5. res = models.User.objects.all().last()
print(res)
6. res = models.User.objects.values('name','age')
print(res)
#<QuerySet [{'name': 'zc好帅', 'age': 15}, {'name': 'zc好帅', 'age': 15}, {'name': 'json', 'age': 15}, {'name': 'zc', 'age': 18}]>
7. res = models.User.objects.values_list('name','age')
print(res) # <QuerySet [('zc好帅', 15), ('zc好帅', 15), ('json', 15), ('zc', 18)]>
8. res = models.User.objects.values('name','age').distinct()
print(res)
# <QuerySet [{'name': 'zc好帅', 'age': 15}, {'name': 'json', 'age': 15}, {'name': 'zc', 'age': 18}]>
9. res = models.User.objects.order_by('age')
print(res) # <QuerySet [<User: zc好帅>, <User: zc好帅>, <User: json>, <User: zc>]>
11. res = models.User.objects.count()
print(res) # 4
12. es = models.User.objects.exclude(name='zc好帅')
print(res) # <QuerySet [<User: json>, <User: zc>]>
13. res = models.User.objects.filter(pk=3).exists()
print(res) # True
双下划线查询
| 方法 | 描述 |
|---|---|
| age__gt | 大于 |
| age__lt | 小于 |
| age__gte | 大于等于 |
| age__lte | 小于等于 |
| age__in=[] | 或者（[12,14,15]） |
| age__range=[] | 首尾都要 从那个元素到哪个元素 |
| name__contains='s' | 模糊查询 |
| name__icontains='p' | 忽略大小写 |
| (register_time__month='1' | 查询出时间 |
一对多外键的操作
增加
models.Book.objects.create(title='十万个为什么？',price=251.24,publish_id=3)
删除
models.Publish.objects.filter(pk=1).delete()(联级删除)
修改
models.Book.objects.filter(pk=2).update(publish_id=2)
多对多外键的操作
book_obj = models.Book.objects.filter(pk=9).first()
增加
方式一
book_obj.authors.add(1)
方式二：
author_obj1 = models.Author.objects.filter(pk=1).first()
author_obj2 = models.Author.objects.filter(pk=3).first()
book_obj.authors.add(author_obj1,author_obj2)
删除：
方式一
book_obj.authors.remove(1)
方式二：
author_obj = models.Author.objects.filter(pk=3).first()
book_obj.authors.remove(author_obj)
修改：
方式一
book_obj.authors.set([3]) # 括号内必须给一个可迭代对象
方式二：
author_obj = models.Author.objects.filter(pk=1).first()
book_obj.authors.set([author_obj])
book_obj.authors.clear() # 在第三张关系表中清空某个书籍与作者的绑定关系
"""
括号内必须传一个可迭代对象，该对象内既可以数字也可以对象 并且都支持多个
"""
多表查询
子查询
# 查询书籍主键为9的出版社
book1 = models.Book.objects.filter(pk=9).first()
res = book1.publish
print(res)
# 查询书籍主键为9的作者
book_obj = models.Book.objects.filter(pk=11).first()
res = book_obj.authors
print(res)
# 查询作者张晨的地址
author_obj = models.Author.objects.filter(name='张晨').first()
res = author_obj.author_detail
print(res.addr)
# 查询出版社是东方出版社的书
res = models.Book.objects.filter(publish_id=3)
print(res)
publish_obj = models.Publish.objects.filter(name='北方出版社').first()
res = publish_obj.book_set.all()
print(res)
# 查询作者张晨写过的书
author_obj = models.Author.objects.filter(name='张晨').first()
print(author_obj.book_set.all())
# 查询手机号是110的作者的名字
a=models.AuthorDetail.objects.filter(phone=3551).first()
res=a.author
print(res)
连表查询
# 1.查询jason的手机号和作者姓名
# res = models.Author.objects.filter(name='jason').values('author_detail__phone','name')
# print(res)
# 反向
# res = models.AuthorDetail.objects.filter(author__name='jason') # 拿作者姓名是jason的作者详情
# res = models.AuthorDetail.objects.filter(author__name='jason').values('phone','author__name')
# print(res)
# 2.查询书籍主键为1的出版社名称和书的名称
# res = models.Book.objects.filter(pk=1).values('title','publish__name')
# print(res)
# 反向
# res = models.Publish.objects.filter(book__id=1).values('name','book__title')
# print(res)
# 3.查询书籍主键为1的作者姓名
# res = models.Book.objects.filter(pk=1).values('authors__name')
# print(res)
# 反向
# res = models.Author.objects.filter(book__id=1).values('name')
# print(res)
# 查询书籍主键是1的作者的手机号
# book author authordetail
# res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
# print(res)
"""
聚合查询和分组查询
聚合函数：聚合函数通常和分组查询在一起使用，只要和数据库有关的函数都在django.db.models里面，上面的没有一般都在django.db里面
# 所有书的平均价格
res = models.Book.objects.aggregate(Avg('price'))
print(res)
re =models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('price'))
print(re)
分组查询：分组之后只能获取到分组的依据，区内其他字段都无法直接获取
统计每一本书的作者的个数
res= models.Book.objects.annotate(author_num=Count('authors')).values('title','author_num')
print(res)
# author_num是我们自己定义的字段 用来存储统计出来的每本书对应的作者个数
统计每个出版社买的最便宜的书的价格
res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
print(res)
统计不止一个作者的图书
"""
1. 先按照图书分组，求每一本书对应的作者的个数
2. 过滤出不止一个作者的图书
"""
res1 = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title','author_num')
print(res1)
查询出每个作者出书的总价格
res=models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
print(res)
F和Q查询
F查询
1.查询卖出数大于库存数的书籍
"""
能够帮助你直接获取到表中某个字段对应的数据
"""
from django.db.models import F
res = models.Book.objects.filter(maichu__gt=F('kucun'))
print(res)
2.将所有书籍的价格提升500块
models.Book.objects.update(price=F('price') + 500)
3.将所有书的名称后面加上爆款两个字
"""
在操作字符类型的数据的时候 F不能够直接做到字符串的拼接
"""
from django.db.models.functions import Concat
from django.db.models import Value
models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
# models.Book.objects.update(title=F('title') + '爆款') # 所有的名称会全部变成空白
Q查询
1.查询卖出数大于100或者价格小于600的书籍
res = models.Book.objects.filter(maichu__gt=100,price__lt=600)
"""filter括号内多个参数是and关系"""
from django.db.models import Q
res = models.Book.objects.filter(Q(maichu__gt=100),Q(price__lt=600)) # Q包裹逗号分割 还是and关系
res = models.Book.objects.filter(Q(maichu__gt=100)|Q(price__lt=600)) # | or关系
res = models.Book.objects.filter(~Q(maichu__gt=100)|Q(price__lt=600)) # ~ not关系
print(res) # <QuerySet []>
Q的高阶用法 能够将查询条件的左边也变成字符串的形式
q = Q()
q.connector = 'or'
q.children.append(('maichu__gt', 100))
q.children.append(('price__lt', 600))
res = models.Book.objects.filter(q) # 默认还是and关系
事务
from django.db import transaction
try:
with transaction.atomic():
# sql1
# sql2
...
# 在with代码快内书写的所有orm操作都是属于同一个事务
except Exception as e:
print(e)
print('执行其他操作')
ORM常用字段和参数
| 字段 | 参数 |
|---|---|
| AutoField | primary_key=True |
| CharField | verbose_name，max_length |
| IntegerField | int |
| BigIntegerField | bigint |
| DecimalField | max_digits=8，decimal_places=2 |
| EmailFiled | date |
| DateField | auto_now，auto_now_add |
| TextField(Field) | 该字段可以用来存大段内容，文本类型 |
| FileField(Field) | upload_to = "/data"，给该字段传一个文件对象，件保存到/data目录下然后将文件路径保存到数据库中 |
自定义字段
class MyCharField(models.Field):
def __init__(self,max_length,*args,**kwargs):
self.max_length = max_length
# 调用父类的init方法
super().__init__(max_length=max_length,*args,**kwargs) # 一定要是关键字的形式传入
def db_type(self, connection):
"""
返回真正的数据类型及各种约束条件
"""
return 'char(%s)'%self.max_length
# 自定义字段使用
myfield = MyCharField(max_length=16,null=True)
外键字段及参数
unique=True
ForeignKey(unique=True) === OneToOneField()
# 你在用前面字段创建一对一 orm会有一个提示信息 orm推荐你使用后者但是前者也能用
db_index:如果db_index=True 则代表着为此字段设置索引
to_field:设置要关联的表的字段 默认不写关联的就是另外一张的主键字段
on_delete:当删除关联表中的数据时，当前表与其关联的行的行为。
"""
django2.X及以上版本 需要你自己指定外键字段的级联更新级联删除
"""
数据库查询优化
only与defer
获取书籍表中所有数的名字
res = models.Book.objects.values('title')
for d in res:
print(d.get('title'))
你给我实现获取到的是一个数据对象 然后点title就能够拿到书名 并且没有其他字段
res = models.Book.objects.only('title')
res = models.Book.objects.all()
print(res)
for i in res:
print(i.title) # 点击only括号内的字for 段 不会走数据库
print(i.price) # 点击only括号内没有的字段 会重新走数据库查询而all不需要走了
res = models.Book.objects.defer('title') # 对象除了没有title属性之外其他的都有
for i in res:
print(i.price)
"""
defer与only刚好相反
defer括号内放的字段不在查询出来的对象里面 查询该字段需要重新走数据
而如果查询的是非括号内的字段 则不需要走数据库了
"""
select_related与prefetch_related
res = models.Book.objects.all()
for i in res:
print(i.publish.name) # 每循环一次就要走一次数据库查询
res = models.Book.objects.select_related('authors') # INNER JOIN
"""
select_related内部直接先将book与publish连起来 然后一次性将大表里面的所有数据
全部封装给查询出来的对象
这个时候对象无论是点击book表的数据还是publish的数据都无需再走数据库查询了
select_related括号内只能放外键字段 一对多 一对一
多对多也不行
"""
for i in res:
print(i.publish.name) # 每循环一次就要走一次数据库查询
res = models.Book.objects.prefetch_related('publish') # 子查询
"""
prefetch_related该方法内部其实就是子查询
将子查询查询出来的所有结果也给你封装到对象中
给你的感觉好像也是一次性搞定的
"""
for i in res:
print(i.publish.name)
