03: Django Model数据库操作
目录:Django其他篇
05:ModelForm 数据验证 & 生成html & 数据库操作
目录:
- 1.1 Django中使用MySQL
- 1.2 创建表
- 1.3 Django一对多表结构操作
- 1.4 Django多对多表结构操作
- 1.5 一大波Model操作
- 1.6 Model性能相关操作:select_related、prefetch_related
- 1.7 F()和Q()查询语句
- 1.8 aggregate和annotate聚合函数 : 求平均值、最大值、最小值等
- 1.9 Trunc函数处理日期格式数据
- 1.10 Django其他查询语句
1.1 Django中使用MySQL 返回顶部
1、先写类:在 app01/models.py中写类
from django.db import models class UserInfo(models.Model): uid = models.AutoField(primary_key=True) # 自增id username = models.CharField(max_length=32) password = models.CharField(max_length=64)
2、在Django项目中使用MySQL
1. 创建管理员密码,与数据库
1. mysqladmin -uroot password 123456 # 用户名:root 密码:123456
2. mysql -uroot -p # dos下登录MySQL
3. create database MyCRM charset utf8; # 创建数据库MyCRM
4. drop database MyCRM; # 如果需要也可以把数据库删除
5. show databases; # 查看现有数据库
2. 配置使用MySQL(修改settings.py配置文件)
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'MyCRM', # 指定数据库名称:MyCRM 'USER': 'root', 'PASSWORD': '123456', 'HOST': '127.0.0.1', 'PORT': '3306', } } '''注释默认数据库配置''' # DATABASES = { # 'default': { # 'ENGINE': 'django.db.backends.sqlite3', # 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), # } # }
3. 主动修改为pymysql
1. Django默认使用MySQLdb模块链接MySQL,但在python3中还没有MySQLdb
2. 主动修改为pymysql,在project同名文件夹下的__init__文件中添加如下代码即可
import pymysql pymysql.install_as_MySQLdb()
4. 创建表 (记得注册APP)
python manage.py makemigrations
python manage.py migrate --fake
5. 远程链接MySQL报错问题解决
#1、例如,你想myuser使用mypassword从任何主机连接到mysql服务器的话。 # GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%' IDENTIFIED BY 'mypassword' WITH GRANT OPTION; # FLUSH PRIVILEGES; #2、如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器,并使用mypassword作为密码 # GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'192.168.1.3' IDENTIFIED BY 'mypassword' WITH GRANT OPTION; # FLUSH PRIVILEGES; #3、如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器的dk数据库,并使用mypassword作为密码 # GRANT ALL PRIVILEGES ON dk.* TO 'myuser'@'192.168.1.3' IDENTIFIED BY 'mypassword' WITH GRANT OPTION; # FLUSH PRIVILEGES;
# mysql -u root -pvmwaremysql>use mysql; # mysql>update user set host = '%' where user = 'root'; # mysql>select host, user from user;
1.2 创建表 返回顶部
1、创建表基本语法
from django.db import models class UserInfo(models.Model): uid = models.AutoField(primary_key=True) # 自增id username = models.CharField(max_length=32) password = models.CharField(max_length=64)
2、元信息Meta
from django.db import models class UserInfo(models.Model): username = models.CharField(max_length=32) password = models.CharField(max_length=32) class Meta: #1 数据库中生成的表名称 默认 app名称 + 下划线 + 类名 db_table = "table_name" #自己指定创建的表名 #2 Django Admin 中显示的表名称 verbose_name='user' #在Django admin后台显示时表名是users #3 verbose_name加s verbose_name_plural='user' #若果这个字段也是user那么4中表名才显示user #4 联合唯一索引 unique_together = (("name", "password"),) #5 联合索引 (缺点是最左前缀,写SQL语句基于password时不能命中索引,查找慢) # 如:select * from tb where password = ‘xx’ 就无法命中索引 index_together = [ ("name", "password"), ] # 更多:https://docs.djangoproject.com/en/1.10/ref/models/options/
3、字段
from django.db import models class UserGroup(models.Model): uid = models.AutoField(primary_key=True) name = models.CharField(max_length=32,null=True, blank=True) email = models.EmailField(max_length=32) text = models.TextField() ctime = models.DateTimeField(auto_now_add=True) # 只有添加时才会更新时间 uptime = models.DateTimeField(auto_now=True) # 只要修改就会更新时间 ip1 = models.IPAddressField() # 字符串类型,Django Admin以及ModelForm中提供验证 IPV4 机制 ip2 = models.GenericIPAddressField() # 字符串类型,Django Admin以及ModelForm中提供验证 Ipv4和Ipv6 active = models.BooleanField(default=True) data01 = models.DateTimeField() # 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ data02 = models.DateField() # 日期格式 YYYY-MM-DD data03 = models.TimeField() # 时间格式 HH:MM[:ss[.uuuuuu]] age = models.PositiveIntegerField() # 正小整数 0 ~ 32767 balance = models.SmallIntegerField() # 小整数 -32768 ~ 32767 money = models.PositiveIntegerField() # 正整数 0 ~ 2147483647 bignum = models.BigIntegerField() # 长整型(有符号的) -9223372036854775808 ~ 9223372036854775807 user_type_choices = ( (1, "超级用户"), (2, "普通用户"), (3, "普普通用户"), ) user_type_id = models.IntegerField(choices=user_type_choices, default=1)
URLField(CharField) - 字符串类型,Django Admin以及ModelForm中提供验证 URL SlugField(CharField) - 字符串类型,Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符(减号) CommaSeparatedIntegerField(CharField) - 字符串类型,格式必须为逗号分割的数字 UUIDField(Field) - 字符串类型,Django Admin以及ModelForm中提供对UUID格式的验证 FilePathField(Field) - 字符串,Django Admin以及ModelForm中提供读取文件夹下文件的功能 - 参数: path, 文件夹路径 match=None, 正则匹配 recursive=False, 递归下面的文件夹 allow_files=True, 允许文件 allow_folders=False, 允许文件夹 FileField(Field) - 字符串,路径保存在数据库,文件上传到指定目录 - 参数: upload_to = "" 上传文件的保存路径 storage = None 存储组件,默认django.core.files.storage.FileSystemStorage ImageField(FileField) - 字符串,路径保存在数据库,文件上传到指定目录 - 参数: upload_to = "" 上传文件的保存路径 storage = None 存储组件,默认django.core.files.storage.FileSystemStorage width_field=None, 上传图片的高度保存的数据库字段名(字符串) height_field=None 上传图片的宽度保存的数据库字段名(字符串) DurationField(Field) - 长整数,时间间隔,数据库中按照bigint存储,ORM中获取的值为datetime.timedelta类型 FloatField(Field) - 浮点型 DecimalField(Field) - 10进制小数 - 参数: max_digits,小数总长度 decimal_places,小数位长度 BinaryField(Field) - 二进制类型
4、参数
null 数据库中字段是否可以为空 default 数据库中字段的默认值 primary_key 数据库中字段是否为主键 db_index 数据库中字段是否可以建立索引 unique 数据库中字段是否可以建立唯一索引 verbose_name Admin中显示的字段名称 blank Admin中是否允许用户输入为空 editable Admin中是否可以编辑 help_text Admin中该字段的提示信息 error_messages 自定义错误信息(字典类型),从而定制想要显示的错误信息; 字典健:null, blank, invalid, invalid_choice, unique, and unique_for_date 如:{'null': "不能为空.", 'invalid': '格式错误'} db_column 数据库中字段的列名 db_tablespace unique_for_date 数据库中字段【日期】部分是否可以建立唯一索引 unique_for_month 数据库中字段【月】部分是否可以建立唯一索引 unique_for_year 数据库中字段【年】部分是否可以建立唯一索引 choices Admin中显示选择框的内容,用不变动的数据放在内存中从而避免跨表操作 如:gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1) validators 自定义错误验证(列表类型),从而定制想要的验证规则 from django.core.validators import RegexValidator from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\ MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator 如: test = models.CharField( max_length=32, error_messages={ 'c1': '优先错信息1', 'c2': '优先错信息2', 'c3': '优先错信息3', }, validators=[ RegexValidator(regex='root_\d+', message='错误了', code='c1'), RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'), EmailValidator(message='又错误了', code='c3'), ] )
1.3 Django一对多表结构操作 返回顶部
1、一对多基本增删改查
from django.db import models class UserInfo(models.Model): name = models.CharField(max_length=64,unique=True) ut = models.ForeignKey(to='UserType') class UserType(models.Model): type_name = models.CharField(max_length=64,unique=True)
from django.shortcuts import render,HttpResponse from app01 import models def orm(request): # 1 创建 # 创建数据方法一 models.UserInfo.objects.create(name='root', ut_id=2) # 创建数据方法二 obj = models.UserInfo(name='root', ut_id=2) obj.save() # 创建数据库方法三(传入字典必须在字典前加两个星号) dic = {'name': 'root', 'ut_id': 2} models.UserInfo.objects.create(**dic) # 2 删除 # models.UserInfo.objects.all().delete() # 删除所有 models.UserInfo.objects.filter(name='root').delete() # 删除指定 # 3 更新 # models.UserInfo.objects.all().update(ut_id=1) # models.UserInfo.objects.filter(name='zhangsan').update(ut_id=4) # 4.1 正向查找 user_obj.ut.type_name print( models.UserInfo.objects.get(name='zhangsan').ut.type_name ) print( models.UserInfo.objects.filter(ut__type_name='student') ) # 4.2 反向查找 type_obj.userinfo_set.all() print( models.UserType.objects.get(type_name='student').userinfo_set.all() ) print( models.UserType.objects.get(type_name='student').userinfo_set.filter(name='zhangsan') ) return HttpResponse('orm')
2、一对多更多查询操作
from django.db import models class UserType(models.Model): user_type_name = models.CharField(max_length=32) def __str__(self): return self.user_type_name #只有加上这个,Django admin才会显示表名 class User(models.Model): username = models.CharField(max_length=32) pwd = models.CharField(max_length=64) ut = models.ForeignKey( to='UserType', to_field='id', # 1、反向操作时,使用的连接前缀,用于替换【表名】 # 如: models.UserGroup.objects.filter(a__字段名=1).values('a__字段名') related_query_name='a', #2、反向操作时,使用的字段名,用于代替 【表名_set】 如: obj.b_set.all() # 使用时查找报错 # related_name='b', )
from django.shortcuts import HttpResponse from app01 import models def orm(request): # 1 正向查找 #1.1 正向查找user表用户名 print(models.User.objects.get(username='zhangsan').username) # zhangsan #1.2 正向跨表查找用户类型 print(models.User.objects.get(username='zhangsan').ut.user_type_name) # student #1.3 双下划线正向跨表正向查找 print( models.User.objects.all().values('ut__user_type_name','username') ) # 2 反向查找 # 2.1:【表名_set】,反向查找user表中用户类型为student 的所有用户 print( models.UserType.objects.get(user_type_name='student').user_set.all() ) # [<User: lisi>, <User: wangwu>] # 2.2:【a__字段名】反向查找user表中张三在UserType表中的类型:([<UserType: teacher>]) print( models.UserType.objects.filter(a__username='zhangsan') ) # student # 这里的a是user表的ForeignKey字段的参数:related_query_name='a' # 2.3: 双下划线跨表反向查找 print( models.UserType.objects.all().values('a__username', 'user_type_name') ) # 3 自动创建User表和UserType表中的数据 ''' username = [{'username':'zhangsan','pwd':'123','ut_id':'1'}, {'username':'lisi','pwd':'123','ut_id':'1'}, {'username':'wangwu','pwd':'123','ut_id':'1'},] user_type = [{'user_type_name':'student'},{'user_type_name':'teacher'},] for type_dic in user_type: models.UserType.objects.create(**type_dic) for user_dic in username: models.User.objects.create(**user_dic) ''' return HttpResponse('orm')
3、一对多使用values和values_list结合双下划线跨表查询
from django.shortcuts import HttpResponse from app01 import models def orm(request): # 第一种:values-----获取的内部是字典 拿固定列数 # 1.1 正向查找: 使用ForeignKey字段名ut结合双下划线查询 models.User.objects.filter(username='zhangsan').values('username', 'ut__user_type_name') # 1.2 向查找: 使用ForeignKey的related_query_name='a',的字段 models.UserType.objects.all().values('user_type_name', 'a__username') # 第二种:values_list-----获取的是元组 拿固定列数 # 1.1 正向查找: 使用ForeignKey字段名ut结合双下划线查询 stus = models.User.objects.filter(username='zhangsan').values_list('username', 'ut__user_type_name') # 1.2 反向查找: 使用ForeignKey的related_query_name='a',的字段 utype = models.UserType.objects.all().values_list('user_type_name', 'a__username') # 3 自动创建User表和UserType表中的数据 ''' username = [{'username':'zhangsan','pwd':'123','ut_id':'1'}, {'username':'lisi','pwd':'123','ut_id':'1'}, {'username':'wangwu','pwd':'123','ut_id':'1'},] user_type = [{'user_type_name':'student'},{'user_type_name':'teacher'},] for type_dic in user_type: models.UserType.objects.create(**type_dic) for user_dic in username: models.User.objects.create(**user_dic) ''' return HttpResponse('orm')
4、一对多ForeignKey可选参数
1、to, # 要进行关联的表名 2、to_field=None, # 要关联的表中的字段名称 3、on_delete=None, # 当删除关联表中的数据时,当前表与其关联的行的行为 - models.CASCADE # ,删除关联数据,与之关联也删除 - models.DO_NOTHING # ,删除关联数据,引发错误IntegrityError - models.PROTECT # ,删除关联数据,引发错误ProtectedError - models.SET_NULL # ,删除关联数据,与之关联的值设置为null(前提FK字段需要设置为可空) - models.SET_DEFAULT # ,删除关联数据,与之关联的值设置为默认值(前提FK字段需要设置默认值) - models.SET # ,删除关联数据, 4、related_name=None, # 反向操作时,使用的字段名,用于代替 【表名_set】 如: obj.表名_set.all() # 在做自关联时必须指定此字段,防止查找冲突 5、delated_query_name=None, # 反向操作时,使用的连接前缀,用于替换【表名】 # 如:models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名') 6、limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时,提供的条件: - limit_choices_to={'nid__gt': 5} - limit_choices_to=lambda : {'nid__gt': 5} 7、db_constraint=True # 是否在数据库中创建外键约束 8、parent_link=False # 在Admin中是否显示关联数据
1.4 Django多对多表结构操作 返回顶部
1、创建并操作多对多表
1. 第一种: 自己不创建第三张关系表,有m2m字段: 根据queryset对象增删改查(推荐)
from django.db import models class UserInfo(models.Model): username = models.CharField(max_length=32) def __str__(self): return self.username class UserGroup(models.Model): group_name = models.CharField(max_length=64) user_info = models.ManyToManyField(to='UserInfo',related_query_name='m2m') def __str__(self): return self.group_name
from django.shortcuts import HttpResponse from app01 import models def orm(request): user_info_obj = models.UserInfo.objects.get(username='zhangsan') user_info_objs = models.UserInfo.objects.all() group_obj = models.UserGroup.objects.get(group_name='group_python') group_objs = models.UserGroup.objects.all() # 添加: 正向 group_obj.user_info.add(user_info_obj) group_obj.user_info.add(*user_info_objs) # 删除:正向 group_obj.user_info.remove(user_info_obj) group_obj.user_info.remove(*user_info_objs) # 添加: 反向 user_info_obj.usergroup_set.add(group_obj) user_info_obj.usergroup_set.add(*group_objs) # 删除:反向 user_info_obj.usergroup_set.remove(group_obj) user_info_obj.usergroup_set.remove(*group_objs) # 查找:正向 print(group_obj.user_info.all()) # 查找group_python组中所有用户 print(group_obj.user_info.all().filter(username='zhangsan')) # 查找:反向 print(user_info_obj.usergroup_set.all()) # 查找用户zhangsan属于那些组 print(user_info_obj.usergroup_set.all().filter(group_name='group_python')) # 双下划线 正向、反向查找 # 正向:从用户组表中查找zhangsan属于哪个用户组:[<UserGroup: group_python>] print( models.UserGroup.objects.filter(user_info__username='zhangsan')) # 反向:从用户表中查询group_python组中有哪些用户:related_query_name='m2m' print( models.UserInfo.objects.filter(m2m__group_name='group_python')) # 自动创建UserInfo表和UserGroup表中的数据 ''' user_list = [{'username':'zhangsan'}, {'username':'lisi'}, {'username':'wangwu'},] group_list = [{'group_name':'group_python'}, {'group_name':'group_linux'}, {'group_name':'group_mysql'},] for c in user_list: models.UserInfo.objects.create(**c) for l in group_list: models.UserGroup.objects.create(**l) ''' return HttpResponse('orm')
2. 第二种: 自己创建第三张关系表,无 m2m 字段,自己链表查询
from django.db import models #表1:主机表 class Host(models.Model): nid = models.AutoField(primary_key=True) hostname = models.CharField(max_length=32,db_index=True) #表2:应用表 class Application(models.Model): name = models.CharField(max_length=32) #表3:自定义第三张关联表 class HostToApp(models.Model): hobj = models.ForeignKey(to="Host",to_field="nid") aobj = models.ForeignKey(to='Application',to_field='id') # 向第三张表插入数据,建立多对多外键关联 HostToApp.objects.create(hobj_id=1,aobj_id=2)
3. 第三种: 自己不创建第三张关系表,有m2m字段: 根据数字id增删改查
from django.db import models class Host(models.Model): hostname = models.CharField(max_length=32,db_index=True) class Group(models.Model): group_name = models.CharField(max_length=32) m2m = models.ManyToManyField("Host")
from django.shortcuts import HttpResponse from app01 import models def orm(request): # 使用间接方法对第三张表操作 obj = models.Group.objects.get(id=1) # 1、添加 obj.m2m.add(1) # 在第三张表中增加一个条目(1,1) obj.m2m.add(2, 3) # 在第三张表中增加条目(1,2)(1,3)两条关系 obj.m2m.add(*[1,3]) # 在第三张表中增加条目(1,2)(1,3)两条关系 # 2、删除 obj.m2m.remove(1) # 删除第三张表中的(1,1)条目 obj.m2m.remove(2, 3) # 删除第三张表中的(1,2)(1,3)条目 obj.m2m.remove(*[1, 2, 3]) # 删除第三张表中的(1,1)(1,2)(1,3)条目 # 3、清空 obj.m2m.clear() # 删除第三张表中application条目等于1的所有条目 # 4 更新 obj.m2m.set([1, 2,]) # 第三张表中会删除所有条目,然后创建(1,1)(1,2)条目 # 5 查找 print( obj.m2m.all() ) # 等价于 models.UserInfo.objects.all() # 6 反向查找: 双下划线 hosts = models.Group.objects.filter(m2m__id=1) # 在Host表中id=1的主机同时属于那些组 # 自动创建Host表和Group表中的数据 ''' hostname = [{'hostname':'zhangsan'}, {'hostname':'lisi'}, {'hostname':'wangwu'},] group_name = [{'group_name':'DBA'},{'group_name':'public'},] for h in hostname: models.Host.objects.create(**h) for u in group_name: models.Group.objects.create(**u) ''' return HttpResponse('orm')
2、多对多使用values和values_list结合双下划线跨表查询
from django.shortcuts import HttpResponse from app01 import models def orm(request): # 第一种:values-----获取的内部是字典,拿固定列数 # 1.1 正向查找: 使用ManyToManyField字段名user_info结合双下划线查询 models.UserGroup.objects.filter(group_name='group_python').values('group_name', 'user_info__username') # 1.2 反向查找: 使用ManyToManyField的related_query_name='m2m',的字段 models.UserInfo.objects.filter(username='zhangsan').values('username', 'm2m__group_name') # 第二种:values_list-----获取的是元组 拿固定列数 # 2.1 正向查找: 使用ManyToManyField字段名user_info结合双下划线查询 models.UserGroup.objects.filter(group_name='group_python').values_list('group_name', 'user_info__username') # 2.2 反向查找: 使用ManyToManyField的related_query_name='m2m',的字段 lesson = models.UserInfo.objects.filter(username='zhangsan').values_list('username', 'm2m__group_name') # 自动创建UserInfo表和UserGroup表中的数据 ''' # user_info_obj = models.UserInfo.objects.get(username='lisi') # user_info_objs = models.UserInfo.objects.all() # # group_obj = models.UserGroup.objects.get(group_name='group_python') # group_objs = models.UserGroup.objects.all() # # group_obj.user_info.add(*user_info_objs) # user_info_obj.usergroup_set.add(*group_objs) user_list = [{'username':'zhangsan'}, {'username':'lisi'}, {'username':'wangwu'},] group_list = [{'group_name':'group_python'}, {'group_name':'group_linux'}, {'group_name':'group_mysql'},] for c in user_list: models.UserInfo.objects.create(**c) for l in group_list: models.UserGroup.objects.create(**l) ''' return HttpResponse('orm')
3、创建m2m多对多时ManyToManyField可以添加的参数
1、to, # 要进行关联的表名 2、related_name=None, # 反向操作时,使用的字段名,用于代替 【表名_set】如: obj.表名_set.all() 3、related_query_name=None, # 反向操作时,使用的连接前缀,用于替换【表名】 # 如: models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名') 4、limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时,提供的条件: # - limit_choices_to={'nid__gt': 5} 5、symmetrical=None, # 用于多对多自关联,symmetrical用于指定内部是否创建反向操作字段 6、through=None, # 自定义第三张表时,使用字段用于指定关系表 7、through_fields=None, # 自定义第三张表时,使用字段用于指定关系表中那些字段做多对多关系表 8、db_constraint=True, # 是否在数据库中创建外键约束 db_table=None, # 默认创建第三张表时,数据库中表的名称
1.5 一大波Model操作 返回顶部
from django.shortcuts import HttpResponse from app01 import models def orm(request): # 1 创建 # 创建数据方法一 models.UserInfo.objects.create(username='root', password='123') # 创建数据方法二 obj = models.UserInfo(username='alex', password='123') obj.save() # 创建数据库方法三(传入字典必须在字典前加两个星号) dic = {'username': 'eric', 'password': '666'} models.UserInfo.objects.create(**dic) # 2 查 result = models.UserInfo.objects.all() # 查找所有条目 result = models.UserInfo.objects.filter(username='alex', password='123') for row in result: print(row.id, row.username, row.password) # 3 删除 models.UserInfo.objects.all().delete() # 删除所有 models.UserInfo.objects.filter(username='alex').delete() # 删除指定 # 4 更新 models.UserInfo.objects.all().update(password='12345') models.UserInfo.objects.filter(id=4).update(password='15') # 5 获取个数 models.UserInfo.objects.filter(name='seven').count() # 6 执行原生SQL # 6.1 执行原生SQL models.UserInfo.objects.raw('select * from userinfo') # 6.2 如果SQL是其他表时,必须将名字设置为当前UserInfo对象的主键列名 models.UserInfo.objects.raw('select id as nid from 其他表') # 6.3 指定数据库 models.UserInfo.objects.raw('select * from userinfo', using="default") return HttpResponse('orm')
1、大于,小于 # models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值 # models.Tb1.objects.filter(id__gte=1) # 获取id大于等于1的值 # models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值 # models.Tb1.objects.filter(id__lte=10) # 获取id小于10的值 # models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值 2、in # models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据 # models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in 3、isnull # Entry.objects.filter(pub_date__isnull=True) #双下划线isnull,查找pub_date是null的数据 4、contains #就是原生sql的like操作:模糊匹配 # models.Tb1.objects.filter(name__contains="ven") # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感 # models.Tb1.objects.exclude(name__icontains="ven") 5、range # models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and 6、order by # models.Tb1.objects.filter(name='seven').order_by('id') # asc 没有减号升续排列 # models.Tb1.objects.filter(name='seven').order_by('-id') # desc 有减号升续排列 7、group by # from django.db.models import Count, Min, Max, Sum # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num')) #根据id列进行分组 # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" # WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id" 8、limit 、offset #分页 # models.Tb1.objects.all()[10:20] 9、regex正则匹配,iregex 不区分大小写 # Entry.objects.get(title__regex=r'^(An?|The) +') # Entry.objects.get(title__iregex=r'^(an?|the) +') 10、date # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1)) #__data表示日期查找,2005-01-01 # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1)) 11、year # Entry.objects.filter(pub_date__year=2005) #__year根据年查找 # Entry.objects.filter(pub_date__year__gte=2005) 12、month # Entry.objects.filter(pub_date__month=12) # Entry.objects.filter(pub_date__month__gte=6) 13、day # Entry.objects.filter(pub_date__day=3) # Entry.objects.filter(pub_date__day__gte=3) 14、week_day # Entry.objects.filter(pub_date__week_day=2) # Entry.objects.filter(pub_date__week_day__gte=2) 15、hour # Event.objects.filter(timestamp__hour=23) # Event.objects.filter(time__hour=5) # Event.objects.filter(timestamp__hour__gte=12) 16、minute # Event.objects.filter(timestamp__minute=29) # Event.objects.filter(time__minute=46) # Event.objects.filter(timestamp__minute__gte=29) 17、second # Event.objects.filter(timestamp__second=31) # Event.objects.filter(time__second=2) # Event.objects.filter(timestamp__second__gte=31)
from django.utils import timezone from report.models import * now = timezone.now() # start_time = now - timezone.timedelta(days=7) start_time = now - timezone.timedelta(hours=240) # 查询10天前的数据 end_time = now qs = AllClarm.objects.filter(start_tm__range=(start_time, end_time))
#! /usr/bin/env python # -*- coding: utf-8 -*- from django.db import models from django.shortcuts import render, get_object_or_404 class SLAGroup(models.Model): name = models.CharField(max_length=100, verbose_name='组名') weight = models.FloatField(verbose_name='权重') description = models.CharField(max_length=255, verbose_name='描述', null=True, blank=True) group = get_object_or_404(SLAGroup, id=1) # 查询id=1的数据,否则就显示404页面 SLAGroup.objects.get_or_create(name='hadoop',weight='15') # 获取或创建
1.6 Model性能相关操作:select_related、prefetch_related 返回顶部
1、普通查询的缺点
1. 例:现在有两张表user,和group两张表,在user表中使用m作为ForeignKey与group表进行一对多关联
2. 如果通过user表中的实例查找对应的group表中的数据,就必须重复发sql请求
3. prefetch_related()和select_related()的设计目,都是为了减少SQL查询的数量,但是实现的方式不一样
2、select_related作用
1. select_related主要针一对一和多对一关系进行优化。
2. select_related使用SQL的JOIN语句进行优化,通过减少SQL查询的次数来进行优化、提高性能。
3、prefetch_related()作用
1. prefetch_related()主要对于多对多字段和一对多字段进行优化
2. 进行两次sql查询,将查询结果拼接成一张表放到内存中,再查询就不用发sql请求
4、select_related与prefetch_related 使用原则
1. prefetch_related()和select_related()的设计目的很相似,都是为了减少SQL查询的数量,但是实现的方式不一样
2. 因为select_related()总是在单次SQL查询中解决问题,而prefetch_related()会对每个相关表进行SQL查询,因此select_related()的效率高
3. 所以尽可能的用select_related()解决问题。只有在select_related()不能解决问题的时候再去想prefetch_related()。
5、select_related举例说明
作用:使用SQL的JOIN语句进行优化,通过减少SQL查询的次数来进行优化
def index(request): #1 这种方法低效 users = models.User.objects.all() #拿到的仅仅是user表中内容 for row in users: print(row.user,row.ut_id) #这里打印user表中的内容不必再次sql请求 print(row.ut.name) #第一次查表,没有拿到关联表ut字段中的内容 #所以每次循环都会再次发sql请求,拿到ut.name的值,低效 #2 使用这种方法也仅需要一次数据库查询(拿到的是字典),但是如果查找的不在那些字段中直接报错 users = models.User.objects.all().values('user','pwd','ut__name') #3 select_related()可以一次sql查询拿到所有关联表信息 users = models.User.objects.all().select_related() # 这里还支持指定只拿到那个关联表的所有信息,比如:有多个外键关联,只拿到与ut外键关联的表 users = models.User.objects.all().select_related('ut') # select_related() 接受depth参数,depth参数可以确定select_related的深度。 # Django会递归遍历指定深度内的所有的OneToOneField和ForeignKey。以本例说明: # zhangs = Person.objects.select_related(depth = d) # d=1 相当于 select_related(‘hometown’,'living’) # d=2 相当于 select_related(‘hometown__province’,'living__province’)
6、prefetch_related举例说明
作用:进行两次sql查询,将查询结果拼接成一张表
def index(request): users = models.User.objects.filter(id__gt=30).prefetch_related('ut') #ut和tu是user表的两个foreign key,分别关联不同的表 users = models.User.objects.filter(id__gt=30).prefetch_related('ut','tu') #1 先执行第一次sql查询:select * from users where id > 30; #2 比如:第一次查询结果,获取上一步骤中所有ut_id=[1,2] #3 然后执行第二次sql查询:select * from user_type where id in [1,2] #4 这样就仅执行了两次sql查询将两个表的数据拼到一起,放到内存中,再查询就不用发sql请求 for row in users: print(row.user,row.ut_id) #这里打印user表中的内容不必再次sql请求
1.7 F()和Q()查询语句 返回顶部
from django.db import models class Student(models.Model): name = models.CharField(max_length=32) age = models.IntegerField() def __str__(self): return self.name
1、F() ---- 专门取对象中某列值的操作
作用:F()允许Django在未实际链接数据的情况下具有对数据库字段的值的引用
from django.shortcuts import HttpResponse from app01 import models from django.db.models import F,Q def orm(request): # 每访问一次数据库中zhangsan的年纪就会自动增加1 models.Student.objects.filter(name='zhangsan').update(age=F("age") + 1) # 自动生成Student表中数据 ''' stu_list = [{'name':'zhangsan','age':11}, {'name': 'lisi', 'age': 22}, {'name': 'wangwu', 'age': 33},] for u in stu_list: models.Student.objects.create(**u) ''' return HttpResponse('orm')
2.1、Q() ---- 复杂查询(用法1)
1、Q对象(django.db.models.Q)可以对关键字参数进行封装,从而更好地应用多个查询
2、可以组合使用 &(and),|(or),~(not)操作符,当一个操作符用于两个Q的对象,它产生一个新的Q对象
3、如: Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
from django.shortcuts import HttpResponse from app01 import models from django.db.models import F,Q def orm(request): # 查找学生表中年级大于1小于30姓zhang的所有学生 stus = models.Student.objects.filter( Q(age__gt=1) & Q(age__lt=30), Q(name__startswith='zhang') ) print('stu',stus) #运行结果:[<Student: zhangsan>] # 自动生成Student表中数据 ''' stu_list = [{'name':'zhangsan','age':11}, {'name': 'lisi', 'age': 22}, {'name': 'wangwu', 'age': 33},] for u in stu_list: models.Student.objects.create(**u) ''' return HttpResponse('orm')
2.2、Q() ---- 动态添加多个and和or查询条件(用法2)
def table_search(request,admin_class,object_list): search_key = request.GET.get('_q','') q_obj = Q() q_obj.connector = 'OR' for column in admin_class.search_fields: q_obj.children.append(('%s__contains'%column,search_key)) res = object_list.filter(q_obj) return res
# or动态添加多个查询条件 >>> from crm import models >>> from django.db.models import Q >>> con = Q() #1. 实例化一个Q()查询类 >>> con.connector = "OR" #2. 指定使用‘OR’条件 >>> con.children.append(('qq__contains','123')) #3. qq字段中包含‘123’ >>> con.children.append(('name__contains','name0')) #4. name字段中包含‘naem0’ >>> con <Q: (OR: ('qq__contains', '123'), ('name__contains', 'name0'))> #5. 查找name字段中包含‘naem0’或qq字段包含‘123’的所有条目 >>> models.Customer.objects.values('qq','name').filter(con)
# and和or结合查询 #1. 导入模块 >>> from crm import models >>> from django.db.models import Q #2. q1:查询id=1或者id=2的所有条目 (or条件) >>> q1 = Q() >>> q1.connector = 'OR' >>> q1.children.append(('id',1)) >>> q1.children.append(('id',2)) #3. q2:查询id=1的所有条目 (or条件) >>> q2 = Q() >>> q2.connector = 'OR' >>> q2.children.append(('id',1)) #4. con:结合q1和q2条件结果是查询id=1的所有条目 (结合q1,q2的and条件) >>> con = Q() >>> con.add(q1,'AND') <Q: (OR: ('id', 1), ('id', 2))> >>> con.add(q2,'AND') <Q: (AND: (OR: ('id', 1), ('id', 2)), ('id', 1))> >>> models.Customer.objects.values('qq','name').filter(con) <QuerySet [{'qq': '123456765432', 'name': 'haha'}]>
1.8 aggregate和annotate聚合函数 : 求平均值、最大值、最小值等 返回顶部
1、aggregate聚合函数
作用:从数据库中取出一个汇总的集合
from django.db.models import Count,Avg,Max,Sum def orm(request): stus = models.Student.objects.aggregate( stu_num=Count('age'), #计算学生表中有多少条age条目 stu_avg=Avg('age'), #计算学生的平均年纪 stu_max=Max('age'), #找到年纪最大的学生 stu_sum=Sum('age')) #将表中的所有年纪相加 print('stu',stus) return HttpResponse('ok') #运行结果:{'stu_sum': 69, 'stu_max': 24, 'stu_avg': 23.0, 'stu_num': 3}
2、annotate实现聚合group by查询
作用:对查询结果进行分组,比如分组求出各年龄段的人数
注: annotate后面加filter过滤相当于原生sql语句中的having
from django.db.models import Count, Avg, Max, Min, Sum def orm(request): #1 按年纪分组查找学生表中各个年龄段学生人数:(22岁两人,24岁一人) # 查询结果:[{'stu_num': 2, 'age': 22}, {'stu_num': 1, 'age': 24}] stus1 = models.Student.objects.values('age').annotate(stu_num=Count('age')) #2 按年纪分组查找学生表中各个年龄段学生人数,并过滤出年纪大于22的: # 查询结果:[{'stu_num': 1, 'age': 24}] (年级大于22岁的仅一人,年级为24岁) stus2 = models.Student.objects.values('age').annotate(stu_num=Count('age')).filter(age__gt=22) #3 先按年纪分组,然后查询出各个年龄段学生的平均成绩 # 查询结果:[{'stu_Avg': 86.5, 'age': 22}, {'stu_Avg': 99.0, 'age': 24}] # 22岁平均成绩:86.5 24岁平均成绩:99 stus3 = models.Student.objects.values('age').annotate(stu_Avg=Avg('grade')) return HttpResponse('ok')
3、aggregate和annotate区别
1. Aggregate作用是从数据库取出一个汇总的数据(比如,数量,最大,最小,平均等)
2. 而annotate是先按照设定的条件对数据进行分组,然后根据不同组分别对数据进行汇总
1.9 Trunc函数处理日期格式数据 返回顶部
1、Trunc函数作用 及 参数说明
1、作用:Trunk可以将时间处理成,只有年,或月或日等格式,那些不关心的部分都会变成0
2、Trunk函数可以传入下面四个参数:
a、expression :传入数据库表中对应要处理的时间那个字段名字
b、kind :是时间格式的一部分,可以是 year,month,day,hour,minute,second
,kind指定最后处理后的时间精确到哪一个部分
c、output_field :只能是这三个格式:DateTimeField(), TimeField(), or DateField()
最后返回的是datetime,date,或则time 就取决于 output_field 字段是如何指定的
d、tzinfosubclass:通常由pytz提供,可以传递给截断值指定一个特定的时区。
3、如果给出的时间是 datetime 2015-06-15 14:30:50.000321+00:00, 使用下面六种 kinds 最后返回结果如下
“year”: 2015-01-01 00:00:00+00:00
“month”: 2015-06-01 00:00:00+00:00
“day”: 2015-06-15 00:00:00+00:00
“hour”: 2015-06-15 14:00:00+00:00
“minute”: 2015-06-15 14:30:00+00:00
“second”: 2015-06-15 14:30:50+00:00
2、解决时差配置问题的报错
1. 错误:Are time zone definitions for your database and pytz installed?
2. 解决方法:安装pytz模块,在Django settings中配置数据库的时区: pip3 install pytz
# 注释的是数据库默认的配置 # LANGUAGE_CODE = 'en-us' # TIME_ZONE = 'UTC' # USE_TZ = True USE_TZ = False LANGUAGE_CODE = 'zh-Hans' TIME_ZONE = 'Asia/Chongqing'
3、Trunk函数基本使用
from django.db import models class Experiment(models.Model): start_datetime = models.DateTimeField()
from django.shortcuts import HttpResponse from .models import * from datetime import datetime from django.db.models import Count, DateTimeField from django.db.models.functions import Trunc def orm(request): #1 首先向Experiment表中插入三条数据 Experiment.objects.create(start_datetime=datetime(2015, 6, 15, 14, 30, 50, 321)) Experiment.objects.create(start_datetime=datetime(2015, 6, 15, 14, 40, 2, 123)) Experiment.objects.create(start_datetime=datetime(2015, 12, 25, 10, 5, 27, 999)) #2 使用Trunk过滤出start_datetime字段,仅保存到日,后面的时分秒全部变成0 #3 annotate(experiments=Count('id'))可以根据天进行分组 experiments_per_day = Experiment.objects.annotate( start_day=Trunc('start_datetime', 'day', output_field=DateTimeField()) ).values('start_day').annotate(experiments=Count('id')) for exp in experiments_per_day: print(exp['start_day'], exp['experiments']) return HttpResponse('orm') # 运行结果: # 2015-06-15 00:00:00+00:00 2 # 2015-12-25 00:00:00+00:00 1 # 从运行结果中可以看出,2015-06-15日有两条记录,2015-12-25日有1条记录
4、Trunk函数应用:查询当天签到同学的id
def attendance(request): """签到页面""" current_datetime = datetime.now() year = current_datetime.year month = current_datetime.month day = current_datetime.day if request.method == 'GET': if course_id: # 获取当天已签到的记录 attended_students = models.Attendance.objects.annotate( attend_day=functions.Trunc('attend_time','day',output_field=DateTimeField(), ) ).filter(attend_day=datetime(year, month, day), course_id=course_id).values_list('student_id', flat=True) #Trunc函数的作用是将'attend_time'中的时间过滤成“day”: 2015-06-15 00:00:00+00:00 这种格式 tt = datetime(2016, 3, 12) #运行结果:2016-03-12 00:00:00 # 运行结果: <QuerySet [1, 2]> #这里的1,2 是数字表示当天只有id=1,和2的学生签到 # 注:使用这个查询语法和上面的查询结果完全一样 attended_students = models.Attendance.objects\ .filter(attend_time__date=datetime(year, month, day),course_id=course_id)\ .values_list('student_id', flat=True)
1.10 Django其他查询语句 返回顶部
1、extra构造额外的查询条件或者映射,如:子查询
1. extra作用
1、extra 中可实现别名,条件,排序等
2、后面两个用 filter, exclude 一般都能实现,排序用 order_by 也能实现
2. extra条件查询
def extra(self, select=None, where=None, params=None,tables=None, order_by=None, select_params=None): #1 select参数操作 Entry.objects.extra(select= {'new_id': "select col from sometable where othercol = %s"}, select_params=(1,)) Entry.objects.extra(select={'new_id': "func(id)"}) #也可以定义函数处理 # %s就会替换成1了 Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid']) #2 where参数操作 Entry.objects.extra(where=['headline=%s'], params=['Lennon']) # 类似filter过滤 Entry.objects.extra(where=['headline=%s','nid>1'], params=['Lennon']) # and操作 Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) #or操作 Entry.objects.extra(where=['func(ctime)=1 or nid=1']) #在这里也可以传入MySQL的函数
3. extra实现别名
from django.db.models import Count, Avg, Max, Min, Sum def orm(request): #1、extra 中可实现别名 tags = models.Student.objects.filter(name='zhangsan')\ .extra(select={'tag_name': 'name'}).first() print('name:',tags.name) # name: zhangsan print('tag_name:',tags.tag_name) # tag_name: zhangsan return HttpResponse('ok')
作者:学无止境
出处:https://www.cnblogs.com/xiaonq
生活不只是眼前的苟且,还有诗和远方。