一 单表操作
0 前期单表准备
##### 1.models.py 定义表 （前期准备：用户表）
class User(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField()
register_time = models.DateField() # 年月日
"""
DateField 与 DateTimeField
两个重要参数 （****** 面试考点）
auto_now:每次操作数据的时候 该字段会自动将当前时间更新
auto_now_add:在创建数据的时候会自动将当前创建时间记录下来 之后只要不人为的修改 那么就一直不变
"""
def __str__(self):
return '对象:%s'%self.name
# 定义表元信息
class Meta:
# 数据库中生成的表名称 默认为：app名称 + 下划线 + 类名
db_table = "table_name"
# 联合索引
index_together = [
("pub_date", "deadline"),
]
# 联合唯一索引
unique_together = (("driver", "restaurant"),)
# admin中显示的表名称
verbose_name = ''
# admin中显示的表名称 加s
verbose_name_plural = ''
##### 2.配置mysql数据库
# 删除\注释掉原来的DATABASES配置项，新增下述配置
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql', # 使用mysql数据库
'NAME': 'db1', # 要连接的数据库
'USER': 'root', # 链接数据库的用于名
'PASSWORD': '', # 链接数据库的用于名
'HOST': '127.0.0.1', # mysql服务监听的ip
'PORT': 3306, # mysql服务监听的端口
'ATOMIC_REQUEST': True, # 设置为True代表同一个http请求所对应的所有sql都放在一个事务中执行
# (要么所有都成功，要么所有都失败)，这是全局性的配置，如果要对某个
# http请求放水（然后自定义事务），可以用non_atomic_requests修饰器
'OPTIONS': {
'init_command': 'SET sql_mode="STRICT_TRANS_TABLES"',
}
}
}
##### 3.替换django默认的mysql处理模块 (pymysql 猴子补丁)
或直接使用mysqlclient模块
# 在任意__init__.py文件中配置 一般是应用下的__init__文件
import pymysql
pymysql.install_as_MySQLdb()
##### 4.数据库迁移
python3 manage.py makemigrations # 将改动记到小本本上(migrations)
python3 manage.py migrate # 真正操作数据库
pycharm快捷方式执行数据库迁移(tools>>>run manage.py task)
##### 5.构建orm测试脚本
# tests.py中 去manage.py中拷贝前四行代码 然后自己写两行
import os
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "d19_dj6.settings")
import django
django.setup()
# 在该代码的下方才可以正常测试django文件
# 写orm语句，操作数据库
from app01 import models
print(models.User.objects.all())
1 数据的增删改查
# django自带的sqlite3数据库对日期格式不是很敏感 处理的时候容易出错
"""
pk：primary key 主键的缩写
会自动查找到当前表的主键字段 指代的就是当前表的主键字段
用了pk之后 你就不需要指代当前表的主键字段到底叫什么了
"""
# 增加（两种方式）
# 第一种：利用 表-类.objects.create()方法创建 models.User.objects.create()
# 时间格式可以自定义字符串书写
res = models.User.objects.create(name='jason',age=18,register_time='2002-1-21')
print(res) # res 是当前 创建model.User的对象本身
# 第二种：实例化 表-类 对象的形式创建 models.User() ； 再 .save() 保存提交
# 时间格式也可以是日期时间对象
import datetime
ctime = datetime.datetime.now()
user_obj = models.User(name='egon',age=84,register_time=ctime)
user_obj.save()
# 删除(两种方式)
# 第一种 将查询的集合，.delete() 全部批量删除
res = models.User.objects.filter(pk=2).delete()
print(res) # 当前删除操作 影响的行数
# 第二种 将查询的集合,取出具体的数据对象，再 对象.delete() 单一删除
user_obj = models.User.objects.filter(pk=1).first()
user_obj.delete()
# 修改 (两种方式)
# 第一种 将查询的集合，.update() 全部批量修改
models.User.objects.filter(pk=4).update(name='egonDSB')
# 第二种 将查询的集合,取出具体的数据对象，再 对象.属性=值 单一修改，最后 对象.save() 保存提交
user_obj = models.User.objects.filter(pk=4).first()
user_obj.name = 'egonPPP'
user_obj.save()
# 查询
# .objects.get() 方法 直接获取数据对象
但是该方法不推荐使用，一旦数据不存在该方法会直接报错！
user_obj = models.User.objects.get(pk=4)
# .objects.filter() 方法 根据查询条件获取查询集合，再.first() 取出具体的数据对象
该方法推荐使用，因为即使数据对象不存在，会返回为空，不会直接报错！
user_obj = models.User.objects.filter(pk=6).first()
2 查询必会13条
# 1.all() 查询所有数据
# 2.filter() 带有过滤条件的查询 返回QuerySet对象 (看做数据对象的集合形式)
括号内可以存放多个条件 默认是and关系
# 3.get() 直接拿数据对象 但是条件不存在直接报错 不推荐使用
# 4.first() 拿queryset里面第一个元素
res = models.User.objects.all().first()
print(res)
# .last() 拿queryset里面最后一个元素
res = models.User.objects.all().last()
print(res)
# 5.values() 可以指定获取的数据字段 相当于：select name,age from ... （******）
res = models.User.objects.values('name','age')
print(res)
# 返回结果（可以看成列表套字典的格式）：<QuerySet [{'name': 'jason', 'age': 18}, {'name': 'egonPPP', 'age': 84}]>
# 6.values_list() 可以指定获取的数据字段 （******）
res = models.User.objects.values_list('name','age')
print(res)
# 返回结果（可以看成列表套元祖的格式）：<QuerySet [('jason', 18), ('egonPPP', 84)]>
# 和.values() 的区别 就是：返回结果形式不一样！
# 7.distinct() 去重
res = models.User.objects.values('name','age').distinct()
print(res)
"""
去重一定要是一模一样的数据
如果带有主键那么肯定不一样 你在往后的查询中一定不要忽略主键
"""
# 8.order_by()
res = models.User.objects.order_by('age') # 默认升序
res = models.User.objects.order_by('-age') # 降序
print(res) # 排序后的queryset
# 9.reverse() 反转的前提是 数据已经排过序了 (order_by())
res = models.User.objects.order_by('age').reverse()
print(res)
# 10.count() 统计当前数据的个数
res = models.User.objects.count()
print(res)
# 11.exclude() 排除在外
res = models.User.objects.exclude(name='jason')
print(res)
# 12.exists() 基本用不到因为数据本身就自带布尔值 返回的是布尔值
res = models.User.objects.filter(pk=10).exists()
print(res)
# 13.create()、update()、delete()、对象.save()
3 神奇的双下划线查询
# 1.年龄大于35岁的数据
res = models.User.objects.filter(age__gt=35)
print(res)
# 2.年龄小于35岁的数据
res = models.User.objects.filter(age__lt=35)
print(res)
# 3.大于等于 小于等于
res = models.User.objects.filter(age__gte=32)
res = models.User.objects.filter(age__lte=32)
print(res)
# 4.年龄是18 或者 32 或者40
res = models.User.objects.filter(age__in=[18,32,40])
print(res)
# 5.年龄在18到40岁之间的 首尾都包括
res = models.User.objects.filter(age__range=[18,40])
print(res)
# 6.查询出名字里面含有s的数据 模糊查询 且区分大小写
res = models.User.objects.filter(name__contains='s')
print(res)
# 7.contains前面加i 忽略大小写
res = models.User.objects.filter(name__icontains='p')
print(res)
# 8.以什么开头
res = models.User.objects.filter(name__startswith='j')
# 9.以什么结尾
res1 = models.User.objects.filter(name__endswith='j')
print(res,res1)
# 10.查询出注册时间是 2020年 1月 (很常用！)
res = models.User.objects.filter(register_time__month='1') # 按照月份
res = models.User.objects.filter(register_time__year='2020') # 按照年份
# 11.时间还支持某个年或月 +范围查询 (很常用！)
res = models.Book.objects.filter(publish_date__year__range=[2000,2014]).all()
res = models.Book.objects.filter(publish_date__year__lte=2014).all()
print(res)
4 批量插入数据
def ab_pc(request):
# 方式一：for循环 创建对象 缺点: IO操作多 每次create都一次IO操作数据库
for i in range(100000):
models.Book.objects.create(title='第%s本书'%i)
# 方式二：批量插入
# 1.先批量实例化模型表的对象
book_list = []
for i in range(100000):
book_obj = models.Book(title='第%s本书'%i) // 用类产生了对象
book_list.append(book_obj)
# 2.统一 一次批量插入 bulk_create只走一次IO操作数据库
models.Book.objects.bulk_create(book_list)
二 多表操作
0 前期多表准备
class Book(models.Model):
title = models.CharField(max_length=32)
price = models.DecimalField(max_digits=8,decimal_places=2)
publish_date = models.DateField(auto_now_add=True)
# 一对多
publish = models.ForeignKey(to='Publish')
# 多对多
authors = models.ManyToManyField(to='Author')
class Publish(models.Model):
name = models.CharField(max_length=32)
addr = models.CharField(max_length=64)
email = models.EmailField()
def __str__(self):
return '对象:%s'%self.name
class Author(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField()
# 一对一
author_detail = models.OneToOneField(to='AuthorDetail')
class AuthorDetail(models.Model):
phone = models.BigIntegerField() # 电话号码用BigIntegerField或者直接用CharField
addr = models.CharField(max_length=64)
1 一对多外键增删改查
# 基本和没有外键关系的 相类似
# 增加(两种方式)
# 1 直接写实际字段 关联表_id=值
models.Book.objects.create(title='论语',price=899.23,publish_id=1)
models.Book.objects.create(title='聊斋',price=444.23,publish_id=2)
models.Book.objects.create(title='老子',price=333.66,publish_id=1)
# 2 虚拟字段对象 关联表=关联表的对象
# 先查询出关联表的对象
publish_obj = models.Publish.objects.filter(pk=2).first()
# 外键指定对象
models.Book.objects.create(title='红楼梦',price=666.23,publish=publish_obj)
# 删除 级联删除
models.Publish.objects.filter(pk=1).delete()
# 修改(两种)
models.Book.objects.filter(pk=1).update(publish_id=2)
publish_obj = models.Publish.objects.filter(pk=1).first()
models.Book.objects.filter(pk=1).update(publish=publish_obj)
2 多对多外键增删改查
# 多对多外键增删改查 本质就是对第三张关系表(虚拟表) 的增删改查
# 增加
# 如何给书籍添加作者？
# 1.先获取到具体的书籍对象
book_obj = models.Book.objects.filter(pk=1).first()
print(book_obj.authors) # 就类似于你已经到了第三张关系表了
# 2.再通过 书籍对象.外键.add(参数) 为该书籍对象添加外键关联
# 参数：可以是具体的值，或者是 外键关联表的对象 并且都支持多个
book_obj.authors.add(1) # 书籍id为1的书籍，绑定一个主键为1 的作者
book_obj.authors.add(2,3)
author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()
author_obj2 = models.Author.objects.filter(pk=3).first()
book_obj.authors.add(author_obj)
book_obj.authors.add(author_obj1,author_obj2)
"""
add给第三张关系表添加数据
括号内既可以传数字也可以传对象
"""
# 删除 (与增加类似)
book_obj = models.Book.objects.filter(pk=1).first()
book_obj.authors.remove(2)
book_obj.authors.remove(1,3)
author_obj = models.Author.objects.filter(pk=2).first()
author_obj1 = models.Author.objects.filter(pk=3).first()
book_obj.authors.remove(author_obj,author_obj1)
"""
remove
括号内既可以传数字也可以传对象 并且都支持多个
"""
# 修改 (本质就是 先删除，再新增)
book_obj.authors.set([1,2]) # 特殊之处：括号内必须给一个可迭代对象
book_obj.authors.set([3]) # 括号内必须给一个可迭代对象
author_obj = models.Author.objects.filter(pk=2).first()
author_obj1 = models.Author.objects.filter(pk=3).first()
book_obj.authors.set([author_obj,author_obj1]) # 括号内必须给一个可迭代对象
"""
set
括号内必须传一个可迭代对象，该对象内既可以数字也可以对象 并且都支持多个
"""
# 清空
# 在第三张关系表中清空某个书籍与作者的绑定关系
book_obj.authors.clear()
"""
clear
括号内不要加任何参数，把当前书籍对象清空该外键关系
"""
3 正反向的概念
# 正向
# 反向
外键字段在我手上那么，我查你就是正向
外键字段如果不在手上，我查你就是反向
book >>>外键字段在书那儿(正向) >>> publish
publish >>>外键字段在书那儿(反向) >>> book
一对一和多对多正反向的判断也是如此
"""
正向查询 按字段 或 字段.all()
单个结果 多个结果
反向查询 按表名小写 或 表名小写_set.all()
"""
三 多表查询
1 子查询(基于对象的跨表查询)
# 1.查询书籍主键为1的出版社 (案例：一对多 正向)
book_obj = models.Book.objects.filter(pk=1).first()
# 书查出版社 正向
res = book_obj.publish
print(res) # publish 对象
print(res.name)
print(res.addr)
# 2.查询书籍主键为2的作者 (案例：多对多 正向)
book_obj = models.Book.objects.filter(pk=2).first()
# 书查作者 正向
res = book_obj.authors # app01.Author.None
res = book_obj.authors.all() # <QuerySet [<Author: Author object>, <Author: Author object>]>
print(res)
# 3.查询作者jason的电话号码 (案例：一对一 正向)
author_obj = models.Author.objects.filter(name='jason').first()
res = author_obj.author_detail
print(res)
print(res.phone)
print(res.addr)
"""
在书写orm语句的时候跟写sql语句一样的
不要企图一次性将orm语句写完 如果比较复杂 就写一点看一点
正向什么时候需要加.all()
当你的结果可能有多个的时候就需要加.all()
如果是一个则直接拿到数据对象
book_obj.publish
book_obj.authors.all()
author_obj.author_detail
"""
# 4.查询出版社是东方出版社出版的书 (案例：一对多 反向)
publish_obj = models.Publish.objects.filter(name='东方出版社').first()
# 出版社查书 反向
res = publish_obj.book_set # app01.Book.None
res = publish_obj.book_set.all()
print(res)
# 5.查询作者是jason写过的书 (案例：多对多 反向)
author_obj = models.Author.objects.filter(name='jason').first()
# 作者查书 反向
res = author_obj.book_set # app01.Book.None
res = author_obj.book_set.all()
print(res)
# 6.查询手机号是110的作者姓名 (案例：一对一 反向)
author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
res = author_detail_obj.author
print(res.name)
"""
基于对象
反向查询的时候
当你的查询结果可以有多个的时候 就必须加_set.all()
当你的结果只有一个的时候 不需要加
自己总结出 自己方便记忆的即可 每个人都可以不一样
个人理解记忆 反向为啥加_set : set 就是集合的意思，那么反向查有多个值，就应该有_set
"""
2 联表查询(基于双下划线的跨表查询)
# 基于双下划线的跨表查询
若是正向，可以把关联的外键 看作是表的一个属性字段 就方便使用 values('外键表名')
若是继续查询 外键表中的字段数据 ，则继续加 双下划线字段 values('外键表名__字段')
# 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)
# 4.查询书籍主键是1的作者的手机号
book author authordetail
# 正向
res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
# 反向
res = models.AuthorDetail.objects.filter(author__book__id=1).values('phone')
print(res)
"""
你只要掌握了正反向的概念
以及双下划线
那么你就可以无限制的跨表
"""
# 测试题：测试双下划线多值反向查询的时候，表名小写 是否加_set
# 1.例：查作者名字叫tank和Jason的手机号
# 作者详情表-->作者 (案例：一对一 多值反向)
res = models.AuthorDetail.objects.filter(author__name__in=['陈政华', '易春闲']).values('phone')
print(res)
# 结果：不加set，若值是多个或处于某个范围，直接用现有的 双下划线的方法 __in=[] range=[]等
四 更多查询
1 聚合查询
# 聚合查询 aggregate v. 集合；聚集
"""
聚合查询 通常情况下都是配合分组一起使用的
若想单独使用，则 .aggregate(五个聚合查询方法)
只要是跟数据库相关的模块
基本上都在django.db.models里面
如果上述没有那么应该在django.db里面
"""
from app01 import models
from django.db.models import Max, Min, Sum, Count,Avg
# 最大值 最小值 求和 计数 平均值
# 1 所有书的平均价格
res = models.Book.objects.aggregate(Avg('price'))
print(res)
# 2.上述方法一次性使用
res = models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('pk'),Avg('price'))
print(res)
2 分组查询
# 分组查询 annotate vi. 注释；给…作注释或评注
# MySQL分组查询都有哪些特点
分组之后默认只能获取到分组的依据 组内其他字段都无法直接获取了
说明数据库开启了：严格模式 (ONLY_FULL_GROUP_BY)
# 分组查询：
1.按照表名分组 # models后面的表名分组(主键)
models.表名.objects.annotate() # eg: 每本书、每个出版社
2.按照指定的字段分组 # 按照values括号内指定的字段分组
models.Book.objects.values('price').annotate() # 以书的价格分组
3.机器上如果出现分组查询报错的情况
需要修改数据库严格模式
# 小总结：
filter 在annotate前 表示过滤
value 在annotate前 表示分组的字段
filter 在annotate后 表示having
value 在annotate后 表示取字段
from django.db.models import Max, Min, Sum, Count, Avg
# 1.统计每一本书的作者个数
res = models.Book.objects.annotate() # models后面点什么 就是按什么分组
res = models.Book.objects.annotate(author_num=Count('authors')).values('title','author_num')
# 注：author_num是我们自己定义的字段 用来存储统计出来的每本书对应的作者个数
res1 = models.Book.objects.annotate(author_num=Count('authors__id')).values('title','author_num')
print(res,res1)
# 2.统计每个出版社卖的最便宜的书的价格(作业:复习原生SQL语句 写出来)
res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
print(res)
# 3.统计不止一个作者的图书
# 1.先按照图书分组 求每一本书对应的作者个数
# 2.过滤出不止一个作者的图书
res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title','author_num')
print(res)
"""
只要你的orm语句得出的结果还是一个queryset对象
那么它就可以继续无限制的点queryset对象封装的方法
"""
# 4.查询每个作者出的书的总价格
res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
print(res)
3 F与Q查询
3.1 F查询
# F查询
能直接获取数据库中字段原有的数据，方便在原有数据上进行修改操作
from django.db.models import F
# 1.查询卖出数大于库存数的书籍
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') + '爆款') # 所有的名称会全部变成空白
3.2 Q查询
# Q查询
能够指定查询条件的关系 或 与 非
# 1.查询卖出数大于100或者价格小于600的书籍
# filter括号内多个参数是and关系
res = models.Book.objects.filter(maichu__gt=100,price__lt=600) # 错误
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)
# Q的高阶用法 能够将查询条件关键词 (查询条件的左边) 变成字符串的形式
q = Q() # 实例化 Q类对象
q.connector = 'or' # 修改链接关系 默认是True
q.children.append(('maichu__gt',100))
q.children.append(('price__lt',600))
res = models.Book.objects.filter(q) # 默认还是and关系
print(res)
五 django杂知识点
1 测试环境(脚本)
"""
当你只是想测试/使用django中的某一个模块内容
那么你可以不用书写前后端交互的形式
而是直接写一个测试脚本即可
脚本代码无论是写在应用下的tests.py，还是自己单独开设py文件都可以
"""
# 测试环境的准备 去manage.py中拷贝前四行代码 然后自己写两行
import os
import sys # 这行可不用
if __name__ == "__main__":
# 导入django配置，启动django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings")
import django
django.setup()
# 在这个代码块的下面就可以测试使用django里面的单个模块
# 测试的所有代码 (包括导入模块代码) 都必须等待环境配置完成后，才能书写
2 查看内部sql语句的方式
# 方式1: queryset对象 能够点query 查看内部的sql语句
res = models.User.objects.values_list('name','age') # <QuerySet [('jason', 18), ('egonPPP', 84)]>
print(res.query)
# 方式2:日志输出形式 所有的sql语句都能查看
# 去配置文件中配置一下即可
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}
