Django之缓存、信号和图片验证码

1、 缓存

一、 介绍

缓存通俗来讲：就是把数据先保存在某个地方，下次再读取的时候不用再去原位置读取，让访问速度更快。
缓存机制图解

 

二、Django中提供了6种缓存方式

　　1. 开发调试
　　2. 内存
　　3. 文件
　　4. 数据库
　　5. Memcache缓存（python-memcached模块）
　　6. Memcache缓存（pylibmc模块）

 注意：下面对缓存进行配置，其实就是设置了缓存方式，是为了设置缓存的存放位置，若是没有设置缓存方式，那么就默认使用的是本地内存缓存的方式。

 

三、 配置缓存(在setting中配置)

配置缓存的方式 1. 开发调试 # 此为开始调试用，实际内部不作任何操做
    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（默认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 2. 内存 # 此缓存将内容保存至内存的变量中
        CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'LOCATION': 'unique-snowflake', 'TIMEOUT': 300,  # 缓存超时时间（默认300，None表示永不过时，0表示当即过时）
                'OPTIONS': { 'MAX_ENTRIES': 300,  # 最大缓存个数（默认300）
                    'CULL_FREQUENCY': 3,  # 缓存到达最大个数以后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
 }, } } 3. 文件 # 此缓存将内容保存至文件
    # 配置：
 CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', 'LOCATION': '/var/tmp/django_cache',  # 文件路径
 } } # 注：其余配置同开发调试版本


    4. 数据库 # 此缓存将内容保存至数据库

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


    5. Memcache缓存（python-memcached模块） # 此缓存使用python-memcached模块链接memcache
 CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': '127.0.0.1:11211', } } CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': 'unix:/tmp/memcached.sock', } } CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': [ '172.19.26.240:11211', '172.19.26.242:11211', ] } } 6. 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', ] } }

 

四、 简单的应用

配置好了缓存的方式以后，咱们使用缓存机制也是很是简单的

1. 给单独的视图应用缓存： 粒度适中 方式一：直接给视图函数添加装饰器 # views.py
    import datetime from django.views.decorators.cache import cache_page @cache_page(15)  # 缓存15秒后失效
    def test_cache(request): now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') return HttpResponse(now) 方式二：给路由添加 # urls.py
    from myapp.views import test_cache from django.views.decorators.cache import cache_page urlpatterns = [ url(r'^testcache/$', cache_page(15)(test_cache)), ] 方式一和二选择一种便可 2. 全站应用： 粒度最大(settings.py) 使用中间件，通过一系列的认证等操做，若是内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户， 当返回给用户以前，判断缓存中是否已经存在，若是不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存(全部视图都进行缓存) MIDDLEWARE = [ # 站点缓存 ， 注意必须在第一个位置
        'django.middleware.cache.UpdateCacheMiddleware', # 其余中间件...

        # 站点缓存 ， 注意必须在最后一个位置
        'django.middleware.cache.FetchFromCacheMiddleware', ] CACHE_MIDDLEWARE_ALIAS = "" CACHE_MIDDLEWARE_SECONDS = 300  # 缓存有效时间
    CACHE_MIDDLEWARE_KEY_PREFIX = ""


3. 局部视图(在HTML页面设置哪些须要缓存)：粒度最细 a. 引入TemplateTag {% load cache %} b. 使用缓存 {% cache 300 '缓存key' %}  # 缓存key的名字能够是随意的
 缓存内容 {% endcache %}

 

2、 序列化

一、介绍

关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户，特别的Ajax请求通常返回的为Json格式。

 

二、serializers

from django.core import serializers def get_value(request): users = models.User.objects.all() ret = serializers.serialize('json', users) return HttpResponse(ret)

 

三、自定义序列化

因为json模块并不能转换时间类型的数据，所以须要咱们自定义一个类来处理时间类型的数据 import json from datetime import datetime, date data = [  # data数据中有datetime类型的值， json不能直接序列化
    {"pk": 1, "name": "\u83b9\u83b9", "age": 18, 'birth': datetime.now()}, {"pk": 2, "name": "\u5c0f\u5fae", "age": 16, 'birth': datetime.now()}, {"pk": 3, "name": "\u5c0f\u9a6c\u54e5", "age": 8, 'birth': datetime.now()}, {"pk": 4, "name": "qqq", "age": 5, 'birth': datetime.now()}, {"pk": 5, "name": "www", "age": 5, 'birth': datetime.now()} ] # json序列化的时候是调用JSONEncoder这个类的default方法进行序列化的
class JsonCustomEncoder(json.JSONEncoder):  # 自定义一个类，从新json.dumps的default方法

    def default(self, field):  # 循环每一个字段的值
        
        if isinstance(field, datetime):  # 若是这个值是datetime类型，咱们本身把它转成字符串类型的时间
            return field.strftime('%Y-%m-%d %H:%M:%S') elif isinstance(field, date):  # 若是这个值是date类型，咱们本身把它转成字符串类型的时间
            return field.strftime('%Y-%m-%d') else: return json.JSONEncoder.default(self, field)  # 若是这个值不是时间类型，调用其父类本来的default方法进行序列化

print(json.dumps(data,cls=JsonCustomEncoder))  # cls指定序列化的时候去执行这个类

 

3、 信号

一、介绍

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

 

二、内置信号

Model signals pre_init # django的model执行其构造方法前，自动触发
    post_init                   # django的model执行其构造方法后，自动触发
    pre_save                    # django的model对象保存前，自动触发
    post_save                   # django的model对象保存后，自动触发
    pre_delete                  # django的model对象删除前，自动触发
    post_delete                 # django的model对象删除后，自动触发
    m2m_changed                 # django的model中使用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 # 建立数据库链接时，自动触发

 

三、使用

1. 场景：数据库增长一条数据时，就记录一条日志，若不使用信号，则须要在每一个建立语句下面写记录日志的语句。 2. 介绍 对于Django内置的信号，仅需注册指定信号，当程序执行相应操做时，自动触发注册函数 注册信号，写入与project同名的文件夹下的_init_.py文件中，也是换数据库引擎的地方。 3. 注册信号步骤 1. 导入须要的信号模块(这里列出所有模块，实际开发的时候须要哪一个就导入哪一个) 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 2. 定义函数来处理信号 # 方法一
from django.db.models.signals import post_save # 函数名可随意，可是参数(sender, **kwargs)是固定的，就这两个参数
def callback(sender, **kwargs): print("xxoo_callback") print(sender, kwargs) post_save.connect(callback) # 注册post_save信号：django的model对象保存后，自动触发callback函数 # post_save信号中，render就是触发信号的那一个ORM类(表) # kwargs就是这个类的一些参数：instance是这个类的实例，created:是不是建立操做


# 方法二
from django.db.models.signals import post_save from django.dispatch import receiver @receiver(post_save) def my_callback(sender, **kwargs): print("xxoo_callback") print(sender, kwargs) # 方法三：指定触发者
from django.db.models.signals import post_save from django.dispatch import receiver from myapp.models import MyModel # 指定只有MyModel这个类才能触发这个函数
@receiver(post_save, sender=MyModel) def my_callback(sender, **kwargs): print("xxoo_callback") print(sender, kwargs) # 或者
post_save.connect(callback, sender=MyModel)

 

四、自定义信号

a. 定义信号 在某py文件中定义信号。 import django.dispatch # pizza_done是信号名 # providing_args是传给信号绑定的函数的kwargs
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"]) b. 注册信号 在_init_.py 中注册信号 from 路径 import pizza_done def callback(sender, **kwargs): print("callback") print(sender,kwargs) pizza_done.connect(callback) c. 触发信号 from 路径 import pizza_done pizza_done.send(sender='seven',toppings=123, size=456) 因为内置信号的触发者已经集成到Django中，因此其会自动调用，而对于自定义信号则须要开发者在任意位置触发。

 

 

4、 ORM性能相关

0、 表结构 class Role(models.Model): name = models.CharField(max_length=32) class User(models.Model): name = models.CharField(max_length=32) age = models.IntegerField() role = models.ForeignKey('Role', null=True, blank=True) 一、 直接查询--> [ 对象 ] 用的时候注意，只拿本身表中的字段，别跨表，好比all_users有3条数据，user表经过外键关联role表， 若是要跨表拿到role表的name字段： all_users = models.User.objects.all() for user in all_users: print(user.name, user.age, user.role.name) 其实一个进行了四次查询，第一次查询出all_users,而后每次的user.role.name都去role表查 二、 要用到跨表字段的时候，使用values或values_list查询速度更快，只需一次查询便可--> [{}] all_users = models.User.objects.all().values('name','age','role__name') for user in all_users: print(user['name'], user['age'], user['role__name']) 3、 select_related：连表较少的时候使用，如：外键、一对一 查询的时候把关联的表也一块儿查了，也是一次查询出结果，跟values不一样的是，能够直接用点取字段 all_users = models.User.objects.all().select_related('role') for user in all_users: print(user.name, user.age, user.role.name) 4、 prefetch_related：连表较多的时候使用，如：多对多字段和一对多字段 all_users = models.User.objects.all().prefetch_related('role') for user in all_users: print(user.name, user.age, user.role.name) 5、 only：将指定的字段查询加载出来，后续再访问指定的字段就不须要再查询数据库 all_users = models.User.objects.all().only('name') 用的时候注意，只拿本身指定的字段 6、 defer：将除了指定的字段查询加载出来，后续再访问指定的字段就不须要再查询数据库(only的反义词) all_users = models.User.objects.all().defer('name')

 

5、 验证码

一、随机验证码python代码

import random def get_code(): code = ''
    for i in range(6): num = str(random.randint(0, 9))  # 数字
        lower = chr(random.randint(97, 122))  # 小写字母
        upper = chr(random.randint(65, 90))  # 大写字母
        c = random.choice([num, lower, upper])  # 随机选取一个
        code += str(c) return code

 

二、如何生成图片

1. 验证码的形式 回想一下，平时咱们输入验证码的时候，是否是都是看着一张图片，图片上显示验证码，咱们看着图片输入验证码。 固然如今还有滑动的，点击等等，这里咱们先学习图片的形式。 2. 实现步骤 1， 准备一张没有任何内容的图片 2， 安装python专门处理图片的第三方包 pip install Pillow 3， 包的导入 from PIL import Image, ImageDraw, ImageFont 4, Image:生成一张图片 ImageDraw：生成一个画笔，用于在图片上画验证码 ImageFont：字体的格式和大小 5，示例 from PIL import Image, ImageDraw, ImageFont # 返回随机的RGB数字
def random_color(): return random.randint(0, 255), random.randint(0, 255), random.randint(0, 255) def get_code(): with open('1.png', 'wb') as f: # 第一步：生成一张图片(画布)
        # 建立一个随机颜色的图片对象
        # 参数：颜色模式，图片大小，图片颜色
        img_obj = Image.new('RGB', (250, 35), random_color()) # 第二步：在该图片对象上生成一个画笔对象
        draw_obj = ImageDraw.Draw(img_obj) # 使用什么字体，字体大小,kumo.ttf是我本地下载好的字体文件(sc.chinaz.com)可下载
        font_obj = ImageFont.truetype('static/font/kumo.ttf', 28) # 生成验证码
        code = ''
        for i in range(6): num = str(random.randint(0, 9))  # 数字
            lower = chr(random.randint(97, 122))  # 小写字母
            upper = chr(random.randint(65, 90))  # 大写字母
            c = random.choice([num, lower, upper])  # 随机选取一个
            code += str(c) # 用画笔把验证码画到图片上
            # 参数：xy:坐标，画在哪一个位置；text:画的内容；fill:画什么颜色；font:字体格式
            draw_obj.text((35 + i*30, 0), c, fill=random_color(), font=font_obj) # 保存图片
 img_obj.save(f) get_code() 6，缺点 上面的代码是在你的硬盘上存了一张图片，若是要在页面上展现，你还得进行文件的读， 这样的话不只浪费硬盘空间，效率还不够高，所以咱们应该把图片写到内存，从内存中取，效率就快不少了， 而后把图片的验证码数据存到session，这样登陆的时候就能够校验了。

 

 

三、在视图中使用验证码

1. urls urlpatterns = [ # 获取图片的路由
    url(r'^login/', views.login), url(r'^v_code/', views.v_code), ] 2. 在页面中点击验证码图片，刷新验证码 <!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Title</title>
</head>
<body>

<form action='' method='POST'> {% csrf_token %} <input type='text' name='username'>用户名 <input type='password' name='password'>密码 <img src="/v_code/" alt="图片加载失败" id="v_code">
    <button type="submit">登陆</button>
</form>

<script> img = document.getElementById('v_code'); img.onclick = function () { img.src += '?' } </script>

</body>
</html>


3. 验证码视图函数 from PIL import Image, ImageDraw, ImageFont import random def random_color(): return random.randint(0, 255), random.randint(0, 255), random.randint(0, 255) def v_code(request): # 第一步：生成一张图片(画布)
    # 建立一个随机颜色的图片对象
    # 参数：颜色模式，图片大小，图片颜色
    img_obj = Image.new('RGB', (250, 35), random_color()) # 第二步：在该图片对象上生成一个画笔对象
    draw_obj = ImageDraw.Draw(img_obj) # 使用什么字体，字体大小
    font_obj = ImageFont.truetype('static/font/kumo.ttf', 28) # 生成验证码
    code = ''
    for i in range(6): num = str(random.randint(0, 9))  # 数字
        lower = chr(random.randint(97, 122))  # 小写字母
        upper = chr(random.randint(65, 90))  # 大写字母
        c = random.choice([num, lower, upper])  # 随机选取一个
        code += str(c) # 用画笔把验证码画到图片上
        # 参数：xy:坐标，画在哪一个位置；text:画的内容；fill:画什么颜色；font:字体格式
        draw_obj.text((35 + i*30, 0), c, fill=random_color(), font=font_obj) # 把图片里面的验证码的内容写到session,且忽略大小写
    request.session['v_code'] = code.upper() # 把图片写到内存
    from io import BytesIO f1 = BytesIO()  # 相似于文件的文件句柄：f1 = open()
    # 把图片保存到内存
    img_obj.save(f1, format="PNG") # 从内存中取数据
    img_data = f1.getvalue() return HttpResponse(img_data, content_type='image/png') 4. 登陆视图函数 def login(request): err_msg = ''
    if request.method == 'POST': username = request.POST.get('username') password = request.POST.get('password') v_code = request.POST.get('v_code', '').upper() if v_code == request.session.get('v_code'): obj = auth.authenticate(request, username=username, password=password) if obj: auth.login(request, obj) # 认证成功 初始化权限信息
                ret = init_permission(request, obj) if ret: return ret return redirect(reverse('my_customer')) err_msg = '用户名或密码错误'
        else: err_msg = '验证码错误'
    
    return render(request, 'login.html', {'err_msg': err_msg})

 

四、验证码的额外小知识

画完验证码后，能够添加一些干扰 就是在 draw_obj.text((35 + i*30, 0), c, fill=random_color(), font=font_obj)以后加 1. 加干扰线 width = 250  # 图片宽度（防止越界）
height = 35
for i in range(5): x1 = random.randint(0, width) x2 = random.randint(0, width) y1 = random.randint(0, height) y2 = random.randint(0, height) draw_obj.line((x1, y1, x2, y2), fill=random_color()) 2. 加干扰点 for i in range(40): draw_obj.point([random.randint(0, width), random.randint(0, height)], fill=random_color()) x = random.randint(0, width) y = random.randint(0, height) draw_obj.arc((x, y, x+4, y+4), 0, 90, fill=random_color())