info=models.table_name.objects.all()[0:5]  #切片
info= models.table_name.objects.all()[3]    #索引

info= models.table_name.objects.all()        #可迭代
print(info.title)
for obj in info:                     print(obj.title)

class A1(models.Model):id = models.IntegerField(primary_key=True)A11 = models.CharField(max_length=20)A12 = models.CharField(max_length=20)A13 = models.CharField(max_length=20)class E1(models.Model):id = models.IntegerField(primary_key=True)E11 = models.OneToOneField('A1',to_field='id',on_delete=models.CASCADE)E12 = models.CharField(max_length=20)# 定义 一对一关联:
# 格式:
# 字段 = models.OneToOneFied('关联表',to_field='关联表字段',on_delete=models.CASCADE)# 可添加参数:# related_name=名字  #外键反向查找别名（方便反向查找）# 使用方式; obj.名字.all()#在写ForeignKey字段的时候，如果想要在反向查找时不使用默认的 小写的表名_set，就在定义这个字段的时间加related参数！# related_query_name 字段=别名# 使用方式; obj.别名.all()# 一张表内两个外键 需要添加 related_query_name= 名字 从而识别是哪个外键值
# 示例:
# B11 = models.ForeignKey('A1',to_field='id',on_delete=models.CASCADE)

# B1表跟A1表形成外键关系
class A1(models.Model):id = models.IntegerField(primary_key=True)A11 = models.CharField(max_length=20)A12 = models.CharField(max_length=20)A13 = models.CharField(max_length=20)class B1(models.Model):id = models.IntegerField(primary_key=True)B11 = models.ForeignKey('A1',to_field='id',on_delete=models.CASCADE)B12 = models.CharField(max_length=20)B13 = models.CharField(max_length=20)# 定义 外键:
# 格式:
# 字段 = models.ForeignKey('关联表',to_field='关联表字段',on_delete=models.CASCADE)# 可添加参数:# related_name=名字  #外键反向查找别名（方便反向查找）# 使用方式; obj.名字.all()#在写ForeignKey字段的时候，如果想要在反向查找时不使用默认的 小写的表名_set，就在定义这个字段的时间加related参数！# related_query_name 字段=别名# 使用方式; obj.别名.all()# 一张表内两个外键 需要添加 related_query_name= 名字 从而识别是哪个外键值
# 示例:
# B11 = models.ForeignKey('A1',to_field='id',on_delete=models.CASCADE)

# C1表跟D1表形成多对多的关系
class C1 (models.Model):id = models.IntegerField(primary_key=True)m = models.ManyToManyField('D1')C12 = models.CharField(max_length=20)C13 = models.CharField(max_length=20)class D1 (models.Model):id = models.IntegerField(primary_key=True)D12 = models.CharField(max_length=20)D13 = models.CharField(max_length=20)# 定义 多对多:
# 格式:
# 字段 = models.ForeignKey('关联表',to_field='关联表字段',on_delete=models.CASCADE)# 可添加参数:# through='UserFans'指定第3张关系表的表名# through_fields    指定第3张关系表的字段
# 示例:
# m = models.ManyToManyField('D1')

# userinfo 形成多对多的自关联
class Userinfo(models.Model):nikename=models.CharField(max_length=32)username=models.CharField(max_length=32)password=models.CharField(max_length=64)sex=((1,'男'),(2,'女'))gender=models.IntegerField(choices=sex)m=models.ManyToManyField('Userinfo')

# # 单表添加数据
# 单表操作# 格式:# 表名.objects.create（）  # 导入的是表# module.表名.objects.create（）  # 导入的是module模块#
    # 添加方式一:# models.表名.objects.create(字段1='参数1', 字段2='参数2')#
    # 添加方式二:# obj = models.表名（字段1 = '参数1', 字段2 = '参数2'）# obj.save()# 示例:# # 方式一# models.A1.objects.create(A11='A1',A12='1',A13='1')#
    # # 方式二# data = {'A11': 'A2', 'A12': '2', 'A13': '2'}# models.A1.objects.create(**data)#
    # # 方式三# data2 = {'A11': 'A3', 'A12': '3', 'A13': '3'}# obj = models.A1(**data2)# obj.save()# QuerySet 数据类型:可以看作是一个列表
#   QuerySet 对象,可切片,索引,迭代# <class 'models.A1'>类对象: 就是一个类
#   相当于一个类,获取字段数值为 类.字段名# 单表查询数据# 查询所有数据# 格式:#     info=models.表名.objects.all()# 返回值:# query_set对象集合 [对象1、对象2、.... ]# obj = models.A1.objects.all()# print(obj) # QuerySet 对象# 查询单条数据#方式一 filter# 格式一:# info = models.表名.objects.filter(字段=参数)# 返回值:# 取值可以为  info[0]# query_set对象集合 [对象1]# obj2 = models.A1.objects.filter(id=1)  #查询不到数据为 空 QuerySet对象# print(obj2) # QuerySet 对象# # filter 可追加参数# obj21 = models.A1.objects.filter(id=1).first()  #第一条# obj22 = models.A1.objects.filter(id=1).last()   #最后一条# obj23 = models.A1.objects.filter(id=1).values_list()   #元组类型输出# obj24 = models.A1.objects.filter(id=1).values()        #字典类型输出# # print(type(obj21/22/23/24))  #<class 'models.A1'>类对象# .oder_by(-id)：按照某列排序# .exclude(字段)：字段获取数据时排除#方式二 get# info = models.表名.objects.get(字段=参数)# 返回值:# 单个对象，没有找到会报错# obj3 = models.A1.objects.get(id=1)  #查询不到数据报错!!!!# print(obj3)# print(type(obj3))  #<class 'models.A1'>类对象# 单表删除数据# 方式一:# models.A1.objects.filter(id=1).delete()# 方式二:# ob1 = models.A1.objects.get(id=1)# ob1.delete()# ob1.save()# 单表修改数据#修改方式1 update()# 格式:# models.表名.objects.filter(字段=参数).update(字段=参数)# models.A1.objects.filter(id=3).update(A11='A33',A12='A33',A13='A33')# data_updata = {'A11':'A33','A12':'A33','A13':'A33'}# models.A1.objects.filter(id=4).update(**data_updata)#修改方式2 obj.save()# obj = models.表名.objects.filter(字段=参数).get(字段=参数)# obj.字段 = 参数# obj.save()# ob1 = models.A1.objects.get(id=3)# ob1.A11 = 'A44'# ob1.A12 = 'A44'# ob1.A13 = 'A44'# ob1.save()# 更新数据操作:# 示例:# 格式:#  models.表名.objects.update_or_create(条件1=参数1, defaults={字段:属性})# 示例:#  tk = username#    models.Token.objects.update_or_create(user=user, defaults={'token': tk})# 找到更新 如果没有找到创建defaults={} 中的数据

# 一对一表操作# 添加删除修改(略)# # 查询# 正向查询(根据ontoon字段直接查询)# info1 = models.E1.objects.filter(id=1).values('id','E12','E11__A12','E11__A13')# info2 = models.E1.objects.filter(id=1).first().E11# print(info1)  # QuerySet# print(info2)  # A1 object (3)# #反向查询(反向查询跟foreignkey不同时的不需要 表名_set 这里只需要对表表名即可)# info1 = models.A1.objects.filter(id=3).values('id','A12','e1__id','e1__E12')# info2 = models.A1.objects.filter(id=3).first().e1# print(info1)    # QuerySet# print(info2)    # E1 object (1)

# 一对多表操作(外键)# # 一对多表操作:# 添加方式一:# models.表名.objects.create(字段1='参数1',字段2='参数2',外键ID='参数')#
    # 添加方式二:# obj=models.表名（字段1='参数1',字段2='参数2',外键=参数）# obj.save()# 一对多添加数据#方式一# data = {'B12':'B66','B13':'B66','B11_id':3}# models.B1.objects.create(**data)#方式二# data = {'B12':'B55','B13':'B55','B11_id':4}# obj = models.B1(**data)# obj.save()# 一对多表删除数据(跟单表操作一样)# 方式一:# models.B1.objects.filter(id=6).delete()# 方式二:# models.B1.objects.get(B12='B66').delete()# 一对多表修改数据(跟单表操作一样)# models.B1.objects.filter(id=3).update(B11_id=4)#一对多表查询数据(跨表查询)# 一对多表 跨表查询(正向查找 B表-外键字段-A表字段,下面两句等效)# info = models.B1.objects.filter(id=3).first().B11# info2 = models.B1.objects.get(id=3).B11# print(info)     # A1 object (4)# print(info2)    # A1 object (4)# # 一对多表 跨表查询(反向查找)(下面两条结果一致)# #方式一(根据 类的方式查找 ) (info.小写表名_set)# info = models.A1.objects.filter(id=4)# info1 = info.first().b1_set.values()# print(info1)    #values --- QuerySet类型# #方式二(根据values方式查找)(在values中  '小写表名__字段名' )# info2 = models.A1.objects.values('b1__B11','b1__B12','b1__B13').filter(id=4)# print(info2)    #values --- QuerySet类型

    #多对多表操作#多对多表添加操作# 如果两表之间存在双向1对N关系，就无法使用外键来描述其关系了；# 只能使用多对多的方式，新增第三张表关系描述表；# add()   添加# clear() 清空# remove() 删除某个对象# 正向添加 通过 多对多字段m.add增加#C1表id =1 字段 关联 D1表的 id = 1,2,3# obj = models.C1.objects.filter(id=1).first()# obj.m.add(1,2,3)# 反向添加 通过 小写表名_set.add增加# D1表id =1 字段 关联 C1表的 id = 1,2,3# obj2 = models.D1.objects.filter(id=1).first()# obj2.c1_set.add(1,2,3)#C1 id=3 关联 D1表id>3的数据# obj1 = models.C1.objects.filter(id=3).first()# obj2 = models.D1.objects.filter(id__gt=3)# obj1.m.add(*obj2)#多对多表删除操作# 正向删除# obj1 = models.C1.objects.filter(id=1).first()# obj1.m.remove(1,2,3)# 逆向删除# obj2 = models.D1.objects.filter(id=1).first()# obj2.c1_set.remove(2,3)# 清除数据# obj3 = models.C1.objects.filter(id=3).first()# obj3.m.clear()#多对多修改# ManyToManyField()字段 自动创建第3张关系表，可以使用字段跨表查询，但无法直接操作第3张表，# obj.m.all() 只有查询和清空 方法#多对多查询# 正向查询(通过多对多字段 直接查询)# obj = models.C1.objects.get(id=3).m.values()# print(obj)# 反向查询(通过.表名_set 查询)# obj = models.D1.objects.get(id=1).c1_set.values_list()# print(obj)

# 多对多自关联（由原来的3张表，变成只有2张表）
# 把两张表通过 choices字段合并为一张表
# ‘第三张关系表’ 使用models.ManyToManyField('Userinfo')生成# 同表正反向查询# 多对多 自关联 通过男士查询女生# boy_obj = models.Userinfo.objects.filter(id=2).first()# res = boy_obj.m.all()# for row in res:#     print(row.nikename)# # 多对多自关联 之通过女士查询男生# girl_obj = models.Userinfo.objects.filter(id=4).first()# res = girl_obj.userinfo_set.all()# for obj in res:#     print(obj.nikename)

    # 查询性能 :# 1、select_related：结果为对象  注意query_set类型的对象 都有该方法# 原理： 查询时主动完成连表形成一张大表，for循环时不用额外发请求；# 试用场景： 节省硬盘空间，数据量少时候适用相当于做了一次数据库查询；# info = models.B1.objects.filter(B11=4).all().select_related()# for i in info:#     print(i)# 2、prefetch_related：结果都对象是# 原理：虽好，但是做连表操作依然会影响查询性能，所以出现prefetch_related# prefetch_related:不做连表，多次单表查询外键表 去重之后显示， 2次单表查询（有几个外键做几次1+N次单表查询，# 适用场景：效率高，数据量大的时候试用# info = models.B1.objects.filter(B11=4).all().prefetch_related()# for i in info:#     print(i)

# F查询与Q查询#F 可以获取对象中的字段的属性（列），并对其进行操作；# from django.db.models import F,Q# models.表名.objects.all().update(price=F('price')+1)   #所在的列进行操作# Q多条件组合查询# Q（）可以使orm的fifter（）方法支持， 多个查询条件，使用逻辑关系（&、|、~）包含、组合到一起进行多条件查询；# 语法：# fifter（Q（查询条件1）| Q（查询条件2））# fifter（Q（查询条件2）& Q（查询条件3））# fifter（Q（查询条件4）& ~Q（查询条件5））# fifter（Q（查询条件6）| Q（Q（查询条件4）& ~ Q（Q（查询条件5）& Q（查询条件3）））包含# from django.db.models import F,Q#     1、F 可以获取对象中的字段的属性（列），并且对其进行操作；#     # models.Book.objects.all().update(price=F('price')+1)#     2、Q多条件组合查询#     #如果 多个查询条件 涉及到逻辑使用 fifter（,隔开）可以表示与，但没法表示或非得关系#     #查询 书名包含作者名的书#     book=models.Book.objects.filter(title__icontains='伟',author__name__contains='伟').values('title')#     #如何让orm 中得 fifter 支持逻辑判断+多条件查询？ Q（）登场#     book=models.Book.objects.filter(Q(title__icontains='伟') & Q(author__name__contains='伟')).values('title')#     book=models.Book.objects.filter(Q(author__name__contains='伟') & ~Q(title__icontains='伟')).values('title')#
        #    #多条件包含组合查询#    #查询作者姓名中包含 方/少/伟/书名包含伟3字 并且出版社地址以山西开头的书#     book=models.Book.objects.filter(#                                     Q(#                                     Q(author__name__contains='方') |#                                     Q(author__name__contains='少') |#                                     Q(title__icontains='伟')|#                                     Q(author__name__contains='伟')#                                     )#                                     &#                                     Q(publish__addr__contains='山西')#                                     ).values('title')#     print(book)# 注意：Q查询条件和非Q查询条件混合使用注意，不包Q（）的查询条件一点要放在Q（查询条件）后面