Django之ORM

 

orm概念

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

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

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

 

orm由来

让我们从o/r开始。字母o起源于"对象"(object)，而r则来自于"关系"(relational)。

几乎所有的软件开发过程中都会涉及到对象和关系数据库。在用户层面和业务逻辑层面，我们是面向对象的。当对象的信息发生变化的时候，我们就需要把对象的信息保存在关系数据库中。

按照之前的方式来进行开发就会出现程序员会在自己的业务逻辑代码中夹杂很多sql语句用来增加、读取、修改、删除相关数据，而这些代码通常都是极其相似或者重复的。

 

orm的优势

orm解决的主要问题是对象和关系的映射。它通常将一个类和一张表一一对应，类的每个实例对应表中的一条记录，类的每个属性对应表中的每个字段。 

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

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

 

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_112233\d+', 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"))
>>> 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: 番茄物语>]>

 

　　示例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'))

 

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)

 

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

　　例 把所有书名后面加上(老潘)

>>> from django.db.models.functions import concat
>>> from django.db.models import value
>>> models.book.objects.all().update(title=concat(f("title"), value("("), value("老潘"), value(")")))

 

　　q查询

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

 

 

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

models.book.objects.filter(q(authors__name="皮皮虾")|q(authors__name="大志"))

你可以组合& 和|  操作符以及使用括号进行分组来编写任意复杂的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))

 

cookie

　cookie的由来　　

大家都知道http协议是无状态的。

无状态的意思是每次请求都是独立的，它的执行情况和结果与前面的请求和之后的请求都无直接关系，它不会受前面的请求响应情况直接影响，也不会直接影响后面的请求响应情况。

一句有意思的话来描述就是人生只如初见，对服务器来说，每次的请求都是全新的。

状态可以理解为客户端和服务器在某次会话中产生的数据，那无状态的就以为这些数据不会被保留。会话中产生的数据又是我们需要保存的，也就是说要“保持状态”。因此cookie就是在这样一个场景下诞生。

　　

　什么是cookie

　　cookie具体指的是一段小信息，它是服务器发送出来存储在浏览器上的一组组键值对，下次访问服务器时浏览器会自动携带这些键值对，以便服务器提取有用信息。

 

　cookie的原理

cookie的工作原理是：由服务器产生内容，浏览器收到请求后保存在本地；当浏览器再次访问时，浏览器会自动带上cookie，这样服务器就能通过cookie的内容来判断这个是“谁”了。

 

　查看cookie

　　我们使用chrome浏览器,打开开发者工具.

 

 

 django中操作cookie

　　获取cookie

request.cookies['key']
request.get_signed_cookie('key', default=raise_error, salt='', max_age=none)

 

get_signed_cookie方法的参数：

• default: 默认值
• salt: 加密盐
• max_age: 后台控制过期时间

 

 　　设置cookie

rep = httpresponse(...)
rep ＝ render(request, ...)

rep.set_cookie(key,value,...)
rep.set_signed_cookie(key,value,salt='加密盐',...)

 

参数：

• key, 键
• value='', 值
• max_age=none, 超时时间
• expires=none, 超时时间(ie requires expires, so set it if hasn't been already.)
• path='/', cookie生效的路径，/ 表示根路径，特殊的：根路径的cookie可以被任何url的页面访问
• domain=none, cookie生效的域名
• secure=false, https传输
• httponly=false 只能http协议传输，无法被javascript获取（不是绝对，底层抓包可以获取到也可以被覆盖）

 

 　删除cookie

def logout(request):
    rep = redirect("/login/")
    rep.delete_cookie("user")  # 删除用户浏览器上之前设置的user的cookie值
    return rep

 

 　　cookie版登录校验

def check_login(func):
    @wraps(func)
    def inner(request, *args, **kwargs):
        next_url = request.get_full_path()
        if request.get_signed_cookie("login", salt="sss", default=none) == "yes":
            # 已经登录的用户...
            return func(request, *args, **kwargs)
        else:
            # 没有登录的用户，跳转刚到登录页面
            return redirect("/login/?next={}".format(next_url))
    return inner


def login(request):
    if request.method == "post":
        username = request.post.get("username")
        passwd = request.post.get("password")
        if username == "xxx" and passwd == "dashabi":
            next_url = request.get.get("next")
            if next_url and next_url != "/logout/":
                response = redirect(next_url)
            else:
                response = redirect("/class_list/")
            response.set_signed_cookie("login", "yes", salt="sss")
            return response
    return render(request, "login.html")

cookie版登录

 

 session

　session

cookie虽然在一定程度上解决了“保持状态”的需求，但是由于cookie本身最大支持4096字节，以及cookie本身保存在客户端，可能被拦截或窃取，因此就需要有一种新的东西，它能支持更多的字节，并且他保存在服务器，有较高的安全性。这就是session。

问题来了，基于http协议的无状态特征，服务器根本就不知道访问者是“谁”。那么上述的cookie就起到桥接的作用。

我们可以给每个客户端的cookie分配一个唯一的id，这样用户在访问时，通过cookie，服务器就知道来的人是“谁”。然后我们再根据不同的cookie的id，在服务器上保存一段时间的私密资料，如“账号密码”等等。

总结而言：cookie弥补了http无状态的不足，让服务器知道来的人是“谁”；但是cookie以文本的形式保存在本地，自身安全性较差；所以我们就通过cookie识别不同的用户，对应的在session里保存私密的信息以及超过4096字节的文本。

另外，上述所说的cookie和session其实是共通性的东西，不限于语言和框架。

 

 django中session相关方法

# 设置、获取、删除session中数据
request.session['k1']
request.session.get('k1',none)
request.session['k1'] = 123
request.session.setdefault('k1',123) # 存在则不设置
del request.session['k1']


# 所有 键、值、键值对
request.session.keys()
request.session.values()
request.session.items()
request.session.iterkeys()
request.session.itervalues()
request.session.iteritems()

# 会话session的key
request.session.session_key

# 将所有session失效日期小于当前日期的数据删除
request.session.clear_expired()

# 检查会话session的key在数据库中是否存在
request.session.exists("session_key")

# 删除当前会话的所有session数据
request.session.delete()
　　
# 删除当前的会话数据并删除会话的cookie。
request.session.flush() 
    这用于确保前面的会话数据不可以再次被用户的浏览器访问
    例如，django.contrib.auth.logout() 函数中就会调用它。

# 设置会话session和cookie的超时时间
request.session.set_expiry(value)
    * 如果value是个整数，session会在些秒数后失效。
    * 如果value是个datatime或timedelta，session就会在这个时间后失效。
    * 如果value是0,用户关闭浏览器session就会失效。
    * 如果value是none,session会依赖全局session失效策略。

 

 session流程解析

 

 

 

session版本登录验证

from functools import wraps


def check_login(func):
    @wraps(func)
    def inner(request, *args, **kwargs):
        next_url = request.get_full_path()
        if request.session.get("user"):
            return func(request, *args, **kwargs)
        else:
            return redirect("/login/?next={}".format(next_url))
    return inner


def login(request):
    if request.method == "post":
        user = request.post.get("user")
        pwd = request.post.get("pwd")

        if user == "alex" and pwd == "alex1234":
            # 设置session
            request.session["user"] = user
            # 获取跳到登陆页面之前的url
            next_url = request.get.get("next")
            # 如果有，就跳转回登陆之前的url
            if next_url:
                return redirect(next_url)
            # 否则默认跳转到index页面
            else:
                return redirect("/index/")
    return render(request, "login.html")


@check_login
def logout(request):
    # 删除所有当前请求相关的session
    request.session.delete()
    return redirect("/login/")


@check_login
def index(request):
    current_user = request.session.get("user", none)
    return render(request, "index.html", {"user": current_user})

session版登录验证

 

　django中的session配置

　　django中默认支持session,其内部提供了5中类型的session供开发者使用.

1. 数据库session
session_engine = 'django.contrib.sessions.backends.db'   # 引擎（默认）

2. 缓存session
session_engine = 'django.contrib.sessions.backends.cache'  # 引擎
session_cache_alias = 'default'                            # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置

3. 文件session
session_engine = 'django.contrib.sessions.backends.file'    # 引擎
session_file_path = none                                    # 缓存文件路径，如果为none，则使用tempfile模块获取一个临时地址tempfile.gettempdir() 

4. 缓存+数据库
session_engine = 'django.contrib.sessions.backends.cached_db'        # 引擎

5. 加密cookie session
session_engine = 'django.contrib.sessions.backends.signed_cookies'   # 引擎

其他公用设置项：
session_cookie_name ＝ "sessionid"                       # session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
session_cookie_path ＝ "/"                               # session的cookie保存的路径（默认）
session_cookie_domain = none                             # session的cookie保存的域名（默认）
session_cookie_secure = false                            # 是否https传输cookie（默认）
session_cookie_httponly = true                           # 是否session的cookie只支持http传输（默认）
session_cookie_age = 1209600                             # session的cookie失效日期（2周）（默认）
session_expire_at_browser_close = false                  # 是否关闭浏览器使得session过期（默认）
session_save_every_request = false                       # 是否每次请求都保存session，默认修改之后才保存（默认）