Django模型层（一）（测试环境搭配常见的十几种查询方法-ORM关键字 ORM执行SQL语句双下划线查询 ORM外键字段的创建外键字段数据的增删改查多表查询（子查询，连表查询）聚合、分组、F和Q查询）

切换数据库
自带的sqlite3数据库对时间字段不敏感有时候会展示错乱，所以我们习惯切换成常见的数据库比如MySQL django orm并不会自动帮你创建库，所以需要提前准备好！
单独搭配测试环境
单独测试django某个功能层，默认不允许单独测试某个py文件，如果想要测试某个py文件(主要models.py)，主要有如下两种方法
测试环境1:pycharm提供的python console
测试环境2:自己搭建(自带的test或者自己创建)

    # 拷贝manage.py前四行
	import os
	import sys
	def main():
   	os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'djangoday05.settings')
  #  自己再加两行
        import django
        jango.setup()

django orm底层还是SQL语句我们是可以查看的

如果我们手上是一个QuerySet对象那么可以直接点query查看SQL语句

如果想查看所有orm底层的SQL语句也可以在配置文件添加日志记录

查看原生SQL语句代码块(放在配置文件最下面)

 LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level': 'DEBUG',
        },
    }
}

在models.py文件中创建新的表

 class User(models.Model):
    name = models.CharField(max_length=32, verbose_name='用户名')
    age = models.IntegerField(verbose_name='年龄')
    register_time = models.DateTimeField(verbose_name='注册时间', auto_now_add=True)
    '''
    针对时间字段有两个重要的参数
        auto_now:每次操作数据都会自动更新当前时间
        auto_now_add:创建数据自动获取当前时间 后续修改不人为操作的情况下不会更新
    '''
 
    def __str__(self):
        return f'用户对象{self.name}'

二、常见的十几种查询方法-ORM关键字

基本关键字

增 create()

 # 第一种方式
     models.User.objects.create(username='kevin1', password='123', age=20)
     models.User.objects.create(username='kevin2', password='123', age=20)
     models.User.objects.create(username='kevin3', password='123', age=20)
     models.User.objects.create(username='kevin4', password='123', age=20)
# 第二种方式
     res = models.User(username='tank', password=123, age=18)
     res.save()

查 filter() first() last()

  # filter()  
 # 根据条件筛选数据  结果是QuerySet [数据对象1,数据对象2]
     res = models.User.objects.filter()
     res = models.User.objects.filter(name='jason')
     res = models.User.objects.filter(name='jason', age=19)  # 括号内支持多个条件但是默认是and关系
 #  first() last()  
 #  QuerySet支持索引取值但是只支持正数 并且orm不建议你使用索引
     res = models.User.objects.filter()[1]
     res = models.User.objects.filter(pk=100)[0]  # 数据不存在索引取值会报错
     res = models.User.objects.filter(pk=100).first()  # 数据不存在不会报错而是返回None
     res = models.User.objects.filter().last()  # 数据不存在不会报错而是返回None

改 update()

 # update()  更新数据(批量更新)
     models.User.objects.filter().update()     批量更新
     models.User.objects.filter(id=1).update() 单个更新
# 方式二：
     user_obj = models.User.objects.filter(pk=1).first()
     user_obj.username = 'jerry'
     user_obj.password = '234'
     user_obj.save()

删 delete()

 # delete()  删除数据(批量删除)
     models.User.objects.filter().delete()      批量删除
     models.User.objects.filter(id=1).delete()  单个删除
# 方式二：
     user_obj = models.User.objects.filter(pk=1).first()
     user_obj.delete()

常用关键字

all() 查询所有数据结果是QuerySet [数据对象1,数据对象2]

     res = models.User.objects.all()

values() 根据指定字段获取数据结果是QuerySet [{},{},{},{}]

     res = models.User.objects.all().values('name')
    res = models.User.objects.filter().values()
    res = models.User.objects.values()

values_list() 根据指定字段获取数据结果是QuerySet [(),(),(),()]

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

distinct() 去重数据一定要一模一样才可以如果有主键肯定不行

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

order_by() 根据指定条件排序默认是升序字段前面加负号就是降序

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

get() 根据条件筛选数据并直接获取到数据对象一旦条件不存在会直接报错不建议使用

     res = models.User.objects.get(pk=1)
    print(res)
    res = models.User.objects.get(pk=100, name='jason')
    print(res)

exclude() 取反操作

     res = models.User.objects.exclude(pk=1)
    print(res)

reverse() 颠倒顺序(被操作的对象必须是已经排过序的才可以)

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

count() 统计结果集中数据的个数

     res = models.User.objects.all().count()
    print(res)

exists() 判断结果集中是否含有数据如果有则返回True 没有则返回False

     res = models.User.objects.all().exists()
    print(res)
    res1 = models.User.objects.filter(pk=100).exists()
    print(res1)

13个必会操作总结

返回QuerySet对象的方法

all()
filter()
exclude()
order by()
reverse()
distinct()

特殊的QuerySet

values()返回一个可选代的字典序列
values list() 返回一个可迭代的元祖序列

返回具体对象的返回具体对象的

get()
first()
last()

返回布尔值的方法有:

exists()

返回数字的方法有

count()

*****************************************test.py文件测试的代码

 from django.test import TestCase
 
# Create your tests here.
 
import os
 
 
def main():
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'djangoday05.settings')
    import django
    django.setup()
    from app01 import models
    # print(models.User.objects.filter())
    # 1.create()  创建数据并直接获取当前创建的数据对象
    # res = models.User.objects.create(name='阿兵', age=28)
    # res = models.User.objects.create(name='oscar', age=18)
    # res = models.User.objects.create(name='jerry', age=38)
    # res = models.User.objects.create(name='jack', age=88)
    # print(res)
    # 2.filter()  根据条件筛选数据  结果是QuerySet [数据对象1,数据对象2]
    # res = models.User.objects.filter()
    # res = models.User.objects.filter(name='jason')
    # res = models.User.objects.filter(name='jason', age=19)  # 括号内支持多个条件但是默认是and关系
    # 3.first() last()  QuerySet支持索引取值但是只支持正数 并且orm不建议你使用索引
    # res = models.User.objects.filter()[1]
    # res = models.User.objects.filter(pk=100)[0]  # 数据不存在索引取值会报错
    # res = models.User.objects.filter(pk=100).first()  # 数据不存在不会报错而是返回None
    # res = models.User.objects.filter().last()  # 数据不存在不会报错而是返回None
    # 4.update()  更新数据(批量更新)
    # models.User.objects.filter().update()     批量更新
    # models.User.objects.filter(id=1).update() 单个更新
    # 5.delete()  删除数据(批量删除)
    # models.User.objects.filter().delete()      批量删除
    # models.User.objects.filter(id=1).delete()  单个删除
    # 6.all()     查询所有数据    结果是QuerySet [数据对象1,数据对象2]
    # res = models.User.objects.all()
    # 7.values()  根据指定字段获取数据    结果是QuerySet [{},{},{},{}]
    # res = models.User.objects.all().values('name')
    # res = models.User.objects.filter().values()
    # res = models.User.objects.values()
    # 8.values_list()   根据指定字段获取数据  结果是QuerySet [(),(),(),()]
    # res = models.User.objects.all().values_list('name','age')
    # 9.distinct()   去重 数据一定要一模一样才可以 如果有主键肯定不行
    # res = models.User.objects.values('name','age').distinct()
    # 10.order_by()  根据指定条件排序  默认是升序 字段前面加负号就是降序
    # res = models.User.objects.all().order_by('age')
    # print(res)
    # 11.get()   根据条件筛选数据并直接获取到数据对象  一旦条件不存在会直接报错 不建议使用
    # res = models.User.objects.get(pk=1)
    # print(res)
    # res = models.User.objects.get(pk=100, name='jason')
    # print(res)
    # 12.exclude()  取反操作
    # res = models.User.objects.exclude(pk=1)
    # print(res)
    # 13.reverse()  颠倒顺序(被操作的对象必须是已经排过序的才可以)
    # res = models.User.objects.all()
    # res = models.User.objects.all().order_by('age')
    # res1 = models.User.objects.all().order_by('age').reverse()
    # print(res, res1)
    # 14.count()  统计结果集中数据的个数
    # res = models.User.objects.all().count()
    # print(res)
    # 15.exists()  判断结果集中是否含有数据 如果有则返回True 没有则返回False
    res = models.User.objects.all().exists()
    print(res)
    res1 = models.User.objects.filter(pk=100).exists()
    print(res1)
main()

三、ORM执行SQL语句

有时候ORM的操作效率可能偏低我们是可以自己编写SQL的

方式1:

     res = models.User.objects.raw('select * from app01_user;')
    print(list(res))

方式2:

     from django.db import connection
    cursor = connection.cursor()
    cursor.execute('select name from app01_user;')
    print(cursor.fetchall())

四、双下划线查询

1._ _gt
查询年龄大于18的用户数据

      res = models.User.objects.filter(age__gt=18)
     print(res)

2._ _lt
查询年龄小于38的用户数据

     res = models.User.objects.filter(age__lt=38)
    print(res)

3._ _gte _ _lte
大于等于小于等于

      res = models.User.objects.filter(age__gte=18)
     res = models.User.objects.filter(age__lte=38)

4._ _in
查询年龄是18或者28或者38的数据

      res = models.User.objects.filter(age__in=(18, 28, 38))
     print(res)

5._ _range
查询年龄范围在18-38的用户数据

      res = models.User.objects.filter(age__range=(18, 38))
     print(res)

6._ _contains
查询名字中含有字母j的数据

      select *from user where username like '%s%' 模糊查询
     res = models.User.objects.filter(name__contains='j')  # 区分大小写
     print(res)
     res = models.User.objects.filter(name__icontains='j')  # 不区分大小写
     print(res)

7._ _year 、 _ _month
1.查询注册年份是2022的数据
2.查询出注册时间是 2023 5月

      res = models.User.objects.filter(register_time__year=2022)
     print(res)
     res= models.User.objects.filter(reg_time__month='5',reg_time__year='2023')

PS：只要还是queryset对象就可以无限制的点queryset对象的方法

    queryset.filter().values().filter().values_list().filter()

针对django框架的时区问题是需要配置文件中修改的后续bbs讲解

五、ORM外键字段的创建

复习MySQL外键关系

   一对多:		外键字段建在多的一方

   多对多:		外键字段统一建在第三张关系表

   一对一:		建在任何一方都可以 但是建议建在查询频率较高的表中

ps:关系的判断可以采用换位思考原则熟练的之后可以瞬间判断

1.创建基础表(书籍表、出版社表、作者表、作者详情)

图书表

 class Book(models.Model):
    """图书表"""
    title = models.CharField(max_length=32, verbose_name='书名')
    price = models.DecimalField(max_digits=8, decimal_places=2, verbose_name='价格')
    publish_time = models.DateField(auto_now_add=True, verbose_name='出版日期')
 
    # ORM创建书籍与出版社的一对多外键字段     由于书籍是多的一方，所以外键建在书籍
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    '''django1.x版本外键字段默认都是级联更新删除 django2.x及以上需要自己申明  on_delete=models.XXX '''
    # 创建书籍与作者的多对多外键字段
    authors = models.ManyToManyField(to='Author')
    '''多对多字段为虚拟字段 用于告诉ORM自动创建第三张表'''
 
    def __str__(self):
        return f'数据对象:{self.title}'

出版社表

 class Publish(models.Model):
    """出版社表"""
    name = models.CharField(max_length=32, verbose_name='名称')
    address = models.CharField(max_length=64, verbose_name='地址')
 
    def __str__(self):
        return f'出版社对象:{self.name}'

作者表

 class Author(models.Model):
    """作者表"""
    name = models.CharField(max_length=32, verbose_name='姓名')
    age = models.IntegerField(verbose_name='年龄')
    # 创建作者与作者详情的一对一外键字段
    author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)
 
    def __str__(self):
        return f'作者对象:{self.name}'

作者详情表

 class AuthorDetail(models.Model):
    """作者详情表"""
    phone = models.BigIntegerField(verbose_name='手机号')
    address = models.CharField(max_length=64, verbose_name='家庭住址')
 
    def __str__(self):
        return f'详情对象:{self.address}'

2.确定外键关系(语句已经写在上面)

一对多 ORM与MySQL一致外键字段建在多的一方
图书和出版社关系表
外键建在图书表
多对多 ORM比MySQL有更多变化
图书和作者关系表
1.外键字段可以直接建在某张表中(查询频率较高的)
内部会自动帮你创建第三张关系表
2.自己创建第三张关系表并创建外键字段
详情后续讲解
一对一 ORM与MySQL一致
外键字段建在查询较高的一方

3.ORM创建（细节，要注意）

针对一对多和同步到表中之后会自动加_id的后缀

 # 一对多
    publish = models.ForeignKey(to='Publish',on_delete=models.CASCADE)
# 一对一
    author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)

针对多对多不会在表中有展示而是创建第三张表

     authors = models.ManyToManyField(to='Author')

四、创建好的表

六、外键字段数据的增删改查

针对一对多，有两种方式,既可以传数字也可以传对象（第一种方便，第二种用的多)

方式一：插入数据可以直接填写表中的实际字段

      models.Book.objects.create(title='三国演义', price=888.88, publish_id=1)
     models.Book.objects.create(title='人性的弱点', price=777.55, publish_id=1)

方式二：插入数据也可以填写表中的类中字段名

      publish_obj = models.Publish.objects.filter(pk=1).first()
     models.Book.objects.create(title='水浒传', price=555.66, publish=publish_obj)

ps:一对一与一对多一致

针对多对多关系绑定

添加关系 add（）

方式一：先通过外键所在图书表的id值找到所要绑定的图书对象，直接通过默认的作者id进行add关键字添加

      book_obj = models.Book.objects.filter(pk=1).first()
     book_obj.authors.add(1)  # 在第三张关系表中给当前书籍绑定作者
     book_obj.authors.add(2, 3)

方式二：先通过外键所在图书表的id值找到所要绑定的图书对象，再通过作者表的id找到需要绑定的作者对象，然后进行add关键字添加

      book_obj = models.Book.objects.filter(pk=4).first()
     author_obj1 = models.Author.objects.filter(pk=1).first()
     author_obj2 = models.Author.objects.filter(pk=2).first()
     book_obj.authors.add(author_obj1)
     book_obj.authors.add(author_obj1, author_obj2)

修改关系 set（）这里必须要写元组或者列表

方式一：放数字

      book_obj = models.Book.objects.filter(pk=1).first()
     book_obj.authors.set((1, 3))  # 修改关系
     book_obj.authors.set([2, ])  # 修改关系

方式二：放作者对象

      author_obj1 = models.Author.objects.filter(pk=1).first()
     author_obj2 = models.Author.objects.filter(pk=2).first()
     book_obj.authors.set((author_obj1,))
     book_obj.authors.set((author_obj1, author_obj2))

删除关系 remove（）

方式一：放数字

      book_obj.authors.remove(2)
     book_obj.authors.remove(1, 3)

方式二：放作者对象

      book_obj.authors.remove(author_obj1,)
     book_obj.authors.remove(author_obj1,author_obj2)

清除指定所有 clear（）

     book_obj.authors.clear()

小总结：
add()\remove() 多个位置参数(数字对象)
set() 可迭代对象(元组列表) 数字对象
clear() 情况当前数据对象的关系

七、ORM跨表查询介绍（多表查询——子查询，连表查询）

复习MySQL跨表查询的思路

 子查询
	分步操作:将一条SQL语句用括号括起来当做另外一条SQL语句的条件
连表操作
	先整合多张表之后基于单表查询即可
		inner join	内连接
		left join	左连接
		right join	右连接

正反向查询的概念(重要)

 正向查询
	由外键字段所在的表数据查询关联的表数据 正向
反向查询
	没有外键字段的表数据查询关联的表数据	 反向
ps:正反向的核心就看外键字段在不在当前数据所在的表中

ORM跨表查询的口诀(重要)

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

八、基于对象的跨表查询（等价MySQL子查询分步操作）

正向查询

1.查询主键为1的书籍对应的出版社名称

     # 先根据条件获取数据对象
    # book_obj = models.Book.objects.filter(pk=1).first()
    # 再判断正反向的概念  由书查出版社 外键字段在书所在的表中 所以是正向查询
    # print(book_obj.publish.name)      # 外键字段是publish

2.查询主键为4的书籍对应的作者姓名

     # 先根据条件获取数据对象
    # book_obj = models.Book.objects.filter(pk=4).first()
    # 再判断正反向的概念  由书查作者 外键字段在书所在的表中 所以是正向查询
    # print(book_obj.authors)  # app01.Author.None  多对多关系，可能有多个结果
    # print(book_obj.authors.all())
    # print(book_obj.authors.all().values('name'))

3.查询jason的电话号码

 author_obj = models.Author.objects.filter(name='jason').first()
print(author_obj.author_detail.phone)

反向查询

4.查询北方出版社出版过的书籍

     # publish_obj = models.Publish.objects.filter(name='北方出版社').first()
    # print(publish_obj.book_set)  # app01.Book.None
    # print(publish_obj.book_set.all())

5.查询jason写过的书籍

     # author_obj = models.Author.objects.filter(name='jason').first()
    # print(author_obj.book_set)  # app01.Book.None
    # print(author_obj.book_set.all())

6.查询电话号码是110的作者姓名

     author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
    print(author_detail_obj.author)
    print(author_detail_obj.author.name)

九、基于上双线的跨表查询（等价MySQL连表查询）

正向查询

1.查询主键为1的书籍对应的出版社名称

      res = models.Book.objects.filter(pk=1).values('publish__name','title')
     print(res)

2.查询主键为4的书籍对应的作者姓名

      res = models.Book.objects.filter(pk=4).values('title', 'authors__name')
     print(res)

3.查询jason的电话号码

      res = models.Author.objects.filter(name='jason').values('author_detail__phone')
     print(res)

反向查询

4.查询北方出版社出版过的书籍名称和价格

     # res = models.Publish.objects.filter(name='北方出版社').values('book__title','book__price','name')
    # print(res)

5.查询jason写过的书籍名称

      res = models.Author.objects.filter(name='jason').values('book__title', 'name')
     print(res)

6.查询电话号码是110的作者姓名

     res = models.AuthorDetail.objects.filter(phone=110).values('phone', 'author__name')
    print(res)

进阶操作（models后面的对象就是对应values）

1.查询主键为1的书籍对应的出版社名称

      res = models.Publish.objects.filter(book__pk=1).values('name')
     print(res)

2.查询主键为4的书籍对应的作者姓名

      res = models.Author.objects.filter(book__pk=4).values('name','book__title')
     print(res)

3.查询jason的电话号码

      res = models.AuthorDetail.objects.filter(author__name='jason').values('phone')
     print(res)

4.查询北方出版社出版过的书籍名称和价格

      res = models.Book.objects.filter(publish__name='北方出版社').values('title','price')
     print(res)

5.查询jason写过的书籍名称

      res = models.Book.objects.filter(authors__name='jason').values('title')
     print(res)

6.查询电话号码是110的作者姓名

     res = models.Author.objects.filter(author_detail__phone=110).values('name')
    print(res)

7.查询主键为4的书籍对应的作者的电话号码

     # res = models.Book.objects.filter(pk=4).values('authors__author_detail__phone')
    # print(res)
    # res = models.AuthorDetail.objects.filter(author__book__pk=4).values('phone')
    # print(res)
    res = models.Author.objects.filter(book__pk=4).values('author_detail__phone')
    print(res)

十、聚合查询

聚合函数:Max Min Sum Count Avg

在ORM中支持单独使用聚合函数 aggregate()关键字

 from django.db.models import Max, Min, Sum, Count, Avg
res = models.Book.objects.aggregate(Max('price'), Count('pk'), 最小价格=Min('price'), allPrice=Sum('price'),平均价格=Avg('price'))
print(res)

十一、分组查询 annotate()关键字

"""
如果执行orm分组查询报错并且有关键字sql_mode strict mode
移除sql_mode中的only_full_group_by
"""

统计每一本书的作者个数

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

统计出每个出版社卖的最便宜的书的价格

     # res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name', 'min_price')
    # print(res)

统计不止一个作者的图书

     # 1.先统计每本书的作者个数
    # res = models.Book.objects.annotate(author_num=Count('authors__pk'))

2.筛选出作者个数大于1的数据

     # res = models.Book.objects.annotate(author_num=Count('authors__pk')).filter(author_num__gt=1).values('title', 'author_num')
    # print(res)

查询每个作者出的书的总价格

     # res = models.Author.objects.annotate(总价=Sum('book__price'),count_book=Count('book__pk')).values('name','总价','count_book')
    # print(res)

上面都是按表分组，下面是按指定字段
"""
models.表名.objects.annotate() 按照表分组
models.表名.objects.values('字段名').annotate() 按照values括号内指定的字段分组
"""

     res = models.Book.objects.values('publish_id').annotate(count_pk=Count('pk')).values('publish_id', 'count_pk')
    print(res)

十二、F与Q查询

F

1.查询库存数大于卖出数的书籍
当查询条件不是明确的也需要从数据库中获取就需要使用F查询

 from django.db.models import F
# res = models.Book.objects.filter(kucun__gt=F('maichu'))
# print(res)

2.将所有书的价格涨800

 # models.Book.objects.update(price=F('price') + 800)

3.将所有书的名称后面追加爆款

 from django.db.models.functions import Concat
from django.db.models import Value
models.Book.objects.update(title=Concat(F('title'), Value('新款')))

Q

查询主键是1或者价格大于2000的书籍

 # res = models.Book.objects.filter(pk=1, price__gt=2000)  # 逗号默认是and关系
from django.db.models import Q
# res = models.Book.objects.filter(Q(pk=1), Q(price__gt=2000))  # 逗号是and
# res = models.Book.objects.filter(Q(pk=1) | Q(price__gt=2000))  # |是or
res = models.Book.objects.filter(~Q(pk=1) | Q(price__gt=2000))  # ~是not
print(res.query)

上一篇Django之模板层（变量分配过滤器标签继承和导入自定义过滤器、标签及inclusion_tag(了解)）

下一篇Django之模型层（二） Q查询进阶 ORM查询优化 ORM事务 ORM常用字段类型和字段参数多对多创建方式

本文作者：Python学习之旅

本文链接：https://www.cnblogs.com/yuezongke/p/17357097.html

posted @ 2023-04-26 21:05 岳宗柯阅读(63) 评论(0) 编辑收藏举报

刷新页面返回顶部

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

	# 拷贝manage.py前四行
	import os
	import sys
	def main():
	os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'djangoday05.settings')
	# 自己再加两行
	import django
	jango.setup()

	LOGGING = {
	'version': 1,
	'disable_existing_loggers': False,
	'handlers': {
	'console': {
	'level': 'DEBUG',
	'class': 'logging.StreamHandler',
	},
	},
	'loggers': {
	'django.db.backends': {
	'handlers': ['console'],
	'propagate': True,
	'level': 'DEBUG',
	},
	}
	}

	class User(models.Model):
	name = models.CharField(max_length=32, verbose_name='用户名')
	age = models.IntegerField(verbose_name='年龄')
	register_time = models.DateTimeField(verbose_name='注册时间', auto_now_add=True)
	'''
	针对时间字段有两个重要的参数
	auto_now:每次操作数据都会自动更新当前时间
	auto_now_add:创建数据自动获取当前时间后续修改不人为操作的情况下不会更新
	'''

	def __str__(self):
	return f'用户对象{self.name}'

	# 第一种方式
	models.User.objects.create(username='kevin1', password='123', age=20)
	models.User.objects.create(username='kevin2', password='123', age=20)
	models.User.objects.create(username='kevin3', password='123', age=20)
	models.User.objects.create(username='kevin4', password='123', age=20)
	# 第二种方式
	res = models.User(username='tank', password=123, age=18)
	res.save()

	# filter()
	# 根据条件筛选数据结果是QuerySet [数据对象1,数据对象2]
	res = models.User.objects.filter()
	res = models.User.objects.filter(name='jason')
	res = models.User.objects.filter(name='jason', age=19) # 括号内支持多个条件但是默认是and关系
	# first() last()
	# QuerySet支持索引取值但是只支持正数并且orm不建议你使用索引
	res = models.User.objects.filter()[1]
	res = models.User.objects.filter(pk=100)[0] # 数据不存在索引取值会报错
	res = models.User.objects.filter(pk=100).first() # 数据不存在不会报错而是返回None
	res = models.User.objects.filter().last() # 数据不存在不会报错而是返回None

	# update() 更新数据(批量更新)
	models.User.objects.filter().update() 批量更新
	models.User.objects.filter(id=1).update() 单个更新
	# 方式二：
	user_obj = models.User.objects.filter(pk=1).first()
	user_obj.username = 'jerry'
	user_obj.password = '234'
	user_obj.save()

	# delete() 删除数据(批量删除)
	models.User.objects.filter().delete() 批量删除
	models.User.objects.filter(id=1).delete() 单个删除
	# 方式二：
	user_obj = models.User.objects.filter(pk=1).first()
	user_obj.delete()

	res = models.User.objects.all().values('name')
	res = models.User.objects.filter().values()
	res = models.User.objects.values()

	res = models.User.objects.get(pk=1)
	print(res)
	res = models.User.objects.get(pk=100, name='jason')
	print(res)

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

	res = models.User.objects.all().exists()
	print(res)
	res1 = models.User.objects.filter(pk=100).exists()
	print(res1)

	from django.test import TestCase

	# Create your tests here.

	import os


	def main():
	os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'djangoday05.settings')
	import django
	django.setup()
	from app01 import models
	# print(models.User.objects.filter())
	# 1.create() 创建数据并直接获取当前创建的数据对象
	# res = models.User.objects.create(name='阿兵', age=28)
	# res = models.User.objects.create(name='oscar', age=18)
	# res = models.User.objects.create(name='jerry', age=38)
	# res = models.User.objects.create(name='jack', age=88)
	# print(res)
	# 2.filter() 根据条件筛选数据结果是QuerySet [数据对象1,数据对象2]
	# res = models.User.objects.filter()
	# res = models.User.objects.filter(name='jason')
	# res = models.User.objects.filter(name='jason', age=19) # 括号内支持多个条件但是默认是and关系
	# 3.first() last() QuerySet支持索引取值但是只支持正数并且orm不建议你使用索引
	# res = models.User.objects.filter()[1]
	# res = models.User.objects.filter(pk=100)[0] # 数据不存在索引取值会报错
	# res = models.User.objects.filter(pk=100).first() # 数据不存在不会报错而是返回None
	# res = models.User.objects.filter().last() # 数据不存在不会报错而是返回None
	# 4.update() 更新数据(批量更新)
	# models.User.objects.filter().update() 批量更新
	# models.User.objects.filter(id=1).update() 单个更新
	# 5.delete() 删除数据(批量删除)
	# models.User.objects.filter().delete() 批量删除
	# models.User.objects.filter(id=1).delete() 单个删除
	# 6.all() 查询所有数据结果是QuerySet [数据对象1,数据对象2]
	# res = models.User.objects.all()
	# 7.values() 根据指定字段获取数据结果是QuerySet [{},{},{},{}]
	# res = models.User.objects.all().values('name')
	# res = models.User.objects.filter().values()
	# res = models.User.objects.values()
	# 8.values_list() 根据指定字段获取数据结果是QuerySet [(),(),(),()]
	# res = models.User.objects.all().values_list('name','age')
	# 9.distinct() 去重数据一定要一模一样才可以如果有主键肯定不行
	# res = models.User.objects.values('name','age').distinct()
	# 10.order_by() 根据指定条件排序默认是升序字段前面加负号就是降序
	# res = models.User.objects.all().order_by('age')
	# print(res)
	# 11.get() 根据条件筛选数据并直接获取到数据对象一旦条件不存在会直接报错不建议使用
	# res = models.User.objects.get(pk=1)
	# print(res)
	# res = models.User.objects.get(pk=100, name='jason')
	# print(res)
	# 12.exclude() 取反操作
	# res = models.User.objects.exclude(pk=1)
	# print(res)
	# 13.reverse() 颠倒顺序(被操作的对象必须是已经排过序的才可以)
	# res = models.User.objects.all()
	# res = models.User.objects.all().order_by('age')
	# res1 = models.User.objects.all().order_by('age').reverse()
	# print(res, res1)
	# 14.count() 统计结果集中数据的个数
	# res = models.User.objects.all().count()
	# print(res)
	# 15.exists() 判断结果集中是否含有数据如果有则返回True 没有则返回False
	res = models.User.objects.all().exists()
	print(res)
	res1 = models.User.objects.filter(pk=100).exists()
	print(res1)
	main()

	res = models.User.objects.raw('select * from app01_user;')
	print(list(res))

	from django.db import connection
	cursor = connection.cursor()
	cursor.execute('select name from app01_user;')
	print(cursor.fetchall())

	res = models.User.objects.filter(age__gte=18)
	res = models.User.objects.filter(age__lte=38)

	res = models.User.objects.filter(age__in=(18, 28, 38))
	print(res)

	res = models.User.objects.filter(age__range=(18, 38))
	print(res)

	select *from user where username like '%s%' 模糊查询
	res = models.User.objects.filter(name__contains='j') # 区分大小写
	print(res)
	res = models.User.objects.filter(name__icontains='j') # 不区分大小写
	print(res)

	res = models.User.objects.filter(register_time__year=2022)
	print(res)
	res= models.User.objects.filter(reg_time__month='5',reg_time__year='2023')

	class Book(models.Model):
	"""图书表"""
	title = models.CharField(max_length=32, verbose_name='书名')
	price = models.DecimalField(max_digits=8, decimal_places=2, verbose_name='价格')
	publish_time = models.DateField(auto_now_add=True, verbose_name='出版日期')

	# ORM创建书籍与出版社的一对多外键字段由于书籍是多的一方，所以外键建在书籍
	publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
	'''django1.x版本外键字段默认都是级联更新删除 django2.x及以上需要自己申明 on_delete=models.XXX '''
	# 创建书籍与作者的多对多外键字段
	authors = models.ManyToManyField(to='Author')
	'''多对多字段为虚拟字段用于告诉ORM自动创建第三张表'''

	def __str__(self):
	return f'数据对象:{self.title}'

Python学习之旅

别让世界左右你的情绪，别让情绪影响你的理性！

Django模型层（一） （测试环境搭配 常见的十几种查询方法-ORM关键字 ORM执行SQL语句 双下划线查询 ORM外键字段的创建 外键字段数据的增删改查 多表查询（子查询，连表查询）聚合、分组、F和Q查询）

目录

一、测试环境搭配

二、常见的十几种查询方法-ORM关键字

基本关键字

常用关键字

13个必会操作总结

三、ORM执行SQL语句

四、双下划线查询

五、ORM外键字段的创建

复习MySQL外键关系

1.创建基础表(书籍表、出版社表、作者表、作者详情)

图书表

出版社表

作者表

作者详情表

2.确定外键关系(语句已经写在上面)

3.ORM创建（细节，要注意）

四、创建好的表

六、外键字段数据的增删改查

针对一对多，有两种方式,既可以传数字也可以传对象（第一种方便，第二种用的多)

针对多对多关系绑定

添加关系 add（）

修改关系 set（） 这里必须要写元组或者列表

删除关系 remove（）

清除指定所有 clear（）

七、ORM跨表查询介绍（多表查询——子查询，连表查询）

复习MySQL跨表查询的思路

正反向查询的概念(重要)

ORM跨表查询的口诀(重要)

八、基于对象的跨表查询（等价MySQL子查询 分步操作）

正向查询

反向查询

九、基于上双线的跨表查询（等价MySQL连表查询）

正向查询

反向查询

进阶操作 （models后面的对象就是对应values）

十、聚合查询

聚合函数:Max Min Sum Count Avg

十一、分组查询 annotate()关键字

十二、F与Q查询

F

Q

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

Django模型层（一）（测试环境搭配常见的十几种查询方法-ORM关键字 ORM执行SQL语句双下划线查询 ORM外键字段的创建外键字段数据的增删改查多表查询（子查询，连表查询）聚合、分组、F和Q查询）

修改关系 set（）这里必须要写元组或者列表

八、基于对象的跨表查询（等价MySQL子查询分步操作）

进阶操作（models后面的对象就是对应values）

	class Publish(models.Model):
	"""出版社表"""
	name = models.CharField(max_length=32, verbose_name='名称')
	address = models.CharField(max_length=64, verbose_name='地址')

	def __str__(self):
	return f'出版社对象:{self.name}'

	class Author(models.Model):
	"""作者表"""
	name = models.CharField(max_length=32, verbose_name='姓名')
	age = models.IntegerField(verbose_name='年龄')
	# 创建作者与作者详情的一对一外键字段
	author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)

	def __str__(self):
	return f'作者对象:{self.name}'

	class AuthorDetail(models.Model):
	"""作者详情表"""
	phone = models.BigIntegerField(verbose_name='手机号')
	address = models.CharField(max_length=64, verbose_name='家庭住址')

	def __str__(self):
	return f'详情对象:{self.address}'

	# 一对多
	publish = models.ForeignKey(to='Publish',on_delete=models.CASCADE)
	# 一对一
	author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)

	models.Book.objects.create(title='三国演义', price=888.88, publish_id=1)
	models.Book.objects.create(title='人性的弱点', price=777.55, publish_id=1)

	publish_obj = models.Publish.objects.filter(pk=1).first()
	models.Book.objects.create(title='水浒传', price=555.66, publish=publish_obj)

	book_obj = models.Book.objects.filter(pk=1).first()
	book_obj.authors.add(1) # 在第三张关系表中给当前书籍绑定作者
	book_obj.authors.add(2, 3)

	book_obj = models.Book.objects.filter(pk=4).first()
	author_obj1 = models.Author.objects.filter(pk=1).first()
	author_obj2 = models.Author.objects.filter(pk=2).first()
	book_obj.authors.add(author_obj1)
	book_obj.authors.add(author_obj1, author_obj2)

	book_obj = models.Book.objects.filter(pk=1).first()
	book_obj.authors.set((1, 3)) # 修改关系
	book_obj.authors.set([2, ]) # 修改关系

	author_obj1 = models.Author.objects.filter(pk=1).first()
	author_obj2 = models.Author.objects.filter(pk=2).first()
	book_obj.authors.set((author_obj1,))
	book_obj.authors.set((author_obj1, author_obj2))