标签：init str cti 文件中 名称 定义 tar 需要 虚拟
django周复习二
1，模型层：
1单表操作：
13个必会操作总结
返回QuerySet对象的方法有
all()
filter()
exclude()
order_by()
reverse()
distinct()
特殊的QuerySet
values() 返回一个可迭代的字典序列
values_list() 返回一个可迭代的元祖序列
返回具体对象的
get()
first()
last()
返回布尔值的方法有：
exists()
返回数字的方法有
count()
增
# 方式1： create
# book_obj = models.Book.objects.create(title=‘三国‘,price=19.99,create_time=‘2019-11-11‘)
# print(book_obj.title)
# 方式2：对象点save()方法 效率极低，因为每执行一次，相当于从数据库从头到尾执行一遍
# from datetime import datetime
# ctime = datetime.now()
# book_obj = models.Book(title=‘西游记‘,price=96.66,create_time=ctime)
# book_obj.save()
查
# print(models.Book.objects.all())
# print(models.Book.objects.get(id=1))
# print(models.Book.objects.get(pk=1))
"""
pk会自动查找到当前数据的主键字段
"""
# print(models.Book.objects.filter(pk=2))
改
# 1.update
# models.Book.objects.filter(pk=1).update(title=‘三国演义‘)
# 2.对象.save()
# book_obj = models.Book.objects.get(pk=1)
# book_obj.price = 666.66
# book_obj.save()
删除 delete()
# models.Book.objects.filter(pk=2).delete()
# < 1 > all(): 查询所有结果
# < 2 > filter(**kwargs): 它包含了与所给筛选条件相匹配的对象
# < 3 > get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。（源码就去搂一眼～诠释为何只能是一个对象）
# < 4 > exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
# print(models.Book.objects.exclude(pk=1)) # 只要pk不是1的数据全部查询出来
# < 5 > order_by(*field): 对查询结果排序(‘-id‘) / (‘price‘)
# print(models.Book.objects.order_by(‘price‘)) # 默认是升序
# print(models.Book.objects.order_by(‘-price‘)) # 加负号就是降序
# < 6 > reverse(): 对查询结果反向排序 >> > 前面要先有排序才能反向
# print(models.Book.objects.order_by(‘price‘).reverse())
# < 7 > count(): 返回数据库中匹配查询(QuerySet)
# print(models.Book.objects.count()) # 对查询出来的结果进行一个计数
# 的对象数量。
# < 8 > first(): 返回第一条记录
# print(models.Book.objects.filter(pk=1).first())
# < 9 > last(): 返回最后一条记录
# print(models.Book.objects.all())
# print(models.Book.objects.all().last())
# < 10 > exists(): 如果QuerySet包含数据，就返回True，否则返回False
# print(models.Book.objects.filter(pk=1000))
# print(models.Book.objects.filter(pk=1000).exists())
# < 11 > values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列
# model的实例化对象，而是一个可迭代的字典序列
# print(models.Book.objects.values(‘title‘,‘price‘)) # 得到的结果是列表套字典
# < 12 > values_list(*field): 它与values()
# print(models.Book.objects.values_list(‘title‘,‘price‘)) # 得到的结果是列表套元组
# 非常相似，它返回的是一个元组序列，values返回的是一个字典序列
# < 13 > distinct(): 从返回结果中剔除重复纪录
"""
去重的前提是 一定要有完全重复的数据 才能去重
"""
# print(models.Book.objects.filter(title=‘三国演义‘).distinct())
# print(models.Book.objects.values(‘title‘,‘price‘,‘create_time‘).distinct())
2，神奇的双下划线查询
字段__
__gt 大于
__lt 小于
__gte 大于等于
__lte 小于等于
__in[] 在不在里面
__range() 在不在某范围，两边都包含
__contains=‘p‘ 判断是否含有p 只能判断小写
__icontains=‘p‘ 判断是否含有p 忽略大小写
__startswith=‘三‘ 判断是否以三开头
__endswith=‘p‘ 判断是否以p结尾
__year=‘2017‘ 查看2017年的
models.Book.objects.filter(price__gte=200) 大于等于
models.Book.objects.filter(price__lte=200) 小于等于
models.Book.objects.filter(price__in=[200,300,666.66]) 查询价格要么是200,要么是300,要么是666.66
models.Book.objects.filter(price__range=(200,800)) # 两边都包含 查询价格在200到800之间的
models.Book.objects.filter(title__contains=‘p‘) # 仅仅只能拿小写p 查询书籍名字中包含p的
models.Book.objects.filter(title__icontains=‘p‘) # 忽略大小写
models.Book.objects.filter(title__startswith=‘三‘) 查询书籍是以三开头的
models.Book.objects.filter(title__endswith=‘p‘)
models.Book.objects.filter(create_time__year=‘2017‘) 查询出版日期是2017的年(******)
3，多表操作
一对多:ForeignKey
一对一:OnoToOneField 可以用ForeignKey代替ForeignKey(unique=True)
上面两个关键字所创建出来的字段会自动加上_id后缀
多对多:ManyToManyFiled
该字段并不会真正的在表中展示出来 它仅仅是一个虚拟字段
1.告诉orm自动创建第三张表
2.帮助orm跨表查询
2.一对多增删改查：
publish_id传数字
models.Book.objects.create(title=‘三国演义‘,price=189.99,publish_id=1)
publish直接传出版社对象
publish_obj = models.Publish.objects.filter(pk=2).first()
models.Book.objects.create(title=‘红楼梦‘,price=999.99,publish=publish_obj)
改
传数字的
models.Book.objects.filter(pk=1).update(publish_id=3)
传对象的
publish_obj = models.Publish.objects.filter(pk=2).first()
models.Book.objects.filter(pk=1).update(publish=publish_obj)
删
models.Publish.objects.filter(pk=2).delete() # 默认都是级联更新 级联删除
3，多对多字段的增删改查
add() 增 传数字，对象
set() 改 传数字，对象 ，必须是可迭代对象
remove() 删 传数字，对象
以上可以传多个
clear() 删所有 括号内不要传参数
# 增
add（）
1，add括号中传数字
# 主键为6的书籍增加一个作者
book_obj = models.Book.objects.filter(pk=6).first()
print(book_obj.authors) 此时为None,就是跳到了第三张表
#对象点击多对多虚拟字段时，会直接多对多的第三张表
#此时book_obj.authors就是直接跨到第三张表
book_obj.authors.add(1) # 此时就是给id为6的书籍添加一个作者
book_obj.authors.add(2,3)
# add括号中既可以传一个数字，又可以传多个数字
# 括号中一个数字，此时就是给id为6的书籍添加一个作者，
# 所以括号中有几个数字，就是添加几个作者，数字表示的是作者的id号
2，add括号中传对象
增加一条
book_obj = models.Book.objects.filter(pk=4).first()
aut_obj = models.Author.objects.filter(pk=3).first()
book_obj.authors.add(aut_obj)
增加多条
book_obj = models.Book.objects.filter(pk=5).first()
book_obj1= models.Book.objects.filter(pk=5).first()
aut_obj = models.Author.objects.filter(pk=2).first()
aut_obj1= models.Author.objects.filter(pk=1).first()
aut_obj2 = models.Author.objects.filter(pk=9).first()
book_obj.authors.add(aut_obj,aut_obj1,aut_obj2)
book_obj1.authors.add(aut_obj1)
总结：
add是给书籍添加作者 括号内既可以传数字也可以传作者对象
并且支持一次性传多个 逗号隔开就可以
注意 ：对象点虚拟字段就是跳到了第三张表
改：
将主键为5的书籍对象 作者修改为2，3
set（）
括号中以列表的形式，是可迭代对象才可以传一个参数也要以列表的形式
1，传数字，
book_obj = models.Book.objects.filter(pk=5).first()
book_obj.authors.set([5,]) 传一个参数
book_obj.authors.set([2,3]) 传多个参数
本质就是修改，有点类似于删除，把不要的删除，把要的留下来
2，传作者对象
aut_obj = models.Author.objects.filter(pk=2).first()
aut_obj1= models.Author.objects.filter(pk=1).first()
aut_obj2 = models.Author.objects.filter(pk=9).first()
book_obj.authors.set([aut_obj,aut_obj1,aut_obj2])
总结：
set（）括号内 需要传一个可迭代对象
可迭代对象 可以是多个数字组合
也可以是多个对象组合
但是不能混在一起使用，即不能既有数字，又有对象！！！
要么纯数字，要么纯对象
删：
remove（）
1，传数字
book_obj = models.Book.objects.filter(pk=5).first()
book_obj.authors.remove(3)
2，传对象
aut_obj = models.Author.objects.filter(pk=2).first()
aut_obj1= models.Author.objects.filter(pk=1).first()
aut_obj2 = models.Author.objects.filter(pk=9).first()
book_obj.authors.remove(aut_obj)
book_obj.authors.remove(aut_obj,aut_obj1,aut_obj2)
总结：
remove（）括号内既可以传数字 也可以传对象
并且支持传多个，逗号隔开即可
将某本书和作者的关系全部清空，用clear（）
即清空当前这个作者与书籍的关系
book_obj = models.Book.objects.filter(pk=5).first()
book_obj.authors.clear()
跨表查询：
正向与反向的概念
# 一对一
# 正向：author---关联字段在author表里--->authordetail 按字段
# 反向：authordetail---关联字段在author表里--->author 按表名小写
# 一对多
# 正向：book---关联字段在book表里--->publish 按字段
# 反向：publish---关联字段在book表里--->book 按表名小写_set.all() 因为一个出版社对应着多个图书
# 多对多
# 正向：book---关联字段在book表里--->author 按字段
# 反向：author---关联字段在book表里--->book 按表名小写_set.all() 因为一个作者对应着多个图书
正向查询按外键字段
反向查询按表名小写
基于对象的跨表查询(子查询:将一张表的查询结果当做另外一个查询语句的条件)
强调:在书写orm语句的时候 跟写sql语句一样
不要尝试着 一次性写完 应该做到写一点看一点再一点
1，如果外键字段在你当前这张表中，那么如果由你当前这张表向另一张表查询就是正向
关系字段在你当前这张表，由你这张表去查，正向
关系字段不在你当前这张表，由你这张表去查，反向
正向查询按外键字段
反向查询按表名小写
# 基于对象的跨表查询（子查询:将一张表的查询结果当做另外一个查询语句的条件）
#查询书籍为4的出版社名称
book_obj = models.Book.objects.filter(pk=4).first()
print(book_obj.publish.name)
print(book_obj.publish.addr)
# 查询书籍id是5的作者姓名
book_obj = models.Book.objects.filter(pk=5).first()
print(book_obj.authors) # app01.Author.None
#书籍有多个作者，所以拿到为None
print(book_obj.authors.all()) 拿到的是对象，
当你外键字段对应的值有多个的时候就用all(),为一个的时候就不用all()
# 查询作者是jason的家庭住址
auth_obj = models.Author.objects.filter(name=‘jason‘).first()
print(auth_obj.author_detail.addr)
反向查询：
# 查询出版社是东方出版社出版的书籍
publish_obj = models.Publish.objects.filter(name=‘东方出版社‘).first()
print(publish_obj.book_set.all())
# 查询作者是jason写过的所有书籍
# auth_obj = models.Author.objects.filter(name=‘jason‘).first()
# print(auth_obj.book_set)
# print(auth_obj.book_set.all())
# 查询作者号码是120的作者姓名
auth_obj = models.AuthorDetail.objects.filter(phone=120).first()
print(auth_obj.author.name)
print(auth_obj.author.age)
总结：
反向查询，当你反向查询的结果是多个的时候就需要加 _set
当你反向查询的结果是一个时就不需要加_set
即表名小写即可
跨表查询：可以连续的查询
# 基于双下划綫的跨表查询(连表查询)
models.Book.objects.filter().values(‘publish__name‘)
models.Publish.objects.filter(book__title=‘三‘).values(‘name‘)
models.Book.objects.filter().values(‘authors__author_detail__phone‘)
# 只要表中有外键字段 你可以通过__无限制的跨表
F与Q
F查询
从数据库中获取字段对应的数据
库存数大于卖出数
Q查询
与
filter(Q(),Q())
filter(Q()&Q())
或
filter(Q()|Q())
非
filter(~Q())
补充
q = Q()
q.connector = ‘or‘
q.children.append((‘title‘,‘三‘))
q.children.append((‘price‘,666))
models.Book.objects.filter(q)
2，常见字段
AutoField() int primary key auto_increment
CharField() varchar()
IntegerField() int()
big....
EmailField() varchar(254)
DateField() date
DateTimeField() datetime
auto_now:每次修改数据都会更新时间
auto_now_add:只在第一次创建数据的时候才会更新一次
BooleanField(Field)
is_delete = BooleanField()
给该字段传值的时候 你只需要传布尔值即可
但是对应到数据库 它存的是0和1
TextField(Field)
- 文本类型
用来存大段文本
FileField(Field)
- 字符串，路径保存在数据库，文件上传到指定目录
- 参数：
upload_to = "" 用户上传的文件会自动放到等号后面指定的文件路径中
storage = None 存储组件，默认django.core.files.storage.FileSystemStorage
自定义char字段
class MyChar(models.Field):
def __init__(self,max_length,*args,**kwargs):
self.max_length = max_length
super().__init__(max_length=max_length,*args,**kwargs)
def db_type(self, connection):
return ‘char(%s)‘%self.max_length
外键字段
当你在使用django2.X版本的时候 在建立外键关系时(*****)
需要你手动添加几个关键点参数
models.cascade
db_constraints
3，数据库查询优化
only与defer
select_releated与prefect_releated
"""数据库查询优化"""
# orm内所有的语句操作 都是惰性查询:只会在你真正需要数据的时候才会走数据库,如果你单单只写orm语句时不会走数据库的
# 这样设计的好处 在于 减轻数据库的压力
# res = models.Book.objects.only(‘title‘)
# # print(res)
# for r in res:
# # print(r.title) # 只走一次数据库查询
# print(r.price) # 当你点击一个不是only括号内指定的字段的时候 不会报错 而是会频繁的走数据库查询
# res1 = models.Book.objects.defer(‘title‘) # defer与only是相反的
# for r in res1: # defer会将不是括号内的所有的字段信息 全部查询出来封装对象中
# # 一旦你点击了括号内的字段 那么会频繁的走数据库查询
# print(r.price)
# select_related与prefetch_related
# select_related帮你直接连表操作 查询数据 括号内只能放外键字段
# res = models.Book.objects.all().select_related(‘publish‘)
# for r in res:
# print(r.publish.name)
# res = models.Book.objects.all().select_related(‘publish__xxx__yyy__ttt‘)
# print(res)
# res = models.Book.objects.all()
"""
select_related:会将括号内外键字段所关联的那张表 直接全部拿过来(可以一次性拿多张表)跟当前表拼接操作
从而降低你跨表查询 数据库的压力
注意select_related括号只能放外键字段(一对一和一对多)
res = models.Book.objects.all().select_related(‘外键字段1__外键字段2__外键字段3__外键字段4‘)
"""
# prefetch_related 不主动连表
res = models.Book.objects.prefetch_related(‘publish‘)
"""
不主动连表操作(但是内部给你的感觉像是连表操作了) 而是将book表中的publish全部拿出来 在取publish表中将id对应的所有的数据取出
res = models.Book.objects.prefetch_related(‘publish‘)
括号内有几个外键字段 就会走几次数据库查询操作
"""
for r in res:
print(r.publish.name)
4，事务
ACID
原子性
一致性
隔离性
持久性
from django.db import transaction
with transaction.atomic():
"""数据库操作
在该代码块中书写的操作 同属于一个事务
"""
models.Book.objects.create()
models.Publish.objects.create()
# 添加书籍和出版社 就是同一个事务 要么一起成功要么一起失败
print(‘出了 代码块 事务就结束‘)
5，数据库连接：
1，在settings.py 文件中进行更改，添加
DATABASES = {
‘default‘: {
‘ENGINE‘: ‘django.db.backends.mysql‘,
‘NAME‘: ‘day56‘,
‘HOST‘:‘127.0.0.1‘,
‘USER‘:‘root‘,
‘PORT‘:3306,
‘PASSWORD‘:‘123‘,
‘CHARSET‘:‘utf8‘
}
}
2.在应用或者项目文件夹下的__init__文件中添加：
import pymysql
pymysql.install_as_MySQLdb()
3，orm对象关系映射
表 类
一条条记录 对象
记录中的字段 对象.属性
首先需要在应用下的models.py中书写模型类
class User(models.Model):
# 将id字段设置为User表主键字段 在django orm中 你可以不写主键字典 django会默认给你的表创建一个名为id的主键字段
# id = models.AutoField(primary_key=True) # 一旦你自己指定了主键字段 那么django就不会自动再帮你创建了
username = models.CharField(max_length=32) # username varchar(32) CharField必须要指定max_length参数
password = models.IntegerField() # password int
*************************需要执行数据库迁移(同步)命令******************************
python3 manage.py makemigrations # 仅仅是在小本本上(migrations文件夹)记录数据库的修改 并不会直接操作数据
python3 manage.py migrate # 将数据库修改记录 真正同步到数据库
注意:只要动了models中跟数据库相关的代码 就必须重新执行上面的两条命令 缺一不可(******)
DJango周总结二：模型层，单表，多表操作，连表操作，数据库操作，事务
标签：init str cti 文件中 名称 定义 tar 需要 虚拟
原文地址：https://www.cnblogs.com/Fzhiyuan/p/11564510.html
