统计

随笔 - 49
文章 - 0
评论 - 3
阅读 - 5428

测试环境

只是想测试django中的某一个py文件内容那么你可以不用书写前后端交互的形式，而是直接写一个测试脚本即可，脚本代码无论是写在应用下的tests.py还是自己单独开设py文件都可以。

 # 测试环境的准备 去manage.py中拷贝前四行代码 然后自己写两行
import os
import sys
 
if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings")
    import django
    django.setup()
    # 在这个代码块的下面就可以测试django里面的单个py文件了

4.1单表操作

增加数据

     # 增 第一种方式
    res = models.User.objects.create(name='upup',age=12,register_time = '2012-11-22')
    # print (res) # User object
    
    
	# 第二种方式
        import datetime
    ctime = datetime.datetime.now()
    user_obj = models.User.objects.create(name='ggg',age=15,register_time=ctime)
    user_obj.save()

删除数据

     # 方式一
    res = models.User.objects.filter(pk=2).delete()
    print (res) # (1, {u'app01.User': 1})
 
    # pk会自动查找到当前表的主键字段 指代的就是当前表的主键字段,用了pk之后 你就不需要指代当前表的主键字段到底叫什么了

修改数据

     # 修改
    models.User.objects.filter(pk=1).update(name='up')
    # get方法返回的是当前数据对象，但是该方法不推荐使用，如果数据不存在会直接报错，但是filter会返回None
    user_obj = models.User.objects.get(pk=1)
    user_obj.name='up'
    user_obj.save()

必会十三条

1、all() 查询所有数据

2、filter() 带有过滤条件的查询

3、get() 直接拿数据对象，但是数据不存在会报错

4、first() 拿queryset里面第一个元素

5、last() 拿queryset里面最后一个元素

6、values() 可以指定获取的数据字段

 res = models.User.objects.values('name','age')
print(res)
 
<QuerySet [{'name': 'up', 'age': 18}, {'name': 'ggg', 'age': 84}]>

7、values_list() 拿到的是列表套元组数据

 res = models.User.objects.values_list('name','age')
print(res)
 
<QuerySet [('up', 18), ('ggg', 84)]>

8、distinct() 去重去重一定要是一模一样的数据,如果带有主键那么肯定不一样你在往后的查询中一定不要忽略主键

 res = models.User.objects.values('name','age').distinct()

9、order_by() 排序

 res = models.User.objects.order_by('age')  # 默认升序
res = models.User.objects.order_by('-age')  # 降序

10、reverse() 反转的前提是数据已经排过序了

 res = models.User.objects.all()
res1 = models.User.objects.order_by('age').reverse()

11、count() 统计当前数据的个数

 res = models.User.objects.count()

12、exclude() 排除在外

 res = models.User.objects.exclude(name='jason')

13、exists() 基本用不到因为数据本身就自带布尔值返回的是布尔值

 res = models.User.objects.filter(pk=10).exists()

查看内部的sql语句

 # 方式1
res = models.User.objects.values_list('name','age')  # <QuerySet [('up', 18), ('ggg', 84)]>
print(res.query)
queryset对象才能够点击query查看内部的sql语句
 
# 方式2:所有的sql语句都能查看
# 去配置文件中配置一下,不用自己写直接copy即可 settings.py
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

4.2双下划线查询

大于

 # 年龄大于35岁的数据
res = models.User.objects.filter(age__gt=35)

小于

 # 年龄小于35岁的数据
res = models.User.objects.filter(age__lt=35)

大于等于小于等于

 res = models.User.objects.filter(age__gte=32)
res = models.User.objects.filter(age__lte=32)

条件查询

 # 年龄是18 或者 32 或者40
res = models.User.objects.filter(age__in=[18,32,40])
 
# 年龄在18到40岁之间的  首尾都要
res = models.User.objects.filter(age__range=[18,40])
 
#查询出名字里面含有s的数据  模糊查询
res = models.User.objects.filter(name__contains='s')
 
# 是否区分大小写  查询出名字里面含有p的数据  区分大小写
res = models.User.objects.filter(name__contains='p')
 
# 忽略大小写
res = models.User.objects.filter(name__icontains='p')
 
# res = models.User.objects.filter(name__startswith='j')
# res1 = models.User.objects.filter(name__endswith='j')

查询时间

 # 查询出注册时间是 2020 1月
# res = models.User.objects.filter(register_time__month='1')
res = models.User.objects.filter(register_time__year='2020')

4.3多表操作

一对多外键操作

点击查看代码

     # 增加
    # 方式一：直接增加id
    models.Book.objects.create(title='三国演义',price=10,publish_id=1)
 
    # 方式二：虚拟字段 对象
    book = models.Publish.objects.filter(pk=2).first()
    models.Book.objects.create(title='红楼梦',price=20,publish=book)
    
     # 删除 级联删除
    models.Book.objects.filter(pk=1).delete()
    
    # 修改
    # 方式一
    models.Book.objects.filter(pk=1).update(publish_id=2)
 
    # 方式二
    book = models.Publish.objects.filter(pk=1).first()
    models.Book.objects.filter(pk=1).update(publish=book)

多对多外键操作

点击查看代码

 # 给书籍添加作者
book_obj = models.Book.objects.filter(pk=1).first()
# print(book_obj.authors)  # 就类似于你已经到了第三张关系表了
# book_obj.authors.add(1)  # 书籍id为1的书籍绑定一个主键为1 的作者
# book_obj.authors.add(2,3)
 
#  add给第三张关系表添加数据,括号内既可以传数字也可以传对象 并且都支持多个
author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()
author_obj2 = models.Author.objects.filter(pk=3).first()
book_obj.authors.add(author_obj)
book_obj.authors.add(author_obj1,author_obj2)
# 删  remove 括号内既可以传数字也可以传对象 并且都支持多个
book_obj.authors.remove(2)
book_obj.authors.remove(1,3)
# author_obj = models.Author.objects.filter(pk=2).first()
# author_obj1 = models.Author.objects.filter(pk=3).first()
# book_obj.authors.remove(author_obj,author_obj1)
 
 
# 修改   set 括号内必须传一个可迭代对象，该对象内既可以数字也可以对象 并且都支持多个
book_obj.authors.set([1,2])  # 括号内必须给一个可迭代对象
book_obj.authors.set([3])  
 
author_obj = models.Author.objects.filter(pk=2).first()
author_obj1 = models.Author.objects.filter(pk=3).first()
book_obj.authors.set([author_obj,author_obj1])  # 括号内必须给一个可迭代对象
 
# 清空 clear括号内不要加任何参数
# 在第三张关系表中清空某个书籍与作者的绑定关系
book_obj.authors.clear()

正反向的概念

正向：有外键字段的去查就是正向

反向：没有外键字段的去查就是反向

正向查询按字段
反向查询按表名小写
_set
...

4.4多表查询

准备工作

点击查看代码

 class User(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    register_time = models.DateField()
 
class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.IntegerField()
    publish_date = models.DateField(auto_now_add=True)
 
    # 一对多
    publish = models.ForeignKey(to='Publish')
 
    # 多对多
    authors = models.ManyToManyField(to='Author')
 
class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=64)
    email = models.EmailField()
 
class Author(models.Model):
    name = models.CharField(max_length=32)<details>
<summary>点击查看代码</summary>

 </details>
    age = models.IntegerField()
 
    # 一对一
    author_detail = models.OneToOneField(to='AuthorDetail')
 
class AuthorDetail(models.Model):
    phone = models.BigIntegerField() # 电话也可以使用 CharField
    addr = models.CharField(max_length=64)

1、基于对象的跨表查询，子查询

点击查看代码

  # 正向什么时候需要加.all(),当你的结果可能有多个的时候就需要加.all(),如果是一个则直接拿到数据对象
          
# 1.查询书籍主键为1的出版社
book_obj = models.Book.objects.filter(pk=1).first()
# 书查出版社 正向
res = book_obj.publish
# print(res)
# print(res.name)
# print(res.addr)
 
# 2.查询书籍主键为2的作者
book_obj = models.Book.objects.filter(pk=2).first()
# 书查作者 正向
res = book_obj.authors  # app01.Author.None
res = book_obj.authors.all()  # <QuerySet [<Author: Author object>, <Author: Author object>]>
 
# 3.查询作者up的电话号码
author_obj = models.Author.objects.filter(name='up').first()
res = author_obj.author_detail
# print(res)
print(res.phone)
print(res.addr)
 
 
基于对象反向查询的时候,当你的查询结果可以有多个的时候 就必须加_set.all(),当你的结果只有一个的时候 不需要加_set.all()
# 4.查询出版社是东方出版社出版的书
publish_obj = models.Publish.objects.filter(name='东方出版社').first()
# 出版社查书  反向
res = publish_obj.book_set  # app01.Book.None
# res = publish_obj.book_set.all()
print(res)
 
# 5.查询作者是up写过的书
author_obj = models.Author.objects.filter(name='up').first()
# 作者查书      反向
# res = author_obj.book_set  # app01.Book.None
res = author_obj.book_set.all()
print(res)
 
# 6.查询手机号是110的作者姓名
author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
res = author_detail_obj.author
print(res.name)

2、基于双下滑线的连表查询

点击查看代码

 # 1.查询jason的手机号和作者姓名
res =models.Author.objects.filter(name='jason').values('author_detail__phone','name')
print(res)
# 反向
res = models.AuthorDetail.objects.filter(author__name='up')  # 拿作者姓名是up的作者详情
res=models.AuthorDetail.objects.filter(author__name='up').values('phone','author__name')
# print(res)
 
# 2.查询书籍主键为1的出版社名称和书的名称
res = models.Book.objects.filter(pk=1).values('title','publish__name')
# print(res)
# 反向
res = models.Publish.objects.filter(book__id=1).values('name','book__title')
 
# 3.查询书籍主键为1的作者姓名
res = models.Book.objects.filter(pk=1).values('authors__name')
# print(res)
# 反向
res = models.Author.objects.filter(book__id=1).values('name')
 
# 查询书籍主键是1的作者的手机号
# book author authordetail   book和authordetail没有关系，但是可以通过author表找到author_detail_id
res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
# print(res)

掌握了正反向的概念以及双下划线,那么就可以无限制的跨表

4.5聚合查询

aggregate

聚合查询通常情况下都是配合分组一起使用的，只要是跟数据库相关的模块，基本上都在django.db.models里面，如果没有那么应该在django.db里面

 from app01 import models
from django.db.models import Max,Min,Sum,Count,Avg
# 1 所有书的平均价格
# res = models.Book.objects.aggregate(Avg('price'))
# print(res)
# 2.上述方法一次性使用
res = models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('pk'),Avg('price'))
print(res)

4.6分组查询

点击查看代码

 # 分组查询  annotate
    from django.db.models import Max, Min, Sum, Count, Avg
    # 1.统计每一本书的作者个数
res = models.Book.objects.annotate()  # models后面点什么 就是按什么分组
res=models.Book.objects.annotate(author_num=Count('authors')).values('title','author_num')
    author_num是我们自己定义的字段 用来存储统计出来的每本书对应的作者个数
 
#res1=models.Book.objects.annotate(author_num=Count('authors__id')).values('title','author_num')
    # print(res,res1)
 
    # 2.统计每个出版社卖的最便宜的书的价格(作业:复习原生SQL语句 写出来)
res=models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
    # print(res)
 
# 3.统计不止一个作者的图书
# 1.先按照图书分组 求每一本书对应的作者个数
# 2.过滤出不止一个作者的图书
res=models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title','author_num')
 
# 4.查询每个作者出的书的总价格
res=models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
print(res)
 
 
# 按照指定的字段分组
 models.Book.objects.values('price').annotate()

只要orm语句得出的结果还是一个queryset对象,那么它就可以继续无限制的点queryset对象封装的方法

4.7F、Q查询

F查询：能够直接获取到表中某个字段对应的数据

     # 1.查询卖出数大于库存数的书籍
    # F查询
    from django.db.models import F
    # res = models.Book.objects.filter(maichu__gt=F('kucun'))
    # print(res)
 
    # 2.将所有书籍的价格提升500块
    # models.Book.objects.update(price=F('price') + 500)
 
 
    # 3.将所有书的名称后面加上爆款两个字
    """
    在操作字符类型的数据的时候 F不能够直接做到字符串的拼接
    """
    from django.db.models.functions import Concat
    from django.db.models import Value
    models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
    
    # models.Book.objects.update(title=F('title') + '爆款')  # 所有的名称会全部变成空白

Q查询：

  # Q查询
# 1.查询卖出数大于100或者价格小于600的书籍
res = models.Book.objects.filter(maichu__gt=100,price__lt=600)
    """filter括号内多个参数是and关系"""
    from django.db.models import Q
res = models.Book.objects.filter(Q(maichu__gt=100),Q(price__lt=600))  # Q包裹逗号分割 还是and关系
res = models.Book.objects.filter(Q(maichu__gt=100)|Q(price__lt=600))  # | or关系
res = models.Book.objects.filter(~Q(maichu__gt=100)|Q(price__lt=600))  # ~ not关系
    # print(res)
 
    # Q的高阶用法  能够将查询条件的左边也变成字符串的形式 比如搜索功能
    q = Q() # 产生一个空对象，默认是and关系 ，可以修改为or
    q.connector = 'or'
    q.children.append(('maichu__gt',100))
    q.children.append(('price__lt',600))
    res = models.Book.objects.filter(q)  # 默认还是and关系
    print(res)

4.7事务

事务的特性：

原子性：不可分割的最小单位
一致性：跟原子性是相辅相成
隔离性：事务之间互相不干扰
持久性：事务一旦确认永久生效

事务的回滚：rollback

事务的确认：commit

django开启事务：

 from django.db import transaction
    try:
        with transaction.atomic():
            # sql1
            # sql2
            ...
            # 在with代码快内书写的所有orm操作都是属于同一个事务
    except Exception as e:
        print(e)
    print('执行其他操作')

4.8orm常用字段

AutoField:主键字段,primary_key=True 一般不用自己写

CharField：varchar字段，max_length长度必须写，verbose_name字段的注释尽量写

IntegerField：int BigIntegerField：bigint

DecimalField：指定小数 max_digits=8，decimal_places=2

EmailFiled：邮箱 varchar(254)

DateField：日期 date 指定年月日
DateTimeField：datetime 指定年月日时分秒
auto_now:每次修改数据的时候都会自动更新当前时间
auto_now_add:只在创建数据的时候记录创建时间后续不会自动修改了

BooleanField(Field)：布尔值类型
该字段传布尔值(False/True) 数据库里面存0/1

TextField(Field)：文本类型
该字段可以用来存大段内容(文章、博客...) 没有字数限制

FileField(Field)：字符类型
upload_to = "/data"
给该字段传一个文件对象，会自动将文件保存到/data目录下然后将文件路径保存到数据库中

ForeignKey(unique=True) === OneToOneField()：一对一关系用，但是推荐使用OneToOneField()

db_index：如果db_index=True 则代表着为此字段设置索引

to_field：设置要关联的表的字段默认不写关联的就是另外一张的主键字段

on_delete：当删除关联表中的数据时，当前表与其关联的行的行为，一般都不写

django2.X及以上版本需要你自己指定外键字段的级联更新级联删除

还可以自定义字段

 class MyCharField(models.Field):
    def __init__(self,max_length,*args,**kwargs):
        self.max_length = max_length
        # 调用父类的init方法
        super().__init__(max_length=max_length,*args,**kwargs)  # 一定要是关键字的形式传入
 
    def db_type(self, connection):
        """
        返回真正的数据类型及各种约束条件
        :param connection:
        :return:
        """
        return 'char(%s)'%self.max_length
 
# 自定义字段使用
myfield = MyCharField(max_length=16,null=True)

4.9数据库查询优化

orm语句的特点：惰性查询，如果写了orm语句，但是没有用到该语句所查询出来的参数，那么orm会自动识别，直接不执行。

1、only和differ

点击only括号内的字段 ,不会走数据库，点击only括号内没有的字段会重新走数据库查询

defer与only刚好相反,defer括号内放的字段不在查询出来的对象里面 ,查询该字段需要重新走数据
而如果查询的是非括号内的字段则不需要走数据库了

 res = models.Book.objects.only('title')
res = models.Book.objects.all()
 
print(i.title)  # 点击only括号内的字段 不会走数据库
print(i.price)  # 点击only括号内没有的字段 会重新走数据库查询而all不需要走了
 
res = models.Book.objects.defer('title')  # 对象除了没有title属性之外其他的都有
    for i in res:
        print(i.price)

2、select_related与prefetch_related

与跨表操作有关

 res = models.Book.objects.select_related('publish')
 for i in res:
		 print(i.publish.name) 
 
"""
select_related内部直接先将book与publish连起来 然后一次性将大表里面的所有数据,全部封装给查询出来的对象,这个时候对象无论是点击book表的数据还是publish的数据都无需再走数据库查询了
select_related括号内只能放外键字段    一对多 一对一可以,多对多不行
"""
 
 res = models.Book.objects.prefetch_related('publish')  # 子查询
"""
prefetch_related该方法内部其实就是子查询
        将子查询查询出来的所有结果也给你封装到对象中
        给你的感觉好像也是一次性搞定的
 """
    for i in res:
        print(i.publish.name)

4.10choice参数

针对某个可以列举完全的可能性字段，一般情况下都会采用choices参数

获取choice参数对应的字段使用get_ 字段名_display()

 class User(models.Model):
    username = models.CharField(max_length=32)
    age = models.IntegerField()
    # 性别
    gender_choices = (
        (1,'男'),
        (2,'女'),
        (3,'其他'),
    )
    
    score_choices = (
        ('A','优秀'),
        ('B','良好'),
        ('C','及格'),
        ('D','不合格'),
    )
    # 保证字段类型跟列举出来的元祖第一个数据类型一致即可
    score = models.CharField(choices=score_choices,null=True)
    gender = models.IntegerField(choices=gender_choices)
    
    
     # 存的时候 没有列举出来的数字也能存（范围还是按照字段类型决定）
     
    # 取
    user_obj = models.User.objects.filter(pk=1).first()
    # print(user_obj.gender) # 不能取到值
    # 只要是choices参数的字段 如果你想要获取对应信息 固定写法 get_字段名_display()
    # print(user_obj.get_gender_display())
 
    user_obj = models.User.objects.filter(pk=4).first()
    # 如果没有对应关系 那么字段是什么还是展示什么
    print(user_obj.get_gender_display())  # 4

MTV与MVC

 # MTV:Django号称是MTV模型
M:models
T:templates
V:views
# MVC:其实django本质也是MVC
M:models
V:views
C:controller  # 控制器
  
# vue框架:MVVM模型

4.11多对多三种创建方式

全自动：利用orm自动帮我们创建第三张关系表

优点:代码不需要你写非常的方便还支持orm提供操作第三张关系表的方法...
缺点:第三张关系表的扩展性极差(没有办法额外添加字段...)

 	class Book(models.Model):
    name = models.CharField(max_length=32)
    authors = models.ManyToManyField(to='Author')
	class Author(models.Model):
    name = models.CharField(max_length=32)

纯手动

优点:第三张表完全取决于你自己进行额外的扩展
缺点:需要写的代码较多，不能够再使用orm提供的简单的方法，比如双下划线
不建议用该方式

 class Book(models.Model):
    name = models.CharField(max_length=32)
    
	class Author(models.Model):
    name = models.CharField(max_length=32)
  
  class Book2Author(models.Model):
    book_id = models.ForeignKey(to='Book')
    author_id = models.ForeignKey(to='Author')

半自动

可以使用orm的正反向查询但是没法使用add,set,remove,clear这四个方法

through_fields字段先后顺序:通过第三张表查询对应的表需要用到哪个字段就把哪个字段放前面

简化判断:当前表是谁就把对应的关联字段放前面

 class Book(models.Model):
    name = models.CharField(max_length=32)
    authors = models.ManyToManyField(to='Author',
                                     through='Book2Author',
                                     through_fields=('book','author')
                                     )
class Author(models.Model):
    name = models.CharField(max_length=32)
    # books = models.ManyToManyField(to='Book',
    #                                  through='Book2Author',
    #                                  through_fields=('author','book')
    #                                  )
class Book2Author(models.Model):
    book = models.ForeignKey(to='Book')
    author = models.ForeignKey(to='Author')

posted on 2022-08-15 18:34 AprilX 阅读(24) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 初识django与ORM

· 4、表与表的关系

· Django之模型层

· Django-模型层

· Django模型层

公告

昵称： AprilX
园龄： 3年4个月
粉丝： 1
关注： 6
+加关注

导航

统计

4.1单表操作

4.2双下划线查询

4.3多表操作

4.4多表查询

4.5聚合查询

4.6分组查询

4.7F、Q查询

4.7事务

4.8orm常用字段

4.9数据库查询优化

4.10choice参数

4.11多对多三种创建方式

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

最新评论

	# 测试环境的准备去manage.py中拷贝前四行代码然后自己写两行
	import os
	import sys

	if __name__ == "__main__":
	os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings")
	import django
	django.setup()
	# 在这个代码块的下面就可以测试django里面的单个py文件了

	# 增第一种方式
	res = models.User.objects.create(name='upup',age=12,register_time = '2012-11-22')
	# print (res) # User object


	# 第二种方式
	import datetime
	ctime = datetime.datetime.now()
	user_obj = models.User.objects.create(name='ggg',age=15,register_time=ctime)
	user_obj.save()

	# 方式一
	res = models.User.objects.filter(pk=2).delete()
	print (res) # (1, {u'app01.User': 1})

	# pk会自动查找到当前表的主键字段指代的就是当前表的主键字段,用了pk之后你就不需要指代当前表的主键字段到底叫什么了

	# 修改
	models.User.objects.filter(pk=1).update(name='up')
	# get方法返回的是当前数据对象，但是该方法不推荐使用，如果数据不存在会直接报错，但是filter会返回None
	user_obj = models.User.objects.get(pk=1)
	user_obj.name='up'
	user_obj.save()

	res = models.User.objects.values('name','age')
	print(res)

	<QuerySet [{'name': 'up', 'age': 18}, {'name': 'ggg', 'age': 84}]>

	res = models.User.objects.values_list('name','age')
	print(res)

	<QuerySet [('up', 18), ('ggg', 84)]>

	res = models.User.objects.order_by('age') # 默认升序
	res = models.User.objects.order_by('-age') # 降序

	res = models.User.objects.all()
	res1 = models.User.objects.order_by('age').reverse()

	# 方式1
	res = models.User.objects.values_list('name','age') # <QuerySet [('up', 18), ('ggg', 84)]>
	print(res.query)
	queryset对象才能够点击query查看内部的sql语句

	# 方式2:所有的sql语句都能查看
	# 去配置文件中配置一下,不用自己写直接copy即可 settings.py
	LOGGING = {
	'version': 1,
	'disable_existing_loggers': False,
	'handlers': {
	'console':{
	'level':'DEBUG',
	'class':'logging.StreamHandler',
	},
	},
	'loggers': {
	'django.db.backends': {
	'handlers': ['console'],
	'propagate': True,
	'level':'DEBUG',
	},
	}
	}

	# 年龄大于35岁的数据
	res = models.User.objects.filter(age__gt=35)

	# 年龄小于35岁的数据
	res = models.User.objects.filter(age__lt=35)

	# 年龄是18 或者 32 或者40
	res = models.User.objects.filter(age__in=[18,32,40])

	# 年龄在18到40岁之间的首尾都要
	res = models.User.objects.filter(age__range=[18,40])

	#查询出名字里面含有s的数据模糊查询
	res = models.User.objects.filter(name__contains='s')

	# 是否区分大小写查询出名字里面含有p的数据区分大小写
	res = models.User.objects.filter(name__contains='p')

	# 忽略大小写
	res = models.User.objects.filter(name__icontains='p')

	# res = models.User.objects.filter(name__startswith='j')
	# res1 = models.User.objects.filter(name__endswith='j')

	# 查询出注册时间是 2020 1月
	# res = models.User.objects.filter(register_time__month='1')
	res = models.User.objects.filter(register_time__year='2020')

	# 增加
	# 方式一：直接增加id
	models.Book.objects.create(title='三国演义',price=10,publish_id=1)

	# 方式二：虚拟字段对象
	book = models.Publish.objects.filter(pk=2).first()
	models.Book.objects.create(title='红楼梦',price=20,publish=book)

	# 删除级联删除
	models.Book.objects.filter(pk=1).delete()

	# 修改
	# 方式一
	models.Book.objects.filter(pk=1).update(publish_id=2)

	# 方式二
	book = models.Publish.objects.filter(pk=1).first()
	models.Book.objects.filter(pk=1).update(publish=book)

	# 给书籍添加作者
	book_obj = models.Book.objects.filter(pk=1).first()

	# print(book_obj.authors) # 就类似于你已经到了第三张关系表了
	# book_obj.authors.add(1) # 书籍id为1的书籍绑定一个主键为1 的作者
	# book_obj.authors.add(2,3)

	# add给第三张关系表添加数据,括号内既可以传数字也可以传对象并且都支持多个
	author_obj = models.Author.objects.filter(pk=1).first()
	author_obj1 = models.Author.objects.filter(pk=2).first()
	author_obj2 = models.Author.objects.filter(pk=3).first()
	book_obj.authors.add(author_obj)
	book_obj.authors.add(author_obj1,author_obj2)

	# 删 remove 括号内既可以传数字也可以传对象并且都支持多个
	book_obj.authors.remove(2)
	book_obj.authors.remove(1,3)

	# author_obj = models.Author.objects.filter(pk=2).first()
	# author_obj1 = models.Author.objects.filter(pk=3).first()
	# book_obj.authors.remove(author_obj,author_obj1)


	# 修改 set 括号内必须传一个可迭代对象，该对象内既可以数字也可以对象并且都支持多个
	book_obj.authors.set([1,2]) # 括号内必须给一个可迭代对象
	book_obj.authors.set([3])

	author_obj = models.Author.objects.filter(pk=2).first()
	author_obj1 = models.Author.objects.filter(pk=3).first()
	book_obj.authors.set([author_obj,author_obj1]) # 括号内必须给一个可迭代对象

	# 清空 clear括号内不要加任何参数
	# 在第三张关系表中清空某个书籍与作者的绑定关系
	book_obj.authors.clear()

	class User(models.Model):
	name = models.CharField(max_length=32)
	age = models.IntegerField()
	register_time = models.DateField()

	class Book(models.Model):
	title = models.CharField(max_length=32)
	price = models.IntegerField()
	publish_date = models.DateField(auto_now_add=True)

	# 一对多
	publish = models.ForeignKey(to='Publish')

	# 多对多
	authors = models.ManyToManyField(to='Author')

	class Publish(models.Model):
	name = models.CharField(max_length=32)
	addr = models.CharField(max_length=64)
	email = models.EmailField()

	class Author(models.Model):
	name = models.CharField(max_length=32)<details>
	<summary>点击查看代码</summary>

	</details>
	age = models.IntegerField()

	# 一对一
	author_detail = models.OneToOneField(to='AuthorDetail')

	class AuthorDetail(models.Model):
	phone = models.BigIntegerField() # 电话也可以使用 CharField
	addr = models.CharField(max_length=64)

	# 正向什么时候需要加.all(),当你的结果可能有多个的时候就需要加.all(),如果是一个则直接拿到数据对象

	# 1.查询书籍主键为1的出版社
	book_obj = models.Book.objects.filter(pk=1).first()
	# 书查出版社正向
	res = book_obj.publish
	# print(res)
	# print(res.name)
	# print(res.addr)

	# 2.查询书籍主键为2的作者
	book_obj = models.Book.objects.filter(pk=2).first()
	# 书查作者正向
	res = book_obj.authors # app01.Author.None
	res = book_obj.authors.all() # <QuerySet [<Author: Author object>, <Author: Author object>]>

	# 3.查询作者up的电话号码
	author_obj = models.Author.objects.filter(name='up').first()
	res = author_obj.author_detail
	# print(res)
	print(res.phone)
	print(res.addr)


	基于对象反向查询的时候,当你的查询结果可以有多个的时候就必须加_set.all(),当你的结果只有一个的时候不需要加_set.all()
	# 4.查询出版社是东方出版社出版的书
	publish_obj = models.Publish.objects.filter(name='东方出版社').first()
	# 出版社查书反向
	res = publish_obj.book_set # app01.Book.None
	# res = publish_obj.book_set.all()
	print(res)

	# 5.查询作者是up写过的书
	author_obj = models.Author.objects.filter(name='up').first()
	# 作者查书反向
	# res = author_obj.book_set # app01.Book.None
	res = author_obj.book_set.all()
	print(res)

	# 6.查询手机号是110的作者姓名
	author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
	res = author_detail_obj.author
	print(res.name)

	# 1.查询jason的手机号和作者姓名
	res =models.Author.objects.filter(name='jason').values('author_detail__phone','name')
	print(res)
	# 反向
	res = models.AuthorDetail.objects.filter(author__name='up') # 拿作者姓名是up的作者详情
	res=models.AuthorDetail.objects.filter(author__name='up').values('phone','author__name')
	# print(res)

	# 2.查询书籍主键为1的出版社名称和书的名称
	res = models.Book.objects.filter(pk=1).values('title','publish__name')
	# print(res)
	# 反向
	res = models.Publish.objects.filter(book__id=1).values('name','book__title')

	# 3.查询书籍主键为1的作者姓名
	res = models.Book.objects.filter(pk=1).values('authors__name')
	# print(res)
	# 反向
	res = models.Author.objects.filter(book__id=1).values('name')

	# 查询书籍主键是1的作者的手机号
	# book author authordetail book和authordetail没有关系，但是可以通过author表找到author_detail_id
	res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
	# print(res)

	from app01 import models
	from django.db.models import Max,Min,Sum,Count,Avg
	# 1 所有书的平均价格
	# res = models.Book.objects.aggregate(Avg('price'))
	# print(res)
	# 2.上述方法一次性使用
	res = models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('pk'),Avg('price'))
	print(res)

	# 分组查询 annotate
	from django.db.models import Max, Min, Sum, Count, Avg
	# 1.统计每一本书的作者个数
	res = models.Book.objects.annotate() # models后面点什么就是按什么分组
	res=models.Book.objects.annotate(author_num=Count('authors')).values('title','author_num')
	author_num是我们自己定义的字段用来存储统计出来的每本书对应的作者个数

	#res1=models.Book.objects.annotate(author_num=Count('authors__id')).values('title','author_num')
	# print(res,res1)

	# 2.统计每个出版社卖的最便宜的书的价格(作业:复习原生SQL语句写出来)
	res=models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
	# print(res)

	# 3.统计不止一个作者的图书
	# 1.先按照图书分组求每一本书对应的作者个数
	# 2.过滤出不止一个作者的图书
	res=models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title','author_num')

	# 4.查询每个作者出的书的总价格
	res=models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
	print(res)


	# 按照指定的字段分组
	models.Book.objects.values('price').annotate()

	# 1.查询卖出数大于库存数的书籍
	# F查询
	from django.db.models import F
	# res = models.Book.objects.filter(maichu__gt=F('kucun'))
	# print(res)

	# 2.将所有书籍的价格提升500块
	# models.Book.objects.update(price=F('price') + 500)


	# 3.将所有书的名称后面加上爆款两个字
	"""
	在操作字符类型的数据的时候 F不能够直接做到字符串的拼接
	"""
	from django.db.models.functions import Concat
	from django.db.models import Value
	models.Book.objects.update(title=Concat(F('title'), Value('爆款')))

	# models.Book.objects.update(title=F('title') + '爆款') # 所有的名称会全部变成空白

	# Q查询
	# 1.查询卖出数大于100或者价格小于600的书籍
	res = models.Book.objects.filter(maichu__gt=100,price__lt=600)
	"""filter括号内多个参数是and关系"""
	from django.db.models import Q
	res = models.Book.objects.filter(Q(maichu__gt=100),Q(price__lt=600)) # Q包裹逗号分割还是and关系
	res = models.Book.objects.filter(Q(maichu__gt=100)\|Q(price__lt=600)) # \| or关系
	res = models.Book.objects.filter(~Q(maichu__gt=100)\|Q(price__lt=600)) # ~ not关系
	# print(res)

	# Q的高阶用法能够将查询条件的左边也变成字符串的形式比如搜索功能
	q = Q() # 产生一个空对象，默认是and关系，可以修改为or
	q.connector = 'or'
	q.children.append(('maichu__gt',100))
	q.children.append(('price__lt',600))
	res = models.Book.objects.filter(q) # 默认还是and关系
	print(res)

	from django.db import transaction
	try:
	with transaction.atomic():
	# sql1
	# sql2
	...
	# 在with代码快内书写的所有orm操作都是属于同一个事务
	except Exception as e:
	print(e)
	print('执行其他操作')

	class MyCharField(models.Field):
	def __init__(self,max_length,args,*kwargs):
	self.max_length = max_length
	# 调用父类的init方法
	super().__init__(max_length=max_length,args,*kwargs) # 一定要是关键字的形式传入

	def db_type(self, connection):
	"""
	返回真正的数据类型及各种约束条件
	:param connection:
	:return:
	"""
	return 'char(%s)'%self.max_length

	# 自定义字段使用
	myfield = MyCharField(max_length=16,null=True)

	res = models.Book.objects.only('title')
	res = models.Book.objects.all()

	print(i.title) # 点击only括号内的字段不会走数据库
	print(i.price) # 点击only括号内没有的字段会重新走数据库查询而all不需要走了

	res = models.Book.objects.defer('title') # 对象除了没有title属性之外其他的都有
	for i in res:
	print(i.price)

	res = models.Book.objects.select_related('publish')
	for i in res:
	print(i.publish.name)

	"""
	select_related内部直接先将book与publish连起来然后一次性将大表里面的所有数据,全部封装给查询出来的对象,这个时候对象无论是点击book表的数据还是publish的数据都无需再走数据库查询了
	select_related括号内只能放外键字段一对多一对一可以,多对多不行
	"""

	res = models.Book.objects.prefetch_related('publish') # 子查询
	"""
	prefetch_related该方法内部其实就是子查询
	将子查询查询出来的所有结果也给你封装到对象中
	给你的感觉好像也是一次性搞定的
	"""
	for i in res:
	print(i.publish.name)

	class User(models.Model):
	username = models.CharField(max_length=32)
	age = models.IntegerField()
	# 性别
	gender_choices = (
	(1,'男'),
	(2,'女'),
	(3,'其他'),
	)

	score_choices = (
	('A','优秀'),
	('B','良好'),
	('C','及格'),
	('D','不合格'),
	)
	# 保证字段类型跟列举出来的元祖第一个数据类型一致即可
	score = models.CharField(choices=score_choices,null=True)
	gender = models.IntegerField(choices=gender_choices)


	# 存的时候没有列举出来的数字也能存（范围还是按照字段类型决定）

	# 取
	user_obj = models.User.objects.filter(pk=1).first()
	# print(user_obj.gender) # 不能取到值
	# 只要是choices参数的字段如果你想要获取对应信息固定写法 get_字段名_display()
	# print(user_obj.get_gender_display())

	user_obj = models.User.objects.filter(pk=4).first()
	# 如果没有对应关系那么字段是什么还是展示什么
	print(user_obj.get_gender_display()) # 4

	# MTV:Django号称是MTV模型
	M:models
	T:templates
	V:views
	# MVC:其实django本质也是MVC
	M:models
	V:views
	C:controller # 控制器

	# vue框架:MVVM模型