Django进阶-ORM框架的一般操作

必知必会

返回QuerySet对象

1 .all()            # 所有
2 .filter()            # 符合条件的
3 .exclude()        # 排除符合条件的
4 .values()            # 取出相应的字段值(不写字段,取出所有), 可以连表取值 --> 字典格式{}
5 .values_list()    # 取出相应的字段值(不写字段,取出所有), 可以连表取值 --> 元祖格式()
6 .order_by()        # 对查询结果排序
7 .reverse()        # 对查询结果反向排序, 只能在已定义顺序的QuerySet上调用
8 .distinct()        # 去重

返回具体对象

9 .get()            # 符合条件的, 只返回一个,找不到就报错
10 .first()            # 返回第一个
11 .last()            # 返回最后一个

返回布尔值

12 .exists()        # 判断表里有没有数据

返回具体数值

13. count()            # 返回查询到的QuerySet的数量

总体示例

import os

if __name__ == "__main__":
    # 加载Django项目的配置信息
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ormday69.settings")
    # 导入Django, 并启动
    import django
    django.setup()

    from app01 import models
    ret = models.Person.objects.all()
    print(ret)

    ret = models.Person.objects.filter(name=‘一米‘)
    print(ret)

    ret = models.Person.objects.get(id=1)
    print(ret)

    ret = models.Person.objects.exclude(name=‘小黑‘)
    print(ret)

    ret = models.Person.objects.values(‘name‘)
    print(ret)

    ret = models.Person.objects.values_list()
    print(ret)

    ret = models.Person.objects.values_list().order_by(‘birthday‘)
    print(ret)

    ret = models.Person.objects.all().order_by(‘age‘).reverse()
    print(ret)

    ret = models.Person.objects.all().count()
    print(ret)

    ret = models.Person.objects.all().first()
    print(ret)

    ret = models.Person.objects.all().last()
    print(ret)

    ret = models.Person.objects.exists()
    print(ret)

必知必会.py

表单查询之双下划线

    __gt=                # 大于
    __lt=                # 小于
    __in=                # 在[a,b,c,d]里面的
    __range=            # 在[a,b]之间的 (包含a b)    

    __contains=            # 包含
    __icontains=        # 包含            (忽略大小写)

    __startswith=        # 以...开头
    __istartswith=        # 以...开头        (忽略大小写)
    __endswith=            # 以...结尾
    __iendswith=        # 以...结尾        (忽略大小写)

    __year=                # date类型字段的年份是
    __month=            # date类型字段的月份是
    __day=                # date类型字段的日份是

#!./usr/bin/env python
# -*- coding: utf-8 -*-
# Date: 2018/10/1

import os

if __name__ == "__main__":
    # 加载Django项目的配置信息
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ormday69.settings")
    # 导入Django, 并启动
    import django
    django.setup()

    from app01 import models

    ret = models.Person.objects.filter(id__gt=1, id__lt=4)      # id大于1,小于4
    print(ret)

    ret = models.Person.objects.filter(id__in=[1, 4])       # id 在[1, 4]里面的
    print(ret)

    ret = models.Person.objects.exclude(id__in=[1, 4])      # id 不在[1, 4]里面的
    print(ret)

    ret = models.Person.objects.filter(name__contains=‘小‘)  # name字段有‘小‘的
    print(ret)

    ret = models.Person.objects.filter(name__icontains=‘ven‘)  # name字段有‘ven‘的,且忽略大小写
    print(ret)

    ret = models.Person.objects.filter(id__range=[1, 4])       # id大于等于,小于1小于4
    print(ret)

    ret = models.Person.objects.filter(name__startswith=‘s‘)  # name字段以‘s‘开头的
    print(ret)

    ret = models.Person.objects.filter(name__istartswith=‘s‘)  # name字段以‘s‘开头的(忽略大小写)
    print(ret)

    ret = models.Person.objects.filter(name__endswith=‘d‘)  # name字段以‘d‘结束的
    print(ret)

    ret = models.Person.objects.filter(name__iendswith=‘d‘)  # name字段以‘d‘结束的(忽略大小写)
    print(ret)

    ret = models.Person.objects.filter(birthday__year=2000)  # birthday的年份是2000的
    print(ret)

    ret = models.Person.objects.filter(birthday__month=8)    # birthday的月份是8月的
    print(ret)

    ret = models.Person.objects.filter(birthday__day=15)  # birthday的天是15的
    print(ret)

    ret = models.Person.objects.filter(birthday__year=2018, birthday__month=8)  # birthday的年份是2000,且月份是8月的
    print(ret)

双下划线.py

外键的跨表查询

正向查找

正向查找有两种方式,一种基于对象,一种基于双下划线

1 基于对象

--> 对具体的对象操作

book_obj1 = models.Book.objects.first()         # 具体的book对象
ret = book_obj1.publisher.name                    # 基于publisher对象
print(ret)

2 基于双下方法

--> 对queryset对象操作

book_obj = models.Book.objects.all()                # QuerySet的对象
ret = book_obj.values(‘publisher__name‘).distinct()    # 基于双下划线
print(ret)

反向查找

反向查找有两种方式,一种基于对象,一种基于双下划线

1 基于对象

--> 对具体的对象操作

publisher_obj = models.Publisher.objects.first()        # 具体的publisher对象
ret = publisher_obj.books.all()                            # 基于books对象(通过related_name关联)
print(ret)

2 基于双下方法

--> 对queryset对象操作

publisher_obj = models.Publisher.objects.all()            # QuerySet对象
ret = publisher_obj.values_list(‘books__title‘)            # 基于双下划线(通过related_name关联)
print(ret)

ManyToManyField

"关联管理器"是在一对多或者多对多的关联上下文中使用的管理器。

它存在于下面两种情况：
　　外键关系的反向查询
　　多对多关联关系

简单来说就是当 【点】【后面的对象】 可能存在多个的时候就可以使用以下的方法。

方法

    1 .create()        # 创建一个新的对象
    2 .add()        # 添加对象
    3 .set()        # 更新model对象的关联对象

    4 .remove()        # 移除执行的model对象    --> 与之关联的值要允许为空
    5 .clear()        # 清空对象                --> 与之关联的值要允许为空

#!./usr/bin/env python
# -*- coding: utf-8 -*-
# Date: 2018/10/2

import os

if __name__ == "__main__":
    # 加载Django项目的配置信息
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ormday69.settings")
    # 导入Django, 并启动
    import django
    django.setup()

    from app01 import models

    author_obj = models.Author.objects.first()
    print(author_obj)
    # 查询
    ret = author_obj.books.all()
    print(ret)

    # author_obj.books.create(title="金老板自传", publisher_id=1)      # 创建一本书

    # book_obj = models.Book.objects.last()
    # print(book_obj)
    # author_obj.books.add(book_obj)                    # 单个对象
    # book_objs = models.Book.objects.filter(id__gt=9)
    # print(book_objs)
    # author_obj.books.add(*book_objs)                  # 多个对象
    # author_obj.books.add(12)                          # 通过ID添加

    # ret = author_obj.books.all()
    # print(ret)
    # books = models.Book.objects.filter(id__lt=4)
    # print(books)
    # author_obj.books.set(books)                     # 更新

    # yuan_obj = models.Author.objects.get(id=4)
    # print(yuan_obj)
    # del_book = models.Book.objects.get(id=3)            # 移除del_book这本书对象
    # yuan_obj.books.remove(del_book)
    # yuan_obj.books.remove(5)                          # 移除id为5的书

    # yuan_obj = models.Author.objects.get(id=4)
    # yuan_obj.books.clear()                            # 清空books
    # 补充(外键的反向操作)
    # publisher_obj = models.Publisher.objects.get(id=4)
    # print(publisher_obj)
    # publisher_obj.books.clear()         # 这样操作的时候,书的出版社id要允许为空

    print("新的测试".center(80, ‘#‘))
    authors_objs = models.Book.objects.first().authors

    # 查询id1的书的作者
    book_obj = models.Book.objects.get(id=1)
    print(book_obj)
    print(book_obj.authors)

manytomanyfied操作.py

聚合和分组

--> 对queryset对象操作

导入

from django.db.models import Avg, Sum, Max, Min, Count

聚合(aggregate)

--> 整体　　　　　　整体指的是一整张表

根据某个字段聚合得到一条结果

models.Book.objects.all().aggregate(Avg("price"))            # 不指定名称,默认为price__avg
models.Book.objects.aggregate(average_price=Avg(‘price‘))    # 为聚合值指定一个名称
models.Book.objects.all().aggregate(Avg("price"), Max("price"), Min("price"))    # 生成多个聚合

分组(annotate)

--> 涉及到每一个　　　　每一个指的是, 例如每一个作者,每一本书,每个出版社

示例1

# 查询每一本书的作者个数
# 先对每一本【书分组】, 再对【作者id做聚合处理】,现在ret仍然是book列表,但多了author_num字段

ret = models.Book.objects.all().annotate(author_num=Count(‘authors‘))        # 写不写all()都可以
# print(ret.values(‘title‘, ‘author_num‘))
for i in ret:
    print(‘书:{} 个数:{}‘.format(i.title, i.author_num))

# 流程分析
　　1 先从书这张表里对【书进行分组】
　　2 对【作者聚合】,根据聚合函数做相应操作

示例2

# 统计出每个出版社卖的最便宜的书的价格
# 先对【出版社分组,再对【书的价钱聚合处理】,现在ret仍然是book列表,但多了min_price字段

ret = models.Publisher.objects.annotate(min_price=Min(‘books__price‘))
# print(ret.values(‘name‘, ‘min_price‘))
for i in ret:
    print(‘出版社:{} 价格:{}‘.format(i.name, i.min_price))

示例3

--> 方法二

# 统计出每个出版社卖的最贵的书的价格
# 先在book里连表->publisher__name, 再根据publisher__name进行分组,再对price做聚合处理

ret = models.Book.objects.values(‘publisher__name‘).annotate(max_price=Max(‘price‘))
for i in ret:
    print(i)

示例4

# 统计不止一个作者的图书 --> 先统计每本书的作者个数

ret = models.Book.objects.annotate(Count(‘authors‘)).filter(authors__count__gt=0)
print(ret.values(‘title‘, ‘authors__count‘))

示例5

# 查询各个作者出的书的总价格

ret = models.Author.objects.annotate(Sum(‘books__price‘))
# print(ret.values(‘name‘, ‘books__price__sum‘))
for i in ret.values(‘name‘, ‘books__price__sum‘):
    print(i)

F查询和Q查询

导入

from django.db.models import F, Q

F查询

同一列数据的两个字段做比较
相当于SQL原生语句里的子查询

示例1

# 库存大于卖出数的

ret = models.Book.objects.filter(kucun__gt=F("maichu"))
print(ret)

示例2

# 刷单, 把每一本数的卖出书都乘于3

models.Book.objects.update(maichu=((F(‘maichu‘)+1)*3))

示例3

# 所有的书加上 第一版

from django.db.models.functions import Concat
from django.db.models import Value
models.Book.objects.update(title=Concat(F(‘title‘), Value("第一版")))

Q查询

ORM的【或操作】

示例1

# 查询卖出数大于1000 或者 价格小于100的所有书

ret = models.Book.objects.filter(Q(maichu__gt=1000) | Q(price__lt=100))
print(ret)

示例2(注意)

# 在示例的基础上, 筛选出名字含有"金老板"的字段

# Q查询和字段查询同时存在时, 字段查询要放在Q查询的后面

ret = models.Book.objects.filter(Q(maichu__gt=1000) | Q(price__lt=100), title__contains=‘金老板‘)
print(ret)

原文地址：https://www.cnblogs.com/sunch/p/9739906.html

时间： 2024-10-24 20:32:25

Django进阶-ORM框架的一般操作的相关文章

Django进阶-ORM框架

对应关系 ORM能做的事 操作数据表 --> 创建表/删除表/修改表 操作数据行 --> 数据的增删改查 注意: 不能创建数据库 使用Django中的ORM连接MySQL 配置 1, 先自己建库 2, 在settings.py里面配置一下数据库的连接信息(告诉Django连接哪一个数据库) DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'day62', 'HOST': '127.0.0.1',

Django进阶 messages框架

在 web 应用程序中,通常需要在处理表单或其他类型的用户输入之后,向用户显示一个通知消息(也称为 flash message).对于这个功能,Django 提供基于 Cookie 和会话的消息,无论是匿名用户还是认证的用户.消息框架允许临时将消息存储在请求中,并在下一个请求中提取它们并显示.每个消息都带有一个特定 level 标签,表示其优先级. 启用消息框架 消息框架的实现通过一个中间件类和对应的上下文处理器.django-admin startproject 命令创建的默认 setting

八、Django的orm之多表操作（二）

一.查询(重点) 基于对象的跨表查询 -- 类似于子查询 正向查询和反向查询 关系属性(字段)写在哪个表里面,从当前类(表)的数据去查询它关联类(表)的数据叫做正向查询,反之叫做反向查询 一对一查询 正向查询 # 1.查询jiege的地址 author_obj = models.Author.objects.get(name='jiege') print(author_obj.authorDetail.addr) # 或者用filter这种查,但是要加.first()变成models对象,否则报

Django之自带ORM框架

前言 Django的工作流程 1.客户端发送请求到达 URL2.URL把客户端请求转发给请求函数3.视图函数 使用原生SQL或者ORM去数据库拿到数据进行渲染(模板+数据渲染)4.return 返回给客户端   Django大而全 本文主要介绍Django的ORM框架 一.使用Django的ORM 1.创建数据库 (注意设置 数据的字符编码) create database day70 default character set utf8 collate utf8_general_ci; 2.修

[Django]Django的orm中get和filter的不同

Django的orm中get和filter的不同 Django的orm框架对于业务复杂度不是很高的应用来说还是不错的,写起来很方面,用起来也简单.对于新手来说查询操作中最长用的两个方法get和filter有时候一不注意就会犯下一些小错误.那么今天就来小节下这两个方法使用上的不同. 我常用的是1.5版本的django,就以此为例来说说吧. 文档 首先对比下两个函数文档上的解释. get Returns the object matching the given lookup parameters,

ORM框架SQLAlchemy学习（未整理完）

一.基本介绍 以下介绍来自维基百科,自由的百科全书. SQLAlchemy是Python编程语言下的一款开源软件.提供了SQL工具包及对象关系映射(ORM)工具,使用MIT许可证发行. SQLAlchemy“采用简单的Python语言,为高效和高性能的数据库访问设计,实现了完整的企业级持久模型”.SQLAlchemy的理念是,SQL数据库的量级和性能重要于对象集合:而对象集合的抽象又重要于表和行.因此,SQLAlchmey采用了类似于Java里Hibernate的数据映射模型,而不是其他ORM框

Django的orm中get和filter的不同

Django的orm框架对于业务复杂度不是很高的应用来说还是不错的,写起来很方面,用起来也简单.对于新手来说查询操作中最长用的两个方法get和filter有时候一不注意就会犯下一些小错误.那么今天就来小节下这两个方法使用上的不同. 首先对比下两个函数文档上的解释. get Returns the object matching the given lookup parameters, which should be in the format described in Field lookups

Django模型层之单表操作

Django模型层之单表操作 一 .ORM简介 我们在使用Django框架开发web应用的过程中,不可避免地会涉及到数据的管理操作(如增.删.改.查),而一旦谈到数据的管理操作,就需要用到数据库管理软件,例如mysql.oracle.Microsoft SQL Server等. 如果应用程序需要操作数据(比如将用户注册信息永久存放起来),那么我们需要在应用程序中编写原生sql语句,然后使用pymysql模块远程操作mysql数据库,详见图一^①^ 但是直接编写原生sql语句会存在两方面的问题,严

Django框架进阶5 models常用字段及参数, choices参数, 自动显示sql命令配置, orm查询优化相关, orm中的事务操作, MTV与MVC模型, 图书管理系统(图书的增删改查)

models中的常用字段 AutoField(primary_key=True) 主键   (int自增列,必须填入参数 primary_key=True.当model中如果没有自增列,则自动会创建一个列名为id的列.) CharField(max_length=32)     varchar(32) IntegerField()       int BigIntergerField()           bigint DecimalField()    decimal EmailField(