Django之ORM

ORM概念

对象关系映射（Object Relational Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。

简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据库中。

ORM在业务逻辑层和数据库层之间充当了桥梁的作用。

ORM的优势

它将一个类和一张表一一对应，类的每个实例对应表中的一条记录，类的每个属性对应表中的每个字段。 

ORM提供了对数据库的映射，不用直接编写SQL代码，只需操作对象就能对数据库操作数据。

让软件开发人员专注于业务逻辑的处理，提高了开发效率。

Django项目使用MySQL数据库

在Django项目的settings.py文件中，配置数据库连接信息：

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.mysql",
        "NAME": "你的数据库名称",  # 需要自己手动创建数据库
        "USER": "数据库用户名",
        "PASSWORD": "数据库密码",
        "HOST": "数据库IP",
        "POST": 3306
    }
}

 在与Django项目同名的目录下的__init__.py文件中写如下代码，告诉Django使用pymysql模块连接MySQL数据库:

import pymysql
 
pymysql.install_as_MySQLdb()

 注意:数据库迁移的时候出现一个警告

WARNINGS: 
?: (mysql.W002) MySQL Strict Mode is not set for database connection 'default'
HINT: MySQL's Strict Mode fixes many data integrity problems in MySQL, such as
data truncation upon insertion, by escalating warnings into errors. It is strongly
recommended you activate it.

 在配置中多加一个OPTIONS参数:

'OPTIONS': {
    'init_command': "SET sql_mode='STRICT_TRANS_TABLES'"},

 Model

在Django中model是你数据的单一、明确的信息来源。它包含了你存储的数据的重要字段和行为。通常，一个模型（model）映射到一个数据库表。

基本情况：

• 每个模型都是一个Python类，它是django.db.models.Model的子类。
• 模型的每个属性都代表一个数据库字段。
• 综上所述，Django为您提供了一个自动生成的数据库访问API，详询官方文档链接。

 

事例说明

下面这个例子定义了一个 Person 模型，包含 first_name 和 last_name。

from django.db import models
 
class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

first_name 和 last_name 是模型的字段。每个字段被指定为一个类属性，每个属性映射到一个数据库列。

上面的 Person 模型将会像这样创建一个数据库表：

CREATE TABLE myapp_person (
    "id" serial NOT NULL PRIMARY KEY,
    "first_name" varchar(30) NOT NULL,
    "last_name" varchar(30) NOT NULL
);

一些说明：

• 表myapp_person的名称是自动生成的，如果你要自定义表名，需要在model的Meta类中指定 db_table 参数，强烈建议使用小写表名，特别是使用MySQL作为数据库时。
• id字段是自动添加的，如果你想要指定自定义主键，只需在其中一个字段中指定 primary_key=True 即可。如果Django发现你已经明确地设置了Field.primary_key，它将不会添加自动ID列。
• 本示例中的CREATE TABLE SQL使用PostgreSQL语法进行格式化，但值得注意的是，Django会根据配置文件中指定的数据库类型来生成相应的SQL语句。
• Django支持MySQL5.5及更高版本。

　　

　　 注意: 流程>>  创建Django项目---在setting中设置(告知Django创建的项目;模板中配置文件位置;数据库配置;静态文件配置)---手动创建数据库---创建表结构(注意配置好项目中__init__文件).

字段

常用字段 

AutoField

自增的整形字段，必填参数primary_key=True，则成为数据库的主键。无该字段时，django自动创建。

一个model不能有两个AutoField字段。

IntegerField

一个整数类型。数值的范围是 -2147483648 ~ 2147483647。

CharField

字符类型，必须提供max_length参数。max_length表示字符的长度。

DateField

日期类型，日期格式为YYYY-MM-DD，相当于Python中的datetime.date的实例。

参数：

• auto_now：每次修改时修改为当前日期时间。(auto_now=True)
• auto_now_add：新创建对象时自动添加当前日期时间。(auto_now_add=True)

auto_now和auto_now_add和default参数是互斥的，不能同时设置。

注意: auto_now和auto_now_add 都是记录时间的参数,但是数据库不提供记录时间功能,

只有Django才会提供记录时间,它俩相互更改时,只需要从models记录下来即可(Python manag.py makemigrations).

DatetimeField

日期时间字段，格式为YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]，相当于Python中的datetime.datetime的实例。

AutoField(Field)
        - int自增列，必须填入参数 primary_key=True
 
    BigAutoField(AutoField)
        - bigint自增列，必须填入参数 primary_key=True
 
        注：当model中如果没有自增列，则自动会创建一个列名为id的列
        from django.db import models
 
        class UserInfo(models.Model):
            # 自动创建一个列名为id的且为自增的整数列
            username = models.CharField(max_length=32)
 
        class Group(models.Model):
            # 自定义自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)
 
    SmallIntegerField(IntegerField):
        - 小整数 -32768 ～ 32767
 
    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正小整数 0 ～ 32767
 
    IntegerField(Field)
        - 整数列(有符号的) -2147483648 ～ 2147483647
 
    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正整数 0 ～ 2147483647
 
    BigIntegerField(IntegerField):
        - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807
 
    BooleanField(Field)
        - 布尔值类型
 
    NullBooleanField(Field):
        - 可以为空的布尔值
 
    CharField(Field)
        - 字符类型
        - 必须提供max_length参数， max_length表示字符长度
 
    TextField(Field)
        - 文本类型
 
    EmailField(CharField)：
        - 字符串类型，Django Admin以及ModelForm中提供验证机制
 
    IPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制
 
    GenericIPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
        - 参数：
            protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
            unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启此功能，需要protocol="both"
 
    URLField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证 URL
 
    SlugField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）
 
    CommaSeparatedIntegerField(CharField)
        - 字符串类型，格式必须为逗号分割的数字
 
    UUIDField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证
 
    FilePathField(Field)
        - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
        - 参数：
                path,                      文件夹路径
                match=None,                正则匹配
                recursive=False,           递归下面的文件夹
                allow_files=True,          允许文件
                allow_folders=False,       允许文件夹
 
    FileField(Field)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
 
    ImageField(FileField)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
            width_field=None,   上传图片的高度保存的数据库字段名（字符串）
            height_field=None   上传图片的宽度保存的数据库字段名（字符串）
 
    DateTimeField(DateField)
        - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]
 
    DateField(DateTimeCheckMixin, Field)
        - 日期格式      YYYY-MM-DD
 
    TimeField(DateTimeCheckMixin, Field)
        - 时间格式      HH:MM[:ss[.uuuuuu]]
 
    DurationField(Field)
        - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型
 
    FloatField(Field)
        - 浮点型
 
    DecimalField(Field)
        - 10进制小数
        - 参数：
            max_digits，小数总长度
            decimal_places，小数位长度
 
    BinaryField(Field)
        - 二进制类型

注意: 这些字段好似一个类名,括号内的是继承其他的类方法,如: AutoField(Field)　AutoField可以看做一个类名,Field是其继承的类,然后通过models调用.　

自定义字段

自定义一个二进制字段，以及Django字段与数据库字段类型的对应关系。

class UnsignedIntegerField(models.IntegerField):
    def db_type(self, connection):
        return 'integer UNSIGNED'
 
# PS: 返回值为字段在数据库中的属性。
# Django字段与数据库字段类型对应关系如下：
    'AutoField': 'integer AUTO_INCREMENT',
    'BigAutoField': 'bigint AUTO_INCREMENT',
    'BinaryField': 'longblob',
    'BooleanField': 'bool',
    'CharField': 'varchar(%(max_length)s)',
    'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
    'DateField': 'date',
    'DateTimeField': 'datetime',
    'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
    'DurationField': 'bigint',
    'FileField': 'varchar(%(max_length)s)',
    'FilePathField': 'varchar(%(max_length)s)',
    'FloatField': 'double precision',
    'IntegerField': 'integer',
    'BigIntegerField': 'bigint',
    'IPAddressField': 'char(15)',
    'GenericIPAddressField': 'char(39)',
    'NullBooleanField': 'bool',
    'OneToOneField': 'integer',
    'PositiveIntegerField': 'integer UNSIGNED',
    'PositiveSmallIntegerField': 'smallint UNSIGNED',
    'SlugField': 'varchar(%(max_length)s)',
    'SmallIntegerField': 'smallint',
    'TextField': 'longtext',
    'TimeField': 'time',
    'UUIDField': 'char(32)',

 自定义一个char类型字段：

class MyCharField(models.Field):  # 继承Field 类
    """
    自定义的char类型的字段类
    """
    def __init__(self, max_length, *args, **kwargs):  # 要接收max_length参数
        self.max_length = max_length　　　　　　　　　　
        super(MyCharField, self).__init__(max_length=max_length, *args, **kwargs)
 
    def db_type(self, connection):
        """
        限定生成数据库表的字段类型为char，长度为max_length指定的值
        """
        return 'char(%s)' % self.max_length　　# 返回给数据库char类型,并指定长度max_length

 使用自定义char类型字段:

class Class(models.Model):
    id = models.AutoField(primary_key=True)
    title = models.CharField(max_length=25)
    # 使用自定义的char类型的字段
    cname = MyCharField(max_length=25)

 

创建的表结构

 

字段参数

null                数据库中字段是否可以为空
 db_column           数据库中字段的列名
 default             数据库中字段的默认值
 primary_key         数据库中字段是否为主键
 db_index            数据库中字段是否可以建立索引
 unique              数据库中字段是否可以建立唯一索引
 unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
 unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
 unique_for_year     数据库中字段【年】部分是否可以建立唯一索引
 
 verbose_name        Admin中显示的字段名称
 blank               Admin中是否允许用户输入为空(数据库不一定允许为空)
 editable            Admin中是否可以编辑
 help_text           Admin中该字段的提示信息
 choices             Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
                     如：sex= models.IntegerField(choices=[(0, '男'),(1, '女'),],default=1)
　　　　　　　　　　　　　　注意: 后者是显示内容,前者是数据库保存的内容
 error_messages      自定义错误信息（字典类型），从而定制想要显示的错误信息；
                     字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
                     如：{'null': "不能为空.", 'invalid': '格式错误'}
 
 validators          自定义错误验证（列表类型），从而定制想要的验证规则
                     from django.core.validators import RegexValidator
                     from django.core.validators import EmailValidator,URLValidator,DecimalValidator,
                     MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
                     如：
                         test = models.CharField(
                             max_length=32,
                             error_messages={
                                 'c1': '优先错信息1',
                                 'c2': '优先错信息2',
                                 'c3': '优先错信息3',
                             },
                             validators=[
                                 RegexValidator(regex='root_d+', message='错误了', code='c1'),
                                 RegexValidator(regex='root_112233d+', message='又错误了', code='c2'),
                                 EmailValidator(message='又错误了', code='c3'), ]
                         )

 Model Meta参数

class UserInfo(models.Model):
    nid = models.AutoField(primary_key=True)
    username = models.CharField(max_length=32)
 
    class Meta:  #(该类是为当前表做的配置)
        # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
        db_table = "table_name"
 
        # admin中显示的表名称
        verbose_name = '个人信息'
 
        # verbose_name加s
        verbose_name_plural = '所有用户信息'
 
        # 联合索引 
        index_together = [
            ("pub_date", "deadline"),   # 应为两个存在的字段
        ]
 
        # 联合唯一索引
        unique_together = (("driver", "restaurant"),)   # 应为两个存在的字段

 必知必会13条

<1> all():                 查询所有结果

<2> get(**kwargs):         返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
 
<3> filter(**kwargs):      它包含了与所给筛选条件相匹配的对象
 
<4> exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象
 
<5> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列
 　　# 没有指定参数,获取所有字段数据(字段和他的值);指定参数就获取指定参数数据 , 如:id,name..
<6> values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
 
<7> order_by(*field):      对查询结果排序
 　　例: ...order_by('id')升序  ...order_by('-id')降序  
<8> reverse():         对查询结果反向排序，请注意reverse()通常只能在具有已定义顺序的
QuerySet上调用(在model类的Meta中指定ordering或调用order_by()方法,先对指定字段进行排序)。
 
<9> distinct():        从返回结果中剔除重复纪录(对象并非字段)(如果你查询跨越多个表，可能在计算QuerySet
时得到重复的结果。此时可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。)
 
<10> count():              返回数据库中匹配查询(QuerySet)的对象数量。
 
<11> first():              返回第一条记录
 
<12> last():               返回最后一条记录
 
<13> exists():             如果QuerySet包含数据，就返回True，否则返回False

 

单表查询(双下划线)

models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值(大于greater than 小于 less than)
 
models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
 
models.Tb1.objects.filter(name__contains="ven")  # 获取name字段包含"ven"的(区分大小写)
models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感(忽略大小写)
 
models.Tb1.objects.filter(id__range=[1, 3])      # id范围是1到3的，等价于SQL的bettwen and
 
类似的还有：startswith(以×为开头)，istartswith(同前且忽略大小写),
　　　　　　endswith(以×结尾), iendswith　

date字段还可以：
models.Class.objects.filter(first_day__year=2017)

外键方法

(利用外键(关联字段)从当前表拿到另一个表的对象,然后再在该对象的基础上查找)

　正向查找(从多到一的查询,一般会把外键设在'多'的一方)

　　对象查找(跨表)

　　语法: 对象.关联字段.字段 

　　示例:

book_obj = models.Book.objects.first()  # 第一本书对象
print(book_obj.publisher)  # 得到这本书关联的出版社对象
print(book_obj.publisher.name)  # 得到出版社对象的名称

字段查找(跨表)

　　语法: 关联字段_字段

　　示例:

print(models.Book.objects.values_list("publisher__name"))

反向操作(从一到多的查询)

　　对象查找

　　语法: obj.表名_set

　　示例:

publisher_obj = models.Publisher.objects.first()  # 找到第一个出版社对象
books = publisher_obj.book_set.all()  # 找到第一个出版社出版的所有书 
　　　　　　　　　　注意:book_set(默认 表名小写_set ,拿到的是关系管理对象)是Django封装的
　　　　　　　　　　但是若只指定releted_name后,就需要改为 指定后的名字_set; 同时也指定
　　　　　　　　　　releted_query_name,则后面的字段查询,就要首先按照 此指定的名字_字段 命名
　　　　　　　　　　若没有指定releted_query_name,字段查询可按照默认或者指定的releted_name命名

titles = books.values_list("title")  # 找到第一个出版社出版的所有书的书名

 

字段查找

　　语法: 表名_字段

　　示例　

titles = models.Publisher.objects.values_list("books__title")
# 在俩张或多张表中'__'双下划线表示跨表

多对多方法

　　

　　方法:

　　create()  创建一个新的对象,保存对象,并将它添加到关联对象之中,返回新创建的对象.

>>> import datetime
>>> models.Author.objects.first().book_set.create(title="番茄物语", publish_date=datetime.date.today())

add()　　把指定的model对象添加到关联对象集中

　　  添加对象

>>> author_objs = models.Author.objects.filter(id__lt=3)
>>> models.Book.objects.first().authors.add(*author_objs)
 

 添加id

>>> models.Book.objects.first().authors.add(*[1, 2])

set()　　更新model对象的关联对象

>>> book_obj = models.Book.objects.first() # 取到第一个书籍对象
>>> book_obj.authors.set([2, 3]) # 为第一个书籍对象设置作者的关联id 2和3.

remove()　　从关联对象集中移除执行的model对象

>>> book_obj = models.Book.objects.first()
>>> book_obj.authors.remove(3)

clear()　　从关联对象集中移除一切对象

>>> book_obj = models.Book.objects.first()
>>> book_obj.authors.clear()

注意: 对于ForeignKey对象, clear()和remove()方法仅在null=True时存在

　　例子:　　ForeignKey字段没设置null=True时,

class Book(models.Model):
    title = models.CharField(max_length=32)
    publisher = models.ForeignKey(to=Publisher)

没有clear()和remove()方法:

>>> models.Publisher.objects.first().book_set.clear()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'RelatedManager' object has no attribute 'clear'

当ForeignKey字段设置null=True时

class Book(models.Model):
    name = models.CharField(max_length=32)
    publisher = models.ForeignKey(to=Class, null=True)

此时就有clear()和remove()方法:

>>> models.Publisher.objects.first().book_set.clear()

注意: 对于所有类型的关联字段,add(), create(), remove(), 和clear(), set()都会马上更新数据库. 换句话说在关联的任何一端,都不需要在调用save()方法.

聚合查询和分组

聚合

aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。 

键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。

　  用到的内置函数  >> from django.db.models import Avg, Sum, Max,Min, Count

　　例子:　　

>>> from django.db.models import Avg, Sum, Max, Min, Count
>>> models.Book.objects.all().aggregate(Avg("price"))
{'price__avg': 13.233333}

如果你想要为聚合值指定一个名称，可以向聚合子句提供它。

>>> models.Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 13.233333}

如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数。所以，如果你也想知道所有图书价格的最大值和最小值，可以这样查询：

>>> models.Book.objects.all().aggregate(Avg("price"), Max("price"), Min("price"))
{'price__avg': 13.233333, 'price__max': Decimal('19.90'), 'price__min': Decimal('9.90')}

分组

　　假设有一张公司职员表:

按照分组求平均工资(原生sql语句)

select dept,AVG(salary) from employee group by dept;

 ORM查询

from django.db.models import Avg
Employee.objects.values("dept").annotate(avg=Avg("salary").values("dept", "avg")

 连表查询的分组:

 

SQL查询:

select dept.name,AVG(salary)
from employee inner join dept on (employee.dept_id=dept.id) group by dept_id;

 ORM查询:

from django.db.models import Avg
models.Dept.objects.annotate(avg=Avg("employee__salary")).values("name", "avg")
# 以部门为分组条件,查询工人姓名和平均工资

 示例1:　　统计每一本书的作者个数

>>> book_list = models.Book.objects.all().annotate(author_num=Count("author"))
　　# annotate查询 会把查询结果放到对象之中,作为对象属性存放.
>>> for obj in book_list:
...     print(obj.author_num)
...
1

 示例2:  统计出每个出版社买的最便宜的书价格

>>> publisher_list = models.Publisher.objects.annotate(min_price=Min("book__price"))
>>> for obj in publisher_list:
...     print(obj.min_price)
...     
9.90
19.90

 方法二:

>>> models.Book.objects.values("publisher__name").annotate(min_price=Min("price"))

<QuerySet [{'publisher__name': '沙河出版社', 'min_price': Decimal('9.90')},
{'publisher__name': '人民出版社', 'min_price': Decimal('19.90')}]>

 示例3: 统计不止一个作者的图书

>>> models.Book.objects.annotate(author_num=Count("author")).filter(author_num__gt=1)
<QuerySet [<Book: 番茄物语>]>  # 拿到的是一个对象,想要拿到整本书(对象)的信息,就要 .values()

 示例4: 根据一本图书作者数量的多少对查询集QuerySet进行排序

>>> models.Book.objects.annotate(author_num=Count("author")).order_by("author_num")
<QuerySet [<Book: 香蕉物语>, <Book: 橘子物语>, <Book: 番茄物语>]> 

 示例5: 查询各个作者出的书的总价格

>>> models.Author.objects.annotate(sum_price=Sum("book__price")).values("name", "sum_price")
<QuerySet [{'name': '小精灵', 'sum_price': Decimal('9.90')},
{'name': '小仙女', 'sum_price': Decimal('29.80')}, {'name': '小魔女', 'sum_price': Decimal('9.90')}]>

F查询

Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。

示例1:

查询评论数大于收藏数的书籍

from django.db.models import F
models.Book.objects.filter(commnet_num__gt=F('keep_num'))
# 查询出的是对象,若要对象的信息需要 .values()

 Django支持F()对象之间以及F()对象和常数之间的加减乘除和取模的操作.

models.Book.objects.filter(commnet_num__lt=F('keep_num')*2)

 修改操作也可以使用F函数,比如将每一本书的价格提高30元

models.Book.objects.all().update(price=F("price")+30)
# update 表示更新指定字段　　如果要用set,则会把所有字段都会更新一遍,效率低.

引申:　　如果要修改char字段呢?

　　例 把所有书名后面加上(郭jj)

>>> from django.db.models.functions import Concat
>>> from django.db.models import Value
>>> models.Book.objects.all().update(title=Concat(F("title"), Value("("), Value("郭jj"), Value(")")))

Q查询

filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR语句），你可以使用Q对象。

　示例1:  查询作者名是皮皮虾或大志

models.Book.objects.filter(Q(authors__name="皮皮虾")|Q(authors__name="大志"))

你可以组合&(and) 和|(或)  操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可以使用~(非)操作符取反，这允许组合正常的查询和取反(NOT) 查询。

　　示例: 查询作者名字是皮皮虾并且不是2018年出版的书的书名.

>>> models.Book.objects.filter(Q(author__name="皮皮虾")
& ~Q(publish_date__year=2018)).values_list("title")
<QuerySet [('番茄物语',)]>

查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。

　　

　　例如: 查询出版社年份是 2017或2018,书名带物语的所有书.

>>> models.Book.objects.filter(Q(publish_date__year=2018) | 
Q(publish_date__year=2017), title__icontains="物语")
<QuerySet [<Book: 番茄物语>, <Book: 香蕉物语>, <Book: 橘子物语>]>

事物

整个操作过程,一处失败都失败,之前的操作都是无效的,所有操作都回退.全部成功才能成功.

比如:银行转账,一步操作失误,转账过程失败,钱也会回退.

示例:

import os

if __name__ == '__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
    import django
    django.setup()

    import datetime
    from app01 import models

    try:
        from django.db import transaction # 导入事物
        with transaction.atomic(): # 其中的操作要么都成功,要么都失败
            new_publisher = models.Publisher.objects.create(name="火星出版社")
            models.Book.objects.create(title="橘子物语", publish_date=datetime.date.today(), publisher_id=10)  # 指定一个不存在的出版社id
    except Exception as e:
        print(str(e))