model基础操作（下）

3.Django多对多表结构操作

 

3.1 第一种： ManyToManyField

 

自己不创建第三张关系表，有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

 

3.2 查询

 

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')

 

3.2 第二种： 自己创建第三张表

 

自己创建第三张关系表，无 m2m 字段，自己链表查询

 

3.2.1 models.py

 

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.3 多对多双下划线查找

 

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.3 创建m2m多对多时ManyToManyField可以添加的参数

 

1、to, 　　　　　　　　　　　　　　   # 要进行关联的表名

2、related_name=None, 　　　　　　# 反向操作时，使用的字段名，用于代替 【表名_set】如： obj.表名_set.all()

3、related_query_name=None, 　　# 反向操作时，使用的连接前缀，用于替换【表名】

 

4.一大波model操作

 

4.1 基础查询语句

 

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')

 

4.2 进阶操作：牛掰掰的双下划线

 

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

　　作:模糊匹配

　　　　# 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))

# 2005-01-01以后创建的数据

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)

 

4.3 时间查询

 

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))

 

5.F()和Q()查询语句

 

5.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')

 

5.2 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')

 

6.aggregate和annotate聚合函数 : 求平均值、最大值、最小值等

 

6.1 ggregate聚合函数

作用：从数据库中取出一个汇总的集合

 

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}

 

6.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')