Django-07-Models

First, the configuration database

1. Database Support

django default support sqlite, mysql, oracle, postgresql database

     <1> sqlite

            django sqlite default database, default comes sqlite database-driven, engine name: django.db.backends.sqlite3

     <2> mysql

            Engine Name: django.db.backends.mysql

2. mysql driver

•    MySQLdb(mysql python)
•    mysqlclient
•    MySQL
•    PyMySQL (pure mysql driver's python)

3. setting Configuration

In django project will use the default sqlite database has the following settings in settings where:

If we want to change the database, you need to be modified as follows:   

= {DATABASES 
    'default': { 
        'ENGINE': 'django.db.backends.mysql', 
        'NAME': 'Books', # your database name 
        ' USER ':' root ', # your database username 
        ' pASSWORD ':' ', # your database password 
        ' hOST ':' ', # your database host, blank defaults to localhost 
        ' pORT ':' 3306 ', # your database port 
    } 
}

NAME that is the name of the database, the database must have been created before mysql connection, and db.sqlite3 under the above project sqlite database is created automatically 

USER and PASSWORD are the user name and password for the database. 

After setting, before restarting our Django project, we need to activate our mysql. 

Then, start the project, will complain: no module named MySQLdb 

This is because the default django import your drive is MySQLdb, but MySQLdb for py3 a big problem, so we need to drive is PyMySQL 

So, we just need to find the next item name file the __init__, which is written in: 
Import pymysql 
pymysql.install_as_MySQLdb ()

4. pycharm database connection mysql

<1> to open mysql Services

<2> Download Driver

<3> and the test connection

Common mistakes:

08001 wrong time zone

Solution: Modify zone is "+8: 00"

It can connect again

Two, Django's ORM (object-relational mapping)

For conversion between the object-oriented programming language systems different types of data, in other words, is an object-oriented manner operating to create the table in the database and the like CRUD operations .

Advantages: 1 ORM make our common database interaction becomes easy, and no need to consider damn SQL statements. Rapid development, resulting.

          2 avoid some of the novice program ape write performance problems sql statement brings.

Disadvantages: 1 sacrifice some performance, but now various ORM frameworks are trying a variety of methods, such as caching, lazy loading Gordon to alleviate this problem. The effect is very significant.

         2 For individual complex queries, ORM still powerless, in order to solve this problem, ORM generally supports write raw sql.

Create a table model

Example: Let's assume the following concepts, fields and relationships

作者模型：一个作者有姓名。

作者详细模型：把作者的详情放到详情表，包含性别，email地址和出生日期，作者详情模型和作者模型之间是一对一的关系（one－to－one）（类似于每个人和他的身份证之间的关系），在大多数情况下我们没有必要将他们拆分成两张表，这里只是引出一对一的概念。

出版商模型：出版商有名称，地址，所在城市，省，国家和网站。

书籍模型：书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系（many－to－many），一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系（one－to－many），也被称作外键。

from django.db import models
class Publish(models.Model):
    name = models.CharField(max_length=30, verbose_name="名称")
    address = models.CharField("地址", max_length=50)
    city = models.CharField('城市',max_length=60)
    state_province = models.CharField(max_length=30)
    country = models.CharField(max_length=50)
    website = models.URLField()
 
    class Meta:
        verbose_name = '出版商'
        verbose_name_plural = verbose_name
 
    def __str__(self):
        return self.name
 
class Author(models.Model):
    name = models.CharField(max_length=30)
    def __str__(self):
        return self.name
 
class AuthorDetail(models.Model):
    sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),))
    email = models.EmailField()
    address = models.CharField(max_length=50)
    birthday = models.DateField()
    author = models.OneToOneField(Author)
 
class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    publish = models.ForeignKey(Publish)
    publication_date = models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2,default=10)
    def __str__(self):
        return self.title

注意1：记得在settings里的INSTALLED_APPS中加入'app01',然后再同步数据库。

注意2: models.ForeignKey("Publish") & models.ForeignKey(Publish)

分析代码：

       <1>  每个数据模型都是django.db.models.Model的子类，它的父类Model包含了所有必要的和数据库交互的方法。并提供了一个简介漂亮的定义数据库字段的语法。

       <2>  每个模型相当于单个数据库表（多对多关系例外，会多生成一张关系表），每个属性也是这个表中的字段。属性名就是字段名，它的类型（例如CharField）相当于数据库的字段类型（例如varchar）。大家可以留意下其它的类型都和数据库里的什么字段对应。

       <3>  模型之间的三种关系：一对一，一对多，多对多。

             一对一：实质就是在主外键（author_id就是foreign key）的关系基础上，给外键加了一个UNIQUE＝True的属性；

             一对多：就是主外键关系；（foreign key）

             多对多：(ManyToManyField) 自动创建第三张表(当然我们也可以自己创建第三张表：两个foreign key)

模型常用的字段类型参数

<1> CharField
        #字符串字段, 用于较短的字符串.
        #CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所允许的最大字符数.

<2> IntegerField
       #用于保存一个整数.

<3> FloatField
        # 一个浮点数. 必须 提供两个参数:
        #
        # 参数    描述
        # max_digits    总位数(不包括小数点和符号)
        # decimal_places    小数位数
                # 举例来说, 要保存最大值为 999 (小数点后保存2位),你要这样定义字段:
                #
                # models.FloatField(..., max_digits=5, decimal_places=2)
                # 要保存最大值一百万(小数点后保存10位)的话,你要这样定义:
                #
                # models.FloatField(..., max_digits=19, decimal_places=10)
                # admin 用一个文本框(<input type="text">)表示该字段保存的数据.

<4> AutoField
        # 一个 IntegerField, 添加记录时它会自动增长. 你通常不需要直接使用这个字段; 
        # 自定义一个主键：my_id=models.AutoField(primary_key=True)
        # 如果你不指定主键的话,系统会自动添加一个主键字段到你的 model.

<5> BooleanField
        # A true/false field. admin 用 checkbox 来表示此类字段.

<6> TextField
        # 一个容量很大的文本字段.
        # admin 用一个 <textarea> (文本区域)表示该字段数据.(一个多行编辑框).

<7> EmailField
        # 一个带有检查Email合法性的 CharField,不接受 maxlength 参数.

<8> DateField
        # 一个日期字段. 共有下列额外的可选参数:
        # Argument    描述
        # auto_now    当对象被保存时,自动将该字段的值设置为当前时间.通常用于表示 "last-modified" 时间戳.
        # auto_now_add    当对象首次被创建时,自动将该字段的值设置为当前时间.通常用于表示对象创建时间.
        #（仅仅在admin中有意义...)

<9> DateTimeField
        #  一个日期时间字段. 类似 DateField 支持同样的附加选项.

<10> ImageField
        # 类似 FileField, 不过要校验上传对象是否是一个合法图片.#它有两个可选参数:height_field和width_field,
        # 如果提供这两个参数,则图片将按提供的高度和宽度规格保存.     
<11> FileField
     # 一个文件上传字段.
     #要求一个必须有的参数: upload_to, 一个用于保存上载文件的本地文件系统路径. 这个路径必须包含 strftime #formatting, 
     #该格式将被上载文件的 date/time 
     #替换(so that uploaded files don't fill up the given directory).
     # admin 用一个<input type="file">部件表示该字段保存的数据(一个文件上传部件) .

     #注意：在一个 model 中使用 FileField 或 ImageField 需要以下步骤:
            #（1）在你的 settings 文件中, 定义一个完整路径给 MEDIA_ROOT 以便让 Django在此处保存上传文件. 
            # (出于性能考虑,这些文件并不保存到数据库.) 定义MEDIA_URL 作为该目录的公共 URL. 要确保该目录对 
            #  WEB服务器用户帐号是可写的.
            #（2） 在你的 model 中添加 FileField 或 ImageField, 并确保定义了 upload_to 选项,以告诉 Django
            # 使用 MEDIA_ROOT 的哪个子目录保存上传文件.你的数据库中要保存的只是文件的路径(相对于 MEDIA_ROOT). 
            # 出于习惯你一定很想使用 Django 提供的 get_<#fieldname>_url 函数.举例来说,如果你的 ImageField 
            # 叫作 mug_shot, 你就可以在模板中以 {{ object.#get_mug_shot_url }} 这样的方式得到图像的绝对路径.

<12> URLField
      # 用于保存 URL. 若 verify_exists 参数为 True (默认), 给定的 URL 会预先检查是否存在( 即URL是否被有效装入且
      # 没有返回404响应).
      # admin 用一个 <input type="text"> 文本框表示该字段保存的数据(一个单行编辑框)

<13> NullBooleanField
       # 类似 BooleanField, 不过允许 NULL 作为其中一个选项. 推荐使用这个字段而不要用 BooleanField 加 null=True 选项
       # admin 用一个选择框 <select> (三个可选择的值: "Unknown", "Yes" 和 "No" ) 来表示这种字段数据.

<14> SlugField
       # "Slug" 是一个报纸术语. slug 是某个东西的小小标记(短签), 只包含字母,数字,下划线和连字符.#它们通常用于URLs
       # 若你使用 Django 开发版本,你可以指定 maxlength. 若 maxlength 未指定, Django 会使用默认长度: 50.  #在
       # 以前的 Django 版本,没有任何办法改变50 这个长度.
       # 这暗示了 db_index=True.
       # 它接受一个额外的参数: prepopulate_from, which is a list of fields from which to auto-#populate 
       # the slug, via JavaScript,in the object's admin form: models.SlugField
       # (prepopulate_from=("pre_name", "name"))prepopulate_from 不接受 DateTimeFields.

<13> XMLField
        #一个校验值是否为合法XML的 TextField,必须提供参数: schema_path, 它是一个用来校验文本的 RelaxNG schema #的文件系统路径.

<14> FilePathField
        # 可选项目为某个特定目录下的文件名. 支持三个特殊的参数, 其中第一个是必须提供的.
        # 参数    描述
        # path    必需参数. 一个目录的绝对文件系统路径. FilePathField 据此得到可选项目. 
        # Example: "/home/images".
        # match    可选参数. 一个正则表达式, 作为一个字符串, FilePathField 将使用它过滤文件名.  
        # 注意这个正则表达式只会应用到 base filename 而不是
        # 路径全名. Example: "foo.*\.txt^", 将匹配文件 foo23.txt 却不匹配 bar.txt 或 foo23.gif.
        # recursive可选参数.要么 True 要么 False. 默认值是 False. 是否包括 path 下面的全部子目录.
        # 这三个参数可以同时使用.
        # match 仅应用于 base filename, 而不是路径全名. 那么,这个例子:
        # FilePathField(path="/home/images", match="foo.*", recursive=True)
        # ...会匹配 /home/images/foo.gif 而不匹配 /home/images/foo/bar.gif

<15> IPAddressField
        # 一个字符串形式的 IP 地址, (i.e. "24.124.1.30").
<16># CommaSeparatedIntegerField
        # 用于存放逗号分隔的整数值. 类似 CharField, 必须要有maxlength参数.

Field重要参数

    <1> null ： 数据库中字段是否可以为空

    <2> blank： django的 Admin 中添加数据时是否可允许空值

    <3> default：设定缺省值

    <4> editable：如果为假，admin模式下将不能改写。缺省为真

    <5> primary_key：设置主键，如果没有设置django创建表时会自动加上：
        id = meta.AutoField('ID', primary_key=True)
        primary_key=True implies blank=False, null=False and unique=True. Only one
        primary key is allowed on an object.

    <6> unique：数据唯一

    <7> verbose_name　　Admin中字段的显示名称

    <8> validator_list：有效性检查。非有效产生 django.core.validators.ValidationError 错误


    <9> db_column，db_index 如果为真将为此字段创建索引

    <10>choices：一个用来选择值的2维元组。第一个值是实际存储的值，第二个用来方便进行选择。
                如SEX_CHOICES= (( ‘F’,'Female’),(‘M’,'Male’),)
                gender = models.CharField(max_length=2,choices = SEX_CHOICES)

三、ORM对单表的操作

在setting文件里加入以下代码可以实时显示操作对应的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',
        },
    }
}

1. 增

from app01.models import *

    #create方式一:   Author.objects.create(name='Alvin')

    #create方式二:   Author.objects.create(**{"name":"alex"})

    #save方式一:     author=Author(name="alvin")
                    author.save()

    #save方式二:     author=Author()
                    author.name="alvin"
                    author.save()

    # 方式一
    b = Book(name='python基础', price=99, author='alex', pub_date='2017-12-12')
    b.save()
    # 方式二
    Book.objects.create(name='Linux基础', price=49, author='lsf', pub_date='2015-03-12')

2. 改

    # 方式一
    Book.objects.filter(author='alex').update(price='999')  # 不能用get(author='alex')

    # 方式二
    b = Book.objects.get(author='lsf')
    b.price = 120
    b.save()

注意：

<1>第一种方式修改不能用get的原因是：update是QuerySet对象的方法，get返回的是一个model对象，它没有update方法，而filter返回的是一个QuerySet对象(filter里面的条件可能有多个条件符合，比如name＝'alvin',可能有两个name＝'alvin'的行数据)。

<2>save方法会将所有属性重新设定一遍，效率低，推荐使用第一种方式

3. 删

Book.objects.filter(author='lsf').delete()

4. 查

# 查询相关API：

#  <1>filter(**kwargs):      它包含了与所给筛选条件相匹配的对象

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

#  <3>get(**kwargs):         返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。

#-----------下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------

#  <4>values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列 model的实例化对象，而是一个可迭代的字典序列
                                     
#  <5>exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象

#  <6>order_by(*field):      对查询结果排序

#  <7>reverse():             对查询结果反向排序

#  <8>distinct():            从返回结果中剔除重复纪录

#  <9>values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列

#  <10>count():              返回数据库中匹配查询(QuerySet)的对象数量。

# <11>first():               返回第一条记录

# <12>last():                返回最后一条记录

#  <13>exists():             如果QuerySet包含数据，就返回True，否则返回False。

    booklist = Book.objects.filter(author='alex')  # 得到一个集合
    booklist = Book.objects.all()
    booklist = Book.objects.all()[::2]
    booklist = Book.objects.all()[::2]
    booklist = Book.objects.get(name='Go')  # 只能取出一条结果时才不报错
    booklist = Book.objects.first()
    booklist = Book.objects.last()

    booklist = Book.objects.exclude(author='alex')
    print(booklist)  # <QuerySet [<Book: Book object (Linux基础)>, <Book: Book object (PHP)>]>

    booklist = Book.objects.filter(author='alex').reverse()  # 倒叙
    booklist = Book.objects.exclude(author='alex').order_by('price')  # 排序
    print(booklist)  # <QuerySet [<Book: Book object (PHP)>, <Book: Book object (Linux基础)>]>

    ret1 = Book.objects.filter(author='alex').values('name', 'price')
    print(ret1)  # <QuerySet [{'name': 'GO', 'price': 55}, {'name': 'python基础', 'price': 99}]>
    ret2 = Book.objects.filter(author='alex').values_list('name', 'price')
    print(ret2)  # <QuerySet [('GO', 55), ('python基础', 99)]>
    booklist = Book.objects.all().values('name').distinct()  # 去重
    book_count = Book.objects.exclude(author='alex').count()  # 返回查询结果的数量

模糊查询（双下划线）

#    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
#
#    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")
#    models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
#
#    models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and
#
#    startswith，istartswith, endswith, iendswith,

四、多表操作

如何处理外键关系的字段如一对多的publish和多对多的authors

1. 一对多

增

    # 方式一：由于绑定一对多的字段,比如publish,存到数据库中的字段名叫publish_id,所以我们可以直接给这个字段设定对应值:
    # Book.objects.create(name='Linux', price=80, pubdate='2017-12-12', publish_id=1) # 相当于绑定了Publish表中id为1的对象
    # 方式二：先获取要绑定的Publish对象，再绑定给publish
    publish_obj = Publish.objects.filter(name='人民出版社')[0]
    Book.objects.create(name='Linux', price=80, pubdate='2017-12-12', publish=publish_obj)

查（通过对象）

    book_obj = Book.objects.get(name='python')
    print(book_obj.price)  # 99
    # 一对多：book_obj.publish一定是一个对象
    print(book_obj.publish)  # Publish object (3)
    print(book_obj.publish.name)  # 南方出版社

    # 查询人民出版社的所有书籍
    # 方法一（正向查找）
    pub_obj = Publish.objects.get(name='人民出版社')
    ret = Book.objects.filter(publish=pub_obj).values('name', 'price')
    print(ret)  # <QuerySet [{'name': 'Linux', 'price': 80}, {'name': 'Java', 'price': 150}]>
    # 方法二（反向查找）
    pub_obj = Publish.objects.get(name='人民出版社')
    print(pub_obj.book_set.all().values('name', 'price'))  # <QuerySet [{'name': 'Linux', 'price': 80}, {'name': 'Java', 'price': 150}]>
    # print(type(pub_obj.book_set.all()))  # <class 'django.db.models.query.QuerySet'>

查（通过双下划线）

    book_dic = Book.objects.filter(publish__name='人民出版社').values('name', 'price')
    print(book_dic)
    # 查找python的出版社名字
    ret1 = Publish.objects.get(book__name='python').name
    ret2 = Publish.objects.filter(book__name='python').values('name')
    ret3 = Book.objects.get(name='python').publish.name
    ret4 = Book.objects.filter(name='python').values('publish__name')
    print(ret1, ret2, ret3, ret4)
    # 查找出版社在北京的书籍
    ret5 = Publish.objects.filter(addr='北京').values('book__name')
    ret6 = Book.objects.filter(publish__addr='北京').values('name')
    print(ret5, ret6)

2. 多对多

增

    book_obj = Book.objects.get(id=10)
    authors_objs = Author.objects.filter(age__lt=40)
    book_obj.authors.add(*authors_objs)
    
    author1=Author.objects.get(id=1)
    author2=Author.objects.filter(name='alvin')[0]
    book=Book.objects.get(id=1)
    book.authors.add(author1,author2)
    #等同于:
    book.authors.add(*[author1,author2])
    book.authors.remove(*[author1,author2])
    #-------------------
    book=Book.objects.filter(id__gt=1)
    authors=Author.objects.filter(id=1)[0]
    authors.book_set.add(*book)
    authors.book_set.remove(*book)
    #-------------------
    book.authors.add(1)
    book.authors.remove(1)
    authors.book_set.add(1)
    authors.book_set.remove(1)

#注意: 如果第三张表是通过models.ManyToManyField()自动创建的,那么绑定关系只有上面一种方式
#     如果第三张表是自己创建的:
     class Book2Author(models.Model):
            author=models.ForeignKey("Author")
            Book=  models.ForeignKey("Book")
#     那么就还有一种方式:
            author_obj=models.Author.objects.filter(id=2)[0]
            book_obj  =models.Book.objects.filter(id=3)[0]

            s=models.Book2Author.objects.create(author_id=1,Book_id=2)
            s.save()
            s=models.Book2Author(author=author_obj,Book_id=1)
            s.save()

删

#正向
book = Book.objects.filter(id=1)

book.author.clear()        #清空与book中id=1 关联的所有数据
book.author.remove(2)  #可以为id
book.author.remove(*[1,2,3,4])  #可以为列表,前面加*

#反向
author = Author.objects.filter(id=1)
author.book_set.clear() #清空与boy中id=1 关联的所有数据

改

    obj=Book.objects.filter(id=1)[0]
    author=Author.objects.filter(id__gt=2)

    obj.author.clear()
    obj.author.add(*author)

查

# 多对多
    # 查找python的作者
    Book.objects.filter(name='python').values('authors__name')
    Author.objects.filter(book__name='python').values('name')
    # 查找出版社在北京的书籍的名字和作者
    Book.objects.filter(publish__addr='北京').values('name', 'authors__name')
    Author.objects.filter(book__publish__addr='北京').values('book__name', 'name')
    Publish.objects.filter(addr='北京').values('book__name', 'book__authors__name')
    # 查找作者为alex的书的出版社名字
    Author.objects.filter(name='alex').values('book__publish__name')
    Book.objects.filter(authors__name='alex').values('publish__name')
    Publish.objects.filter(book__authors__name='alex').values('name')

3. 聚合查询和分组查询

 <1>aggregate(*args, **kwargs)

通过对QuerySet进行计算，返回一个聚合值的字典。aggregate()中每一个参数都指定一个包含在字典中的返回值。即在查询集上生成聚合。

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

从整个查询集生成统计值。比如，你想要计算所有在售书的平均价钱。Django的查询语法提供了一种方式描述所有
图书的集合。

>>> Book.objects.all().aggregate(Avg('price'))
{'price__avg': 34.35}

aggregate()子句的参数描述了我们想要计算的聚合值，在这个例子中，是Book模型中price字段的平均值

aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的
标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定
一个名称，可以向聚合子句提供它:
>>> Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 34.35}

如果你也想知道所有图书价格的最大值和最小值，可以这样查询：
>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

<2>annotate(*args, **kwargs)

可以通过计算查询结果中每一个对象所关联的对象集合，从而得出总计值(也可以是平均值或总和)，即为查询集的每一项生成聚合。

查询alex出的书总价格

       

        查询各个作者出的书的总价格,这里就涉及到分组了，分组条件是authors__name

           

         查询各个出版社最便宜的书价是多少

       

4. F查询和Q查询

仅仅靠单一的关键字参数查询已经很难满足查询要求。此时Django为我们提供了F和Q查询：

# F 使用查询条件的值,专门取对象中某列值的操作
    # from django.db.models import F
    # models.Tb1.objects.update(num=F('num')+1)


# Q 构建搜索条件
    from django.db.models import Q
    #1 Q对象(django.db.models.Q)可以对关键字参数进行封装，从而更好地应用多个查询
    q1=models.Book.objects.filter(Q(title__startswith='P')).all()
    print(q1)#[<Book: Python>, <Book: Perl>]

    # 2、可以组合使用&,|操作符，当一个操作符是用于两个Q的对象,它产生一个新的Q对象。
    Q(title__startswith='P') | Q(title__startswith='J')

    # 3、Q对象可以用~操作符放在前面表示否定，也可允许否定与不否定形式的组合
    Q(title__startswith='P') | ~Q(pub_date__year=2005)

    # 4、应用范围：
    # Each lookup function that takes keyword-arguments (e.g. filter(),
    #  exclude(), get()) can also be passed one or more Q objects as
    # positional (not-named) arguments. If you provide multiple Q object
    # arguments to a lookup function, the arguments will be “AND”ed
    # together. For example:

    Book.objects.get(
        Q(title__startswith='P'),
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
    )

    #sql:
    # SELECT * from polls WHERE question LIKE 'P%'
    #     AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')

    # import datetime
    # e=datetime.date(2005,5,6)  #2005-05-06

    # 5、Q对象可以与关键字参数查询一起使用，不过一定要把Q对象放在关键字参数查询的前面。
    # 正确：
    Book.objects.get(
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
        title__startswith='P')
    # 错误：
    Book.objects.get(
        question__startswith='P',
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))