Django ORM
ORM是什么？：(在django中，根据代码中的类自动生成数据库的表也叫--code first)
ORM:Object Relational Mapping(关系对象映射)
类名对应------》数据库中的表名
类属性对应---------》数据库里的字段
类实例对应---------》数据库表里的一行数据
obj.id obj.name.....类实例对象的属性
Django的orm操作本质上会根据对接的数据库引擎，翻译成对应的sql语句；所有使用Django开发的项目无需关心程序底层使用的是MySQL、Oracle、sqlite....，如果数据库迁移，只需要更换Django的数据库引擎即可；
一.Django连接MySQL
1.创建数据库
由于Django自带的orm是data_first类型的ORM，使用前必须先创建数据库
create database day70 default character set utf8 collate utf8_general_ci;
2、修改project中的settings.py文件中设置 连接 MySQL数据库（Django默认使用的是sqllite数据库）
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME':'day70',
'USER': 'eric',
'PASSWORD': '123123',
'HOST': '192.168.182.128',
'PORT': '3306',
}
}
3、修改project 中的__init__py 文件设置 Django默认连接MySQL的方式
import pymysql
pymysql.install_as_MySQLdb()
二.models.py创建表
Djan提供了很多字段类型，比如URL/Email/IP/ 但是mysql数据没有这些类型，这类型存储到数据库上本质是字符串数据类型,其主要目的是为了封装底层SQL语句；
1.字符串类以下都是在数据库中本质都是字符串数据类型，此类字段只是在Django自带的admin中生效）
name=models.CharField(max_length=32)
EmailField(CharField)：
IPAddressField(Field)
URLField(CharField)
SlugField(CharField)
UUIDField(Field)
FilePathField(Field)
FileField(Field)
ImageField(FileField)
CommaSeparatedIntegerField(CharField)
models.CharField 对应的是MySQL的varchar数据类型
char 和 varchar的区别 :
char和varchar的共同点是存储数据的长度，不能 超过max_length限制，
不同点是varchar根据数据实际长度存储，char按指定max_length（）存储数据；所有前者更节省硬盘空间；
2、时间字段
models.DateTimeField(null=True)
date=models.DateField()
3.数据字段
(max_digits=30,decimal_places=10)总长度30小数位 10位）
数字：
num = models.IntegerField()
num = models.FloatField() 浮点
price=models.DecimalField(max_digits=8,decimal_places=3) 精确浮点
4.枚举字段
choice=(
(1,'男人'),
(2,'女人'),
(3,'其他')
)
lover=models.IntegerField(choices=choice) #枚举类型
扩展
在数据库存储枚举类型，比外键有什么优势？
1、无需连表查询性能低，省硬盘空间(选项不固定时用外键)
2、在modle文件里不能动态增加（选项一成不变用Django的choice）
字段参数介绍
1.数据库级别生效
1 AutoField(Field) 2 - int自增列，必须填入参数 primary_key=True 3 4 BigAutoField(AutoField) 5 - bigint自增列，必须填入参数 primary_key=True 6 7 注：当model中如果没有自增列，则自动会创建一个列名为id的列 8 from django.db import models 9 10 class UserInfo(models.Model): 11 # 自动创建一个列名为id的且为自增的整数列 12 username = models.CharField(max_length=32) 13 14 class Group(models.Model): 15 # 自定义自增列 16 nid = models.AutoField(primary_key=True) 17 name = models.CharField(max_length=32) 18 19 SmallIntegerField(IntegerField): 20 - 小整数 -32768 ～ 32767 21 22 PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField) 23 - 正小整数 0 ～ 32767 24 IntegerField(Field) 25 - 整数列(有符号的) -2147483648 ～ 2147483647 26 27 PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField) 28 - 正整数 0 ～ 2147483647 29 30 BigIntegerField(IntegerField): 31 - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807 32 33 自定义无符号整数字段 34 35 class UnsignedIntegerField(models.IntegerField): 36 def db_type(self, connection): 37 return 'integer UNSIGNED' 38 39 PS: 返回值为字段在数据库中的属性，Django字段默认的值为： 40 'AutoField': 'integer AUTO_INCREMENT', 41 'BigAutoField': 'bigint AUTO_INCREMENT', 42 'BinaryField': 'longblob', 43 'BooleanField': 'bool', 44 'CharField': 'varchar(%(max_length)s)', 45 'CommaSeparatedIntegerField': 'varchar(%(max_length)s)', 46 'DateField': 'date', 47 'DateTimeField': 'datetime', 48 'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)', 49 'DurationField': 'bigint', 50 'FileField': 'varchar(%(max_length)s)', 51 'FilePathField': 'varchar(%(max_length)s)', 52 'FloatField': 'double precision', 53 'IntegerField': 'integer', 54 'BigIntegerField': 'bigint', 55 'IPAddressField': 'char(15)', 56 'GenericIPAddressField': 'char(39)', 57 'NullBooleanField': 'bool', 58 'OneToOneField': 'integer', 59 'PositiveIntegerField': 'integer UNSIGNED', 60 'PositiveSmallIntegerField': 'smallint UNSIGNED', 61 'SlugField': 'varchar(%(max_length)s)', 62 'SmallIntegerField': 'smallint', 63 'TextField': 'longtext', 64 'TimeField': 'time', 65 'UUIDField': 'char(32)', 66 67 BooleanField(Field) 68 - 布尔值类型 69 70 NullBooleanField(Field): 71 - 可以为空的布尔值 72 73 CharField(Field) 74 - 字符类型 75 - 必须提供max_length参数， max_length表示字符长度 76 77 TextField(Field) 78 - 文本类型 79 80 EmailField(CharField)： 81 - 字符串类型，Django Admin以及ModelForm中提供验证机制 82 83 IPAddressField(Field) 84 - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制 85 86 GenericIPAddressField(Field) 87 - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6 88 - 参数： 89 protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6" 90 unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启刺功能，需要protocol="both" 91 92 URLField(CharField) 93 - 字符串类型，Django Admin以及ModelForm中提供验证 URL 94 95 SlugField(CharField) 96 - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号） 97 98 CommaSeparatedIntegerField(CharField) 99 - 字符串类型，格式必须为逗号分割的数字 100 101 UUIDField(Field) 102 - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证 103 104 FilePathField(Field) 105 - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能 106 - 参数： 107 path, 文件夹路径 108 match=None, 正则匹配 109 recursive=False, 递归下面的文件夹 110 allow_files=True, 允许文件 111 allow_folders=False, 允许文件夹 112 113 FileField(Field) 114 - 字符串，路径保存在数据库，文件上传到指定目录 115 - 参数： 116 upload_to = "" 上传文件的保存路径 117 storage = None 存储组件，默认django.core.files.storage.FileSystemStorage 118 119 ImageField(FileField) 120 - 字符串，路径保存在数据库，文件上传到指定目录 121 - 参数： 122 upload_to = "" 上传文件的保存路径 123 storage = None 存储组件，默认django.core.files.storage.FileSystemStorage 124 width_field=None, 上传图片的高度保存的数据库字段名（字符串） 125 height_field=None 上传图片的宽度保存的数据库字段名（字符串） 126 127 DateTimeField(DateField) 128 - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] 129 130 DateField(DateTimeCheckMixin, Field) 131 - 日期格式 YYYY-MM-DD 132 133 TimeField(DateTimeCheckMixin, Field) 134 - 时间格式 HH:MM[:ss[.uuuuuu]] 135 136 DurationField(Field) 137 - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型 138 139 FloatField(Field) 140 - 浮点型 141 142 DecimalField(Field) 143 - 10进制小数 144 - 参数： 145 max_digits，小数总长度 146 decimal_places，小数位长度 147 148 BinaryField(Field) 149 - 二进制类型
2.Django admin级别生效
1 针对 dango_admin生效的参数（正则匹配）（使用Django admin就需要关心以下参数！！）） 2 blanke (是否为空) 3 editable=False 是否允许编辑 4 5 help_text="提示信息"提示信息 6 choices=choice 提供下拉框 7 error_messages="错误信息" 错误信息 8 9 validators 自定义错误验证（列表类型），从而定制想要的验证规则 10 from django.core.validators import RegexValidator 11 from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\ 12 MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator 13 如： 14 test = models.CharField( 15 max_length=32, 16 error_messages={ 17 'c1': '优先错信息1', 18 'c2': '优先错信息2', 19 'c3': '优先错信息3', 20 }, 21 validators=[ 22 RegexValidator(regex='root_\d+', message='错误了', code='c1'), 23 RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'), 24 EmailValidator(message='又错误了', code='c3'), ]
三.ORM表单操作
<1> all(): 查询所有结果
<2> filter(**kwargs): 它包含了与所给筛选条件相匹配的对象
<3> get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
<4> exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
<5> values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列
<6> values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
<7> order_by(*field): 对查询结果排序
<8> reverse(): 对查询结果反向排序，请注意reverse()通常只能在具有已定义顺序的QuerySet上调用(在model类的Meta中指定ordering或调用order_by()方法)。
<9> distinct(): 从返回结果中剔除重复纪录(如果你查询跨越多个表，可能在计算QuerySet时得到重复的结果。此时可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。)
<10> count(): 返回数据库中匹配查询(QuerySet)的对象数量。
<11> first(): 返回第一条记录
<12> last(): 返回最后一条记录
<13> exists(): 如果QuerySet包含数据，就返回True，否则返回False
我们在学习django中的orm的时候，我们可以把一对多，多对多，分为正向和反向查找两种方式。
正向查找：ForeignKey在 UserInfo表中，如果从UserInfo表开始向其他的表进行查询，这个就是正向操作，反之如果从UserType表去查询其他的表这个就是反向操作。
一对多：models.ForeignKey(其他表)
多对多：models.ManyToManyField(其他表)
一对一：models.OneToOneField(其他表)
正向连表操作总结
所谓正、反向连表操作的认定无非是Foreign_Key字段在哪张表决定的，
Foreign_Key字段在哪张表就可以哪张表使用Foreign_Key字段连表，反之没有Foreign_Key字段就使用与其关联的小写表名；
1对多：对象.外键.关联表字段，values(外键字段__关联表字段)
多对多：外键字段.all()
反向连表操作总结：
通过value、value_list、fifter 方式反向跨表：小写表名__关联表字段
通过对象的形式反向跨表：小写表面_set().all()
应用场景
一对多：当一张表中创建一行数据时，有一个单选的下拉框（可以被重复选择）
例如：创建用户信息时候，需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。
多对多：在某表中创建一行数据是，有一个可以多选的下拉框
例如：创建用户信息，需要为用户指定多个爱好
一对一：在某表中创建一行数据时，有一个单选的下拉框（下拉框中的内容被用过一次就消失了
例如：原有含10列数据的一张表保存相关信息，经过一段时间之后，10列无法满足需求，需要为原来的表再添加5列数据
1 1.一对多 2 class UserInfo(models.Model): 3 """ 4 用户信息表 5 """ 6 uid = models.BigAutoField(primary_key=True) 7 username = models.CharField(verbose_name='账号', max_length=32, unique=True) 8 password = models.CharField(verbose_name='密码', max_length=64) 9 nickname = models.CharField(verbose_name='用户名', max_length=32) 10 11 def __str__(self): 12 return self.username 13 14 class UserToken(models.Model): 15 '''用户token表''' 16 useruid = models.OneToOneField(to="UserInfo", on_delete=models.CASCADE) 17 token = models.CharField(max_length=64) 18 19 class GetUserInfo(APIView): 20 """ 21 用户登录认证通过后只在vuex中存储token，并没有存储用户信息。 22 前端定义router.beforeEach全局钩子，基于用于唯一标识（token）访问这个接口用于获取最新的用户信息。 23 """ 24 def get(self,request,*args,**kwargs): 25 token = request.GET.get("token") 26 # userinfo = models.UserToken.objects.get(token=token).useruid.uid #获取到token 从UserToken正向查 27 userinfo = models.UserInfo.objects.get(usertoken__token=token).uid #获取到token 从UserInfo反向查 28 print(userinfo) 29 return Response(1234) 30 31 如果A表的1条记录对应B表中N条记录成立，两表之间就是1对多关系；在1对多关系中 A表就是主表，B表为子表，ForeignKey字段就建在子表；如果B表的1条记录也对应A表中N条记录，两表之间就是双向1对多关系，也称为多对多关系； 32 在orm中设置如果 A表设置了外键字段user=models.ForeignKey('UserType')到B表(注意外键表名加引号) 33 就意味着 写在写A表的B表主键， （一列），代表B表的多个（一行）称为1对多， 34 查询 35 总结：利用orm获取 数据库表中多个数据 36 获取到的数据类型本质上都是 queryset类型， 37 类似于列表， 38 内部有3种表现形式（对象，字典，列表） 39 modle.表名.objects.all() 40 modle.表名.objects.values() 41 modle.表名.objects.values() 42 跨表 43 正向操作 44 所以可以通过obj.外键.B表的列表跨表操作（注意！！orm连表操作必须选拿单个对象，不像SQL中直接表和表join就可以了） 45 print(obj.cls.title) 46 47 class UserGroup(models.Model): 48 """ 49 部门 3 50 """ 51 title = models.CharField(max_length=32) 52 class UserInfo(models.Model): 53 """ 54 员工4 55 """ 56 nid = models.BigAutoField(primary_key=True) 57 user = models.CharField(max_length=32) 58 password = models.CharField(max_length=64) 59 age = models.IntegerField(default=1) 60 # ug_id 1 61 ug = models.ForeignKey("UserGroup",null=True) 62 1. 在取得时候跨表 63 q = UserInfo.objects.all().first() 64 q.ug.title 65 66 2. 在查的时候就跨表了 67 UserInfo.objects.values('nid','ug_id') 68 UserInfo.objects.values('nid','ug_id','ug__title') #注意正向连表是 外键__外键列 反向是小写的表名 69 70 3. UserInfo.objects.values_list('nid','ug_id','ug__title') 71 72 反向连表： 73 反向操作无非2种方式： 74 1、通过对象的形式反向跨表：小写表名_set().all() 75 2、通过value和value_list方式反向跨表：小写表名__字段 76 77 1. 小写的表名_set 得到有外键关系的对象 78 obj = UserGroup.objects.all().first() 79 result = obj.userinfo_set.all() [userinfo对象,userinfo对象,] 80 2. 小写的表名 得到有外键关系的列 #因为使用values取值取得是字典的不是对象，所以需要 小写表名（外键表）__ 81 v = UserGroup.objects.values('id','title') 82 v = UserGroup.objects.values('id','title','小写的表名称') 83 v = UserGroup.objects.values('id','title','小写的表名称__age') 84 85 1对多自关联（ 由原来的2张表，变成一张表！ ） 86 class Comment(models.Model): 87 """ 88 评论表 89 """ 90 news_id = models.IntegerField() # 新闻ID 91 content = models.CharField(max_length=32) # 评论内容 92 user = models.CharField(max_length=32) # 评论者 93 reply = models.ForeignKey('Comment',null=True,blank=True,related_name='xxxx') #回复ID 94 2.多对多 95 1.自己写第三张关系表 96 多对多关系表 数据查找思路 97 1、找到该对象 98 2.通过该对象 反向操作 找到第三张关系表 99 3.通过第三张关系表 正向操作 找到 和该对象有关系对象 100 总结（只要对象1和对象2 中间有关系表建立了关系； 对象1反向操作 到关系表 ,关系表正向操作到对象2,反之亦然 101 2.第3张关系表不用写(m=models.ManyToManyField(' 要关联的表') 自动生成 ) 102 由于 DjangoORM中一个类名对应一张表，要想操作表就modles.类直接操作那张表，但使用ManyToManyField字段生成 “第三张”关系表怎么操作它呢？ 103 答案：通过单个objd对象 间接操作 104 class Boy(models.Model): 105 name = models.CharField(max_length=32) 106 m = models.ManyToManyField('Girl',through="Love",through_fields=('b','g',)) 107 class Girl(models.Model): 108 nick = models.CharField(max_length=32) 109 m = models.ManyToManyField('Boy') 110 111 正向操作: obj.m.all() 112 obj = models.Boy.objects.filter(name='方少伟').first() 113 print(obj.id,obj.name) 114 obj.m.add(2) 115 obj.m.add(2,4) 116 obj.m.add(*[1,]) 117 118 obj.m.remove(1) 119 obj.m.remove(2,3) 120 obj.m.remove(*[4,]) 121 122 obj.m.set([1,]) 123 124 q = obj.m.all() 125 # [Girl对象] 126 print(q) 127 obj = models.Boy.objects.filter(name='方少伟').first() 128 girl_list = obj.m.all() 129 130 obj = models.Boy.objects.filter(name='方少伟').first() 131 girl_list = obj.m.all() 132 girl_list = obj.m.filter(nick='小鱼') 133 print(girl_list) 134 135 obj = models.Boy.objects.filter(name='方少伟').first() 136 obj.m.clear() 137 138 反向操作 :obj.小写的表名_set 139 多对多和外键跨表一样都是 小写的表名_set 140 3、既自定义第三张关系表 也使用ManyToManyField('Boy')字段(杂交类型) 141 ManyToManyField()字段创建第3张关系表，可以使用字段跨表查询，但无法直接操作第3张表， 142 自建第3表关系表可以直接操作，但无法通过字段 查询，我们可以把他们结合起来使用； 143 作用： 144 1、既可以使用字段跨表查询，也可以直接操作第3张关系表 145 2、obj.m.all() 只有查询和清空 方法 146 class UserInfo(AbstractUser): 147 """ 148 用户信息 149 """ 150 nid = models.BigAutoField(primary_key=True) 151 nickname = models.CharField(verbose_name='昵称', max_length=32) 152 telephone = models.CharField(max_length=11, blank=True, null=True, unique=True, verbose_name='手机号码') 153 avatar = models.FileField(verbose_name='头像', upload_to='upload/avatar/') 154 create_time = models.DateTimeField(verbose_name='创建时间',auto_now_add=True) 155 156 fans = models.ManyToManyField(verbose_name='粉丝们', 157 to='UserInfo', 158 through='UserFans', 159 through_fields=('user', 'follower')) 160 161 def __str__(self): 162 return self.username 163 class UserFans(models.Model): 164 """ 165 互粉关系表 166 """ 167 nid = models.AutoField(primary_key=True) 168 user = models.ForeignKey(verbose_name='博主', to='UserInfo', to_field='nid', related_name='users') 169 follower = models.ForeignKey(verbose_name='粉丝', to='UserInfo', to_field='nid', related_name='followers') 170 class Meta: 171 unique_together = [ 172 ('user', 'follower'), 173 ] 174 through='UserFans'指定第3张关系表的表名 175 through_fields 指定第3张关系表的字段 176 177 class Boy(models.Model): 178 name = models.CharField(max_length=32) 179 m = models.ManyToManyField('Girl',through="Love",through_fields=('b','g',)) 180 # 查询和清空 181 182 class Girl(models.Model): 183 nick = models.CharField(max_length=32) 184 # m = models.ManyToManyField('Boy') 185 186 class Love(models.Model): 187 b = models.ForeignKey('Boy') 188 g = models.ForeignKey('Girl') 189 190 class Meta: 191 unique_together = [ 192 ('b','g'), 193 外键反向查找别名（方便反向查找） 194 在写ForeignKey字段的时候，如果想要在反向查找时不使用默认的 小写的表名_set，就在定义这个字段的时间加related参数！ 195 related_name、related_query_name 字段=什么别名 反向查找时就使用什么别名！ 196 197 反向查找： 198 设置了related_query_name 反向查找时就是obj.别名_set.all（）保留了_set 199 related_query_name 200 from django.db import models 201 202 class Userinfo(models.Model): 203 nikename=models.CharField(max_length=32) 204 username=models.CharField(max_length=32) 205 password=models.CharField(max_length=64) 206 sex=((1,'男'),(2,'女')) 207 gender=models.IntegerField(choices=sex) 208 209 '''把男女表混合在一起，在代码层面控制第三张关系表的外键关系 ''' 210 #写到此处问题就来了，原来两个外键 对应2张表 2个主键 可以识别男女 211 #现在两个外键对应1张表 反向查找 无法区分男女了了 212 # object对象女.U2U.Userinfo.set object对象男.U2U.Userinfo.set 213 #所以要加related_query_name对 表中主键 加以区分 214 #查找方法 215 # 男 obj.a._set.all() 216 # 女：obj.b._set.all() 217 class U2U(models.Model): 218 b=models.ForeignKey(Userinfo,related_query_name='a') 219 g=models.ForeignKey(Userinfo,related_query_name='b') 220 related_name 221 反向查找： 222 设置了relatedname就是 反向查找时就说 obj.别名.all() 223 from django.db import models 224 225 class Userinfo(models.Model): 226 nikename=models.CharField(max_length=32) 227 username=models.CharField(max_length=32) 228 password=models.CharField(max_length=64) 229 sex=((1,'男'),(2,'女')) 230 gender=models.IntegerField(choices=sex) 231 232 233 '''把男女表混合在一起，在代码层面控制第三张关系表的外键关系 ''' 234 #写到此处问题就来了，原来两个外键 对应2张表 2个主键 可以识别男女 235 #现在两个外键对应1张表 反向查找 无法区分男女了了 236 # object对象女.U2U.Userinfo.set object对象男.U2U.Userinfo.set 237 #所以要加related_query_name设置反向查找命名对 表中主键 加以区分 238 #查找方法 239 # 男 obj.a.all() 240 # 女：obj.b.all() 241 class U2U(models.Model): 242 b=models.ForeignKey(Userinfo,related_name='a') 243 g=models.ForeignKey(Userinfo,related_name='b') 244 操作 245 from django.shortcuts import render,HttpResponse 246 from app01 import models 247 # Create your views here. 248 249 def index(request): 250 #查找 ID为1男孩 相关的女孩 251 boy_obj=models.Userinfo.objects.filter(id=1).first() 252 253 res= boy_obj.boy.all()#得到U2U的对象再 正向跨表 254 #原来跨表 boy_obj.小写表名.all（） 255 # 现在设置了related_name（别名） 直接res= boy_obj.boy.all()跨表 256 257 for obj in res: 258 print(obj.g.nikename) 259 return HttpResponse('OK') 260 多对多自关联（由原来的3张表，变成只有2张表） 261 把两张表通过 choices字段合并为一张表 262 ‘第三张关系表’ 使用models.ManyToManyField('Userinfo')生成 263 特性： 264 obj = models.UserInfo.objects.filter(id=1).first() 获取对象 265 1、查询第三张关系表前面那一列：obj.m 266 select xx from xx where from_userinfo_id = 1 267 2、查询第三张关系表后面那一列：obj.userinfo_set 268 select xx from xx where to_userinfo_id = 1 269 270 class Userinfo(models.Model): 271 nikename=models.CharField(max_length=32) 272 username=models.CharField(max_length=32) 273 password=models.CharField(max_length=64) 274 sex=((1,'男'),(2,'女')) 275 gender=models.IntegerField(choices=sex) 276 m=models.ManyToManyField('Userinfo') 277 278 def index(request): 279 # 多对多自关联 之通过男士查询女生 280 boy_obj=models.Userinfo.objects.filter(id=4).first() 281 res=boy_obj.m.all() 282 for row in res: 283 print(row.nikename) 284 return HttpResponse('OK') 285 286 girl_obj=models.Userinfo.objects.filter(id=4).first() 287 #多对多自关联 之通过女士查询男生 288 res=girl_obj.userinfo_set.all() 289 for obj in res: 290 print(obj.nikename) 291 return HttpResponse('OK')
四.浅谈ORM查询性能
普通查询
obj_list=models.Love.objects.all()
for row in obj_list: #for循环10次发送10次数据库查询请求
print(row.b.name)
这种查询方式第一次发送 查询请求每for循环一次也会发送查询请求
1、select_related：结果为对象 注意query_set类型的对象 都有该方法
原理： 查询时主动完成连表形成一张大表，for循环时不用额外发请求；
试用场景： 节省硬盘空间，数据量少时候适用相当于做了一次数据库查询；
obj_list=models.Love.objects.all().select_related('b')
for row in obj_list:
print(row.b.name)
2、prefetch_related：结果都对象是
原理：虽好，但是做连表操作依然会影响查询性能，所以出现prefetch_related
prefetch_related:不做连表，多次单表查询外键表 去重之后显示， 2次单表查询（有几个外键做几次1+N次单表查询，
适用场景：效率高，数据量大的时候试用
obj_list=models.Love.objects.all().prefetch_related('b')
for obj in obj_list:
print(obj.b.name)
3、update()和对象.save()修改方式的性能PK
修改方式1
models.Book.objects.filter(id=1).update(price=3)
方式2
book_obj=models.Book.objects.get(id=1)
book_obj.price=5
book_obj.save()
执行结果：
(0.000) BEGIN; args=None
(0.000) UPDATE "app01_book" SET "price" = '3.000' WHERE "app01_book"."id" = 1; args=('3.000', 1)
(0.000) SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", "app01_book"."date", "app01_book"."publish_id", "app01_book"."classify_id" FROM "app01_book" WHERE "app01_book"."id" = 1; args=(1,)
(0.000) BEGIN; args=None
(0.000) UPDATE "app01_book" SET "title" = '我的奋斗', "price" = '5.000', "date" = '1370-09-09', "publish_id" = 4, "classify_id" = 3 WHERE "app01_book"."id" = 1; args=('我的奋斗', '5.000', '1370-09-09', 4, 3, 1)
[31/Aug/2017 17:07:20] "GET /fandq/ HTTP/1.1" 200 2
结论：
update() 方式1修改数据的方式，比obj.save()性能好；
五.分组和聚合查询
1 1、aggregate(*args,**kwargs) 聚合函数 2 通过对QuerySet进行计算，返回一个聚合值的字典。aggregate()中每一个参数都指定一个包含在字典中的返回值。即在查询集上生成聚合。 3 from django.db.models import Avg,Sum,Max,Min 4 #求书籍的平均价 5 ret=models.Book.objects.all().aggregate(Avg('price')) 6 #{'price__avg': 145.23076923076923} 7 8 #参与西游记著作的作者中最老的一位作者 9 ret=models.Book.objects.filter(title__icontains='西游记').values('author__age').aggregate(Max('author__age')) 10 #{'author__age__max': 518} 11 12 #查看根哥出过得书中价格最贵一本 13 ret=models.Author.objects.filter(name__contains='根').values('book__price').aggregate(Max('book__price')) 14 #{'book__price__max': Decimal('234.000')} 15 2、annotate(*args,**kwargs) 分组函数 16 #查看每一位作者出过的书中最贵的一本（按作者名分组 values() 然后annotate 分别取每人出过的书价格最高的） 17 ret=models.Book.objects.values('author__name').annotate(Max('price')) 18 # < QuerySet[ 19 # {'author__name': '吴承恩', 'price__max': Decimal('234.000')}, 20 # {'author__name': '吕不韦','price__max': Decimal('234.000')}, 21 # {'author__name': '姜子牙', 'price__max': Decimal('123.000')}, 22 # {'author__name': '亚微',price__max': Decimal('123.000')}, 23 # {'author__name': '伯夷 ', 'price__max': Decimal('2010.000')}, 24 # {'author__name': '叔齐','price__max': Decimal('200.000')}, 25 # {'author__name': '陈涛', 'price__max': Decimal('234.000')}, 26 # {'author__name': '高路川', price__max': Decimal('234.000')} 27 # ] > 28 29 #查看每本书的作者中最老的 按作者姓名分组 分别求出每组中年龄最大的 30 ret=models.Book.objects.values('author__name').annotate(Max('author__age')) 31 # < QuerySet[ 32 # {'author__name': '吴承恩', 'author__age__max': 518}, 33 # {'author__name': '张X', 'author__age__max': 18}, 34 # { 'author__name': '张X杰', 'author__age__max': 56}, 35 # {'author__name': '方X伟', 'author__age__max': 26}, 36 # {'author__name': '游X兵', 'author__age__max': 35}, 37 # {'author__name': '金庸', 'author__age__max': 89}, 38 # { 'author__name': 'X涛', 'author__age__max': 27}, 39 # {'author__name': '高XX', 'author__age__max': 26} 40 # ] > 41 42 #查看 每个出版社 出版的最便宜的一本书 43 ret=models.Book.objects.values('publish__name').annotate(Min('price')) 44 # < QuerySet[ 45 # {'publish__name': '北大出版社','price__min': Decimal('67.000')}, 46 # {'publish__name': '山西出版社','price__min': Decimal('34.000')}, 47 # {'publish__name': '河北出版社', 'price__min': Decimal('123.000')}, 48 # {'publish__name': '浙江出版社', 'price__min': Decimal('2.000')}, 49 # {'publish__name': '湖北出版社', 'price__min': Decimal('124.000')}, 50 # {'publish__name': '湖南出版社',price__min': Decimal('15.000')} 51 # ] >
六.F查询与Q查询
1 仅仅靠单一的关键字参数查询已经很难满足查询要求。此时Django为我们提供了F和Q查询： 2 1、F 可以获取对象中的字段的属性（列），并对其进行操作； 3 from django.db.models import F,Q 4 #F 可以获取对象中的字段的属性（列），并且对其进行操作； 5 models.Book.objects.all().update(price=F('price')+1) #对图书馆里的每一本书的价格 上调1块钱 6 2、Q多条件组合查询 7 Q（）可以使orm的filter（）方法支持， 多个查询条件，使用逻辑关系（&、|、~）包含、组合到一起进行多条件查询； 8 语法： 9 fifter（Q（查询条件1）| Q（查询条件2）） 10 fifter（Q（查询条件2）& Q（查询条件3）） 11 fifter（Q（查询条件4）& ~Q（查询条件5）） 12 fifter（Q（查询条件6）| Q（Q（查询条件4）& ~ Q（Q（查询条件5）& Q（查询条件3）））包含 13 14 from django.db.models import F,Q 15 1、F 可以获取对象中的字段的属性（列），并且对其进行操作； 16 # models.Book.objects.all().update(price=F('price')+1) 17 2、Q多条件组合查询 18 #如果 多个查询条件 涉及到逻辑使用 fifter（,隔开）可以表示与，但没法表示或非得关系 19 #查询 书名包含作者名的书 20 book=models.Book.objects.filter(title__icontains='伟',author__name__contains='伟').values('title') 21 #如何让orm 中得 fifter 支持逻辑判断+多条件查询？ Q（）登场 22 book=models.Book.objects.filter(Q(title__icontains='伟') & Q(author__name__contains='伟')).values('title') 23 book=models.Book.objects.filter(Q(author__name__contains='伟') & ~Q(title__icontains='伟')).values('title') 24 25 #多条件包含组合查询 26 #查询作者姓名中包含 方/少/伟/书名包含伟3字 并且出版社地址以山西开头的书 27 book=models.Book.objects.filter( 28 Q( 29 Q(author__name__contains='方') | 30 Q(author__name__contains='少') | 31 Q(title__icontains='伟')| 32 Q(author__name__contains='伟') 33 ) 34 & 35 Q(publish__addr__contains='山西') 36 ).values('title') 37 print(book) 38 return HttpResponse('OK')
七.补充
1 1.oder_by(-id)：按照某种规则排序 2 2.exclude(字段)：字段获取数据时排除 3 course_list = models.Course.objects.exclude(course_type=2) 4 3.按时间查询 5 Django的orm支持按时间查询数据，前提是你在models中设置了该字段为DateTimeField 以及该字段存储的数据类型为 python的datime时间类型。 6 提示: 7 如果在通过时间查询的时候出现 warning 在setings.py中设置如下： 8 USE_TZ = True 9 如果时间格式显示英文在setings.py中设置如下： 10 LANGUAGE_CODE = 'zh-Hans' 11 12 A.查询大于某个时间点产生的数据。（在某个时间点之后） 13 #gt：大于某个时间 14 now = datetime.datetime.now() 15 start = now-datetime.timedelta(hours=23,minutes=59,seconds=59) 16 #查询 前一天的数据 17 obj=models.TaskLog.objects.filter(date__gt=start) 18 print(obj) 19 B.大于等于某个时间点 20 import datetime 21 start_date = datetime.date(2018, 9, 5) 22 #gte：大于等于某个时间点 23 now = datetime.datetime.now() 24 start = now-datetime.timedelta(hours=23,minutes=59,seconds=59) 25 #查询 前一天的数据 26 obj=models.TaskLog.objects.filter(date__gte=start) 27 print(obj) 28 C.小于某个时间点（在某个时间点之前） 29 import datetime 30 start_date = datetime.date(2018, 9, 5) 31 #lt：小于某个时间点 32 now = datetime.datetime.now() 33 start = now-datetime.timedelta(hours=23,minutes=59,seconds=59) 34 #查询 2018年9月4日，之前产生的日志。 35 obj=models.TaskLog.objects.filter(date__lt=start) 36 print(obj) 37 D.小于等于某个时间点 38 import datetime 39 start_date = datetime.date(2018, 9, 5) 40 #lte：小于等于某个时间点 41 now = datetime.datetime.now() 42 start = now-datetime.timedelta(hours=23,minutes=59,seconds=59) 43 #查询 2018年9月4日当日以及当天之前产生的日志。 44 obj=models.TaskLog.objects.filter(date__lte=start) 45 print(obj) 46 47 E.range：查询某个明确时间段数据 (某个时间段） 48 import datetime 49 start_date = datetime.date(2018, 9, 5) 50 end_date = datetime.date(2018, 9,8) 51 #查询 2018年9月5日 ------- 2018年9月8日 期间产生的日志 52 obj=models.TaskLog.objects.filter(date__range=(start_date,end_date)) 53 print(obj) 54 55 F.__year查询某年产生数据（例如：2018） 56 #查询2018年产生的日志 57 obj=models.TaskLog.objects.filter(date__year=2018) 58 print(obj) 59 60 G.__month查询 某月产生的数据（例：2018年9月） 61 #查询9月产生的数据 62 obj=models.TaskLog.objects.filter(date__year=2018,date__month=9) 63 print(obj) 64 65 H.__week_day查询某年、某月、星期几产生的数据（例如：2018年9月份 每个星期5） 66 #查询 某年 某月 周几 产生的数据 67 #0-6表示：周1至周五 68 obj=models.TaskLog.objects.filter(date__year=2018,date__month=9,date__week_day=4).count() 69 print(obj) 70 71 I.查询某年、某月、某天产生的数据 （例：2018年9月10日） 72 obj=models.TaskLog.objects.filter(date__year=2018,date__month=9,date__day=10).count() 73 print(obj) 74
<1> all(): 查询所有结果 <2> filter(**kwargs): 它包含了与所给筛选条件相匹配的对象 <3> get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。 <4> exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象 <5> values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列 <6> values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列 <7> order_by(*field): 对查询结果排序 <8> reverse(): 对查询结果反向排序，请注意reverse()通常只能在具有已定义顺序的QuerySet上调用(在model类的Meta中指定ordering或调用order_by()方法)。 <9> distinct(): 从返回结果中剔除重复纪录(如果你查询跨越多个表，可能在计算QuerySet时得到重复的结果。此时可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。) <10> count(): 返回数据库中匹配查询(QuerySet)的对象数量。 <11> first(): 返回第一条记录 <12> last(): 返回最后一条记录 <13> exists(): 如果QuerySet包含数据，就返回True，否则返回False 