Django（七）缓存、信号、Form

时间 2019-11-12

标签 django 缓存信号 form 栏目 Python 繁體版

原文原文链接

大纲

1、缓存
1.一、五种缓存配置
1.2配置
2.一、三种应用（全局、视图函数、模板）
2.2 应用多个缓存时生效的优先级
2、信号
一、Django内置信号
二、自定义信号
3、Form
一、初始form，建立form
二、自定制form错误信息，前端显示
三、保留上一次提交的数据，自动生成html标签
四、更简洁的html标签生成方法
五、自定义样式
六、form 内置字段
经常使用选择插件
七、初始化操做html

1、缓存

除了Django这个web框架以外、其余框架都没有缓存。Django的配置一下就可使用。前端

1.一、五种缓存配置

Django中提供了5种缓存方式：python

开发调试（缓存哪里都不放，只都配置好，测试用）
内存
文件
数据库
Memcache缓存
- （使用 python-memcached模块链接memcache）
- （使用 pylibmc模块链接memcache）

1.2配置

开发调试

# 此为开始调试用，实际内部不作任何操做
    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.dummy.DummyCache',     # 引擎
                'TIMEOUT': 300,           # 缓存超时时间（默认300，None表示永不过时，0表示当即过时）
                'OPTIONS':{
                    'MAX_ENTRIES': 300,   # 最大缓存个数（默认300）
                    'CULL_FREQUENCY': 3,  # 缓存到达最大个数以后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认剔除1/3）
                },
                'KEY_PREFIX': '',         # 缓存key的前缀（默认空）
                'VERSION': 1,             # 缓存key的版本（默认1）
                'KEY_FUNCTION' 函数名     # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
            }
        }

    # 自定义key 名
    def default_key_func(key, key_prefix, version):
        """
        Default function to generate keys.

        Constructs the key used by all other methods. By default it prepends
        the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
        function with custom key making behavior.
        """
        return '%s:%s:%s' % (key_prefix, version, key)

    def get_key_func(key_func):
        """
        Function to decide which key function to use.

        Defaults to ``default_key_func``.
        """
        if key_func is not None:
            if callable(key_func):
                return key_func
            else:
                return import_string(key_func)
        return default_key_func

内存

# 此缓存将内容保存至内存的变量中
      # 配置：
          CACHES = {
              'default': {
                  'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
                  'LOCATION': 'unique-snowflake',
              }
          }

      # 注：其余配置同开发调试版本

文件

# 此缓存将内容保存至文件
    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
                'LOCATION': '/var/tmp/django_cache',
                # 'LOCATION': os.path.join(BASE_DIR,'cache'),
            }
        }
    # 注：其余配置同开发调试版本

数据库

# 此缓存将内容保存至数据库
    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
                'LOCATION': 'my_cache_table', # 数据库表
            }
        }
    # 注：执行建立表命令 python manage.py createcachetable

Memcache缓存（python-memcached模块）

# 此缓存使用python-memcached模块链接memcache
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': '127.0.0.1:11211',
        }
    }
    CACHES = {  # 链接本地cookie
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': 'unix:/tmp/memcached.sock',
        }
    }   
    # 能够配置多个，链接多个memcache
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': [
                '172.19.26.240:11211',
                '172.19.26.242:11211',
                # ('172.19.26.240:11211',10)  调权重
                # ('172.19.26.242:11211',11)  调权重，memcache模块实现的
            ]
        }
    }

Memcache缓存（pylibmc模块）

# 此缓存使用pylibmc模块链接memcache
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': '127.0.0.1:11211',
        }
    }
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': '/tmp/memcached.sock',
        }
    }   
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': [
                '172.19.26.240:11211',
                '172.19.26.242:11211',
            ]
        }
    }

2.一、三种应用（全局、视图函数、模板）

缓存配置示例（文件方式）mysql

settings.pygit

# 这里在文件末尾处添加。并新建文件夹 cache
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': os.path.join(BASE_DIR,'cache'),
    }
}

urls.py url(r'^cache/$', views.cache),web

单独视图缓存（views函数缓存）*

 # 方式一：
        from django.views.decorators.cache import cache_page

        @cache_page(60 * 15)  # 15分钟
        def my_view(request):
            ...

   # 方式二：
        from django.views.decorators.cache import cache_page

        urlpatterns = [
            url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),
        ]

局部视图使用（模板局部缓存）

 # a. 引入TemplateTag

        {% load cache %}

   # b. 使用缓存

        {% cache 5000 缓存key %}
            缓存内容
        {% endcache %}

示例：正则表达式

views.pysql

from django.views.decorators.cache import cache_page
# @cache_page(10)    views函数缓存
def cache(request):
    import time
    ctime = time.time()
    return render(request, 'cache.html', {'ctime': ctime})

cache.html数据库

{% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    <h1>{{ ctime }}</h1>
    <h1>{{ ctime }}</h1>

     {% cache 10 c1 %}      <!--模板局部缓存-->
        <h1>{{ ctime }}</h1>
     {% endcache %}
</body>
</html>

全站使用

例如博客等缓存，经过中间件实现全站缓存。django

加缓存中间件，那么多中间件加在什么位置？

请求时：缓存加在中间件里的最后一个，好比一次通过一、二、三、4中间件，加在4

返回事：缓存加在中间件里的第一个，如上返回依次通过四、三、二、1，加在1

django 中，导入模块，能够实现。

# 使用中间件，通过一系列的认证等操做，
# 若是内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，
# 当返回给用户以前，判断缓存中是否已经存在，
# 若是不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存

 MIDDLEWARE = [
        'django.middleware.cache.UpdateCacheMiddleware',  # 只有process_response
        # 其余中间件...
        'django.middleware.cache.FetchFromCacheMiddleware',  # 只有process_view
    ]

    CACHE_MIDDLEWARE_ALIAS = ""
    CACHE_MIDDLEWARE_SECONDS = ""
    CACHE_MIDDLEWARE_KEY_PREFIX = ""

2.2 应用多个缓存时生效的优先级

另外：session引擎缓存配置，就是放在这里的缓存里。

若是同时应用了两个级别的缓存，好比views缓存和模板局部缓存，哪一个生效？

哪一个生效，和请求的声明周期的有关系的

因此最早生效的是全站、以后views、最后模板局部缓存。

2、信号

Django中提供了“信号调度”，用于在框架执行操做时解耦。通俗来说，就是一些动做发生的时候，信号容许特定的发送者去提醒一些接受者。

好比在数据库操做，插入一条数据以前和以后都写入日志。

这里装饰器就实现不了了，装饰器用在函数上，这里可能在一条代码先后，并且是每次。

Django是很是牛逼的框架，在不少地方都放置了钩子。咱们调用钩子就能够了。

咱们能够在信号里面注册不少个函数。触发信号时，会把信号里的函数执行一遍。

一、Django内置信号

# Model signals
/    pre_init                # django的modal执行其构造方法前，自动触发
\    post_init               # django的modal执行其构造方法后，自动触发
/    pre_save                # django的modal对象保存前，自动触发
\    post_save               # django的modal对象保存后，自动触发
/    pre_delete              # django的modal对象删除前，自动触发
\    post_delete             # django的modal对象删除后，自动触发
    m2m_changed              # django的modal中使用m2m字段操做第三张表（add,remove,clear）先后，自动触发
    class_prepared           # 程序启动时，检测已注册的app中modal类，对于每个类，自动触发
# Management signals
    pre_migrate              # 执行migrate命令前，自动触发
    post_migrate             # 执行migrate命令后，自动触发
# Request/response signals
    request_started          # 请求到来前，自动触发
    request_finished         # 请求结束后，自动触发
    got_request_exception    # 请求异常后，自动触发
# Test signals
    setting_changed          # 使用test测试修改配置文件时，自动触发
    template_rendered        # 使用test测试渲染模板时，自动触发
# Database Wrappers
    connection_created       # 建立数据库链接时，自动触发

对于Django内置的信号，仅需注册指定信号，当程序执行相应操做时，自动触发注册函数：

　　 from django.core.signals import request_finished
    from django.core.signals import request_started
    from django.core.signals import got_request_exception

    from django.db.models.signals import class_prepared
    from django.db.models.signals import pre_init, post_init
    from django.db.models.signals import pre_save, post_save
    from django.db.models.signals import pre_delete, post_delete
    from django.db.models.signals import m2m_changed
    from django.db.models.signals import pre_migrate, post_migrate

    from django.test.signals import setting_changed
    from django.test.signals import template_rendered

    from django.db.backends.signals import connection_created

    def func1(sender, **kwargs):
        print("xxoo_callback")
        # print(sender,kwargs)  两个参数会把内容传递给信号

    xxoo.connect(func1)  # 信号注册函数func1。xxoo指上述导入的信号

from django.core.signals import request_finished
from django.dispatch import receiver

@receiver(request_finished)
def my_callback(sender, **kwargs):
    print("Request finished!")

如上的代码文件，如何被调用执行呢？

能够在project下的同名目录下__init__.py里导入这个文件，这样一运行就自动注册了

二、自定义信号

定义信号

import django.dispatch
sg_name = django.dispatch.Signal(providing_args=["toppings", "size"])  # 触发信号至少要传两个参数

注册信号

def callback(sender, **kwargs):
    print("callback")
    print(sender,kwargs)

sg_name.connect(callback)

触发信号

from 路径 import sg_name

sg_name.send(sender='发送者随便填',toppings=123, size=456)

因为内置信号的触发者已经集成到Django中，因此其会自动调用，而对于自定义信号则须要开发者在任意位置触发。

好比对系统状态阀值设置，到达某个状态，触发信号。

这样只注册信号就能够，相似插拔式，下降程序耦合。

3、Form

django中的Form功能操做：

验证用户请求
生成HTML标签

（保留上一次提交的数据）

好比用户注册信息验证：用户名不容许为空、密码最短6位，若是本身写须要写不少，比较麻烦，而Django form提供了特别便捷的实现方式

Form表单验证模板模板是一个类，建立以下：

一、初始form，建立form

views.py

from django import forms
class FM(forms.Form):
    # 只关心处理本身定义的form表单数据，恶意攻击定义的数据不处理
    user = forms.CharField()
    pwd = forms.CharField()  # 这里的变量名必须和html form里的name保持一致
    email = forms.EmailField()

def fm(request):
    if request.method == "GET":
        return render(request, "fm.html")
    elif request.method == "POST":
        # 获取用户全部数据，每条数据请求的验证
        # 成功 --> 获取全部的正确信息；失败 --> 显示错误信息
        obj = FM(request.POST)
        r1 = obj.is_valid()
        if r1:  # 返回的正确信息
            print(obj.cleaned_data)
        else:   # 返回的错误信息
            print(obj.errors)
            print(obj.errors.as_json())
        return redirect('/fm/')

fm.html

<body>
    <form action="/fm/" method="POST">
        {% csrf_token %}
        <input type="text" name="user">
        <input type="text" name="pwd">
        <input type="text" name="email">
        <input type="submit" value="提交" />
    </form>
</body>

错误提示以下：

<ul class="errorlist"><li>email<ul class="errorlist"><li>This field is required.</li></ul></li><li>pwd<ul class="errorlist"><li>This field is required.</li></ul></li><li>user<ul class="errorlist"><li>This field is required.</li></ul></li></ul> 
{"email": [{"message": "This field is required.", "code": "required"}], "pwd": [{"message": "This field is required.", "code": "required"}], "user": [{"message": "This field is required.", "code": "required"}]}

上面的错误信息为英文，能不能自定制呢？

二、自定制form错误信息，前端显示

views.py

from django import forms
class FM(forms.Form):
    # 只关心处理本身定义的form表单数据，恶意攻击定义的数据不处理
    user = forms.CharField(error_messages={'required':'用户名不能为空'})
    pwd = forms.CharField(
        max_length=12,
        min_length=6,
        error_messages={'required':'密码不能为空','min_length':'密码长度不能小于6','max_length':'密码长度不能大于12'}
    )
    email = forms.EmailField(error_messages={'required':'用户名不能为空','invalid':'邮箱格式错误'})

def fm(request):
    if request.method == "GET":
        return render(request, "fm.html")
    elif request.method == "POST":
        obj = FM(request.POST)
        r1 = obj.is_valid()
        if r1:  # 返回的正确信息
            print(obj.cleaned_data)
        else:   # 返回的错误信息
            # ErrorDict
            # print(obj.errors['user'][0])
            # print(obj.errors.as_json())
            return render(request,'fm.html',{'obj':obj})
        return render(request,'fm.html')

fm.html

 <form action="/fm/" method="POST">
        {% csrf_token %}
        <p><input type="text" name="user"> {{ obj.errors.user.0 }}</p>
        <p><input type="text" name="pwd"> {{ obj.errors.pwd.0 }}</p>
        <p><input type="text" name="email"> {{ obj.errors.email.0 }}</p>
        <input type="submit" value="提交" />
    </form>

三、保留上一次提交的数据，自动生成html标签

views里面不只能帮咱们生成错误信息，还能帮咱们生成html标签。

fm.html

 <form action="/fm/" method="POST">
        {% csrf_token %}
        <p>{{ obj.user }} {{ obj.errors.user.0 }}</p>
        <p>{{ obj.pwd }} {{ obj.errors.pwd.0 }}</p>
        <p>{{ obj.email }} {{ obj.errors.email.0 }}</p>
        <input type="submit" value="提交" />
    </form>

views.py

def fm(request):
    if request.method == "GET":
        obj = FM()  # 自动生成html时，get这里也须要建立对象
        return render(request, "fm.html",{'obj':obj})
    elif request.method == "POST":
        obj = FM(request.POST)
        r1 = obj.is_valid()
        if r1:  # 返回的正确信息
            print(obj.cleaned_data)  # 这是个字典，注册直接下面那一句就成功了
            # models.UserInfo.objects.create(**obj.cleaned_data)
        else:   # 返回的错误信息
            return render(request,'fm.html',{'obj':obj})
        return render(request,'fm.html')

四、更简洁的html标签生成方法

这里生成虽然方便，可是可定制化不如上面高。

obj.as_p
obj.as_ul
obj.as_table

能够把上面html里的form改成：

 <form action="/fm/" method="POST">
        {% csrf_token %}
        {{ obj.as_p }}
        <input type="submit" value="提交" />
    </form>

<form action="/fm/" method="POST">
        {% csrf_token %}
        {{ obj.as_ul }}
        <input type="submit" value="提交" />
    </form>

<form action="/fm/" method="POST">
        {% csrf_token %}
        <table>
            {{ obj.as_table }}
        </table>  
        <input type="submit" value="提交" />
    </form>

五、自定义样式

form类里面的字段，只有一个功能，就是验证客户端发过来的数据。生成html的功能作不了。

可是怎么生成的html标签呢，在charfield里面有个插件，插件生成的。在其源码里作了html字符串的拼接返回。

from django import forms
from django.forms import widgets  # 插件在这里面
class FM(forms.Form):
    # 字段自己只作验证
    user = forms.CharField(         # 修改html标签，并指定样式##############
        error_messages={'required':'用户名不能为空'},
        widget=widgets.Textarea(attrs={'class':'c1'}),  # 页面再看就是textarea了
        label="用户名"
    )
    pwd = forms.CharField(
        max_length=12,
        min_length=6,
        error_messages={'required':'密码不能为空','min_length':'密码长度不能小于6','max_length':'密码长度不能大于12'},
        widget=widgets.PasswordInput  # 密码密文显示，若是自定义样式也可加上(attrs……)
    )
    email = forms.EmailField(error_messages={'required':'用户名不能为空','invalid':'邮箱格式错误'})

而字段都在from django.forms import fields里面，因此上面的forms能够改用fields

email = fields.EmailField()

前端<p>{{ obj.user.label }}{{ obj.user }} {{ obj.errors.user.0 }}</p>

插件里面input、checkbox、select、redio等所有都有

六、form 内置字段

Field
    required=True,               是否容许为空
    widget=None,                 HTML插件
    label=None,                  用于生成Label标签或显示内容
    initial=None,                初始值
    help_text='',                帮助信息(在标签旁边显示)
    error_messages=None,         错误信息 {'required': '不能为空', 'invalid': '格式错误'}
*   show_hidden_initial=False,   是否在当前插件后面再加一个隐藏的且具备默认值的插件（可用于检验两次输入是否一直）
*   validators=[],               自定义验证规则
    localize=False,              是否支持本地化，使用本地时间
    disabled=False,              是否能够编辑
    label_suffix=None            Label内容后缀

################# 下面的经过本身写正则表达式也能实现 ################# 
CharField(Field)
    max_length=None,             最大长度
    min_length=None,             最小长度
    strip=True                   是否移除用户输入空白

IntegerField(Field)
    max_value=None,              最大值
    min_value=None,              最小值

FloatField(IntegerField)
    ...

DecimalField(IntegerField)
    max_value=None,              最大值
    min_value=None,              最小值
    max_digits=None,             总长度
    decimal_places=None,         小数位长度

BaseTemporalField(Field)
    input_formats=None          时间格式化   

DateField(BaseTemporalField)    格式：2015-09-01
TimeField(BaseTemporalField)    格式：11:12
DateTimeField(BaseTemporalField)格式：2015-09-01 11:12

DurationField(Field)            时间间隔：%d %H:%M:%S.%f
    ...

RegexField(CharField)
    regex,                      自定制正则表达式
    max_length=None,            最大长度
    min_length=None,            最小长度
    error_message=None,         忽略，错误信息使用 error_messages={'invalid': '...'}

EmailField(CharField)      
    ...

FileField(Field)
    allow_empty_file=False     是否容许空文件

ImageField(FileField)      
    ...
    注：须要PIL模块，pip3 install Pillow
    以上两个字典使用时，须要注意两点：
        - form表单中 enctype="multipart/form-data"
        - view函数中 obj = MyForm(request.POST, request.FILES)

URLField(Field)
    ...


BooleanField(Field)  
    ...

NullBooleanField(BooleanField)
    ...

ChoiceField(Field)
    ...
    choices=(),                选项，如：choices = ((0,'上海'),(1,'北京'),)
    required=True,             是否必填
    widget=None,               插件，默认select插件
    label=None,                Label内容
    initial=None,              初始值
    help_text='',              帮助提示


ModelChoiceField(ChoiceField)
    ...                        django.forms.models.ModelChoiceField
    queryset,                  # 查询数据库中的数据
    empty_label="---------",   # 默认空显示内容
    to_field_name=None,        # HTML中value的值对应的字段
    limit_choices_to=None      # ModelForm中对queryset二次筛选

ModelMultipleChoiceField(ModelChoiceField)
    ...                        django.forms.models.ModelMultipleChoiceField



TypedChoiceField(ChoiceField)
    coerce = lambda val: val   对选中的值进行一次转换
    empty_value= ''            空值的默认值

MultipleChoiceField(ChoiceField)
    ...

TypedMultipleChoiceField(MultipleChoiceField)
    coerce = lambda val: val   对选中的每个值进行一次转换
    empty_value= ''            空值的默认值

ComboField(Field)
    fields=()                  使用多个验证，以下：即验证最大长度20，又验证邮箱格式
                               fields.ComboField(fields=[fields.CharField(max_length=20), fields.EmailField(),])

MultiValueField(Field)
    PS: 抽象类，子类中能够实现聚合多个字典去匹配一个值，要配合MultiWidget使用

SplitDateTimeField(MultiValueField)
    input_date_formats=None,   格式列表：['%Y--%m--%d', '%m%d/%Y', '%m/%d/%y']
    input_time_formats=None    格式列表：['%H:%M:%S', '%H:%M:%S.%f', '%H:%M']

FilePathField(ChoiceField)     文件选项，目录下文件显示在页面中
    path,                      文件夹路径
    match=None,                正则匹配
    recursive=False,           递归下面的文件夹
    allow_files=True,          容许文件
    allow_folders=False,       容许文件夹
    required=True,
    widget=None,
    label=None,
    initial=None,
    help_text=''

GenericIPAddressField
    protocol='both',           both,ipv4,ipv6支持的IP格式
    unpack_ipv4=False          解析ipv4地址，若是是::ffff:192.0.2.1时候，可解析为192.0.2.1， PS：protocol必须为both才能启用

SlugField(CharField)           数字，字母，下划线，减号（连字符）
    ...

UUIDField(CharField)           uuid类型

...

说一下上面的ChoiceField，它主要作选项用的

city = fields.ChoiceField(
        choices=[(0,'上海'),(1,'广州')]
    )
    city2 = fields.MultipleChoiceField(
        choices=[(0,'上海'),(1,'广州')]
    )

经常使用选择插件

# 单radio，值为字符串
# user = fields.CharField(
#     initial=2,
#     widget=widgets.RadioSelect(choices=((1,'上海'),(2,'北京'),))
# )

# 单radio，值为字符串
# user = fields.ChoiceField(
#     choices=((1, '上海'), (2, '北京'),),
#     initial=2,
#     widget=widgets.RadioSelect
# )

# 单select，值为字符串
# user = fields.CharField(
#     initial=2,
#     widget=widgets.Select(choices=((1,'上海'),(2,'北京'),))
# )

# 单select，值为字符串
# user = fields.ChoiceField(
#     choices=((1, '上海'), (2, '北京'),),
#     initial=2,
#     widget=widgets.Select
# )

# 多选select，值为列表
# user = fields.MultipleChoiceField(
#     choices=((1,'上海'),(2,'北京'),),
#     initial=[1,],
#     widget=widgets.SelectMultiple
# )


# 单checkbox
# user = fields.CharField(
#     widget=widgets.CheckboxInput()
# )


# 多选checkbox,值为列表
# user = fields.MultipleChoiceField(
#     initial=[2, ],
#     choices=((1, '上海'), (2, '北京'),),
#     widget=widgets.CheckboxSelectMultiple
# )

Django内置插件：

TextInput(Input)
NumberInput(TextInput)
EmailInput(TextInput)
URLInput(TextInput)
PasswordInput(TextInput)
HiddenInput(TextInput)
Textarea(Widget)
DateInput(DateTimeBaseInput)
DateTimeInput(DateTimeBaseInput)
TimeInput(DateTimeBaseInput)
CheckboxInput
Select
NullBooleanSelect
SelectMultiple
RadioSelect
CheckboxSelectMultiple
FileInput
ClearableFileInput
MultipleHiddenInput
SplitDateTimeWidget
SplitHiddenDateTimeWidget
SelectDateWidget

自定义
    - 类
    - 字段（校验）
    - 插件（生成HTML）

七、初始化操做

在Web应用程序中开发编写功能时，时经常使用到获取数据库中的数据并将值初始化在HTML中的标签上。

def fm(request):
    if request.method == "GET":
        dic = {
            "user":'r1',
            "pwd":'123456',
            "email":'aera@11.com',
            "city":1,
            "city2":[1,2],
        }
        obj = FM(initial=dic)  # 初始化
        return render(request, "fm.html",{'obj':obj})
    # ……

转载请务必保留此出处：http://www.cnblogs.com/lgeng/articles/7366204.html

《版本说明》: 本文转自 -- http://blog.csdn.net/fgf00/article/details/54319791