Django之缓存、信号和图片验证码、ORM性能
阅读原文时间:2023年07月09日阅读:5

一、 缓存

1、 介绍

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

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

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

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

3、 配置缓存(在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',  
            \]  
        }  
    }

4、 简单的应用

配置好了缓存的方式之后,我们使用缓存机制也是非常简单的

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 = ""
  1. 局部视图(在HTML页面设置哪些需要缓存):粒度最细

    a. 引入TemplateTag

    {% load cache %}

    b. 使用缓存

    {% cache 300 '缓存key' %}  # 缓存key的名字可以是随意的  
        缓存内容  
    {% endcache %}

二、 序列化

1、介绍

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

2、serializers

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

return HttpResponse(ret)

3、自定义序列化

由于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指定序列化的时候去执行这个类

三、 信号

1、介绍

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

2、内置信号

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 # 创建数据库连接时,自动触发

3、使用

1. 场景:数据库增加一条数据时,就记录一条日志,若不使用信号,则需要在每个创建语句下面写记录日志的语句。

  1. 介绍
    对于Django内置的信号,仅需注册指定信号,当程序执行相应操作时,自动触发注册函数
    注册信号,写入与project同名的文件夹下的_init_.py文件中,也是换数据库引擎的地方。

  2. 注册信号步骤

  3. 导入需要的信号模块(这里列出全部模块,实际开发的时候需要哪个就导入哪个)
    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

  1. 定义函数来处理信号

方法一

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)

4、自定义信号

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中,所以其会自动调用,而对于自定义信号则需要开发者在任意位置触发。

四、 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)

1、 直接查询--> [ 对象 ]
用的时候注意,只拿自己表中的字段,别跨表,比如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表查

2、 要用到跨表字段的时候,使用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:连表较少的时候使用,如:外键、一对一
select_related主要针一对一和多对一关系进行优化,通过多表join关联查询,一次性获得所有数据,
存放在内存中,但如果关联的表太多,会严重影响数据库性能

# 查询的时候把关联的表也一起查了,也是一次查询出结果,跟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:连表较多的时候使用,如:多对多字段和一对多字段
prefetch_related是通过分表,先获取各个表的数据,存放在内存中,然后通过Python处理他们之间的关联

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

for user in all\_users:  
    print(user.name)  # 访问指定的字段name不需要再去查询数据库

for user in all\_users:  
    print(user.age)  # 访问不是指定的字段,每一次都去查一次数据库

6、 defer:将除了指定的字段查询加载出来,后续再访问指定的字段就不需要再查询数据库(only的反义词)
all_users = models.User.objects.all().defer('name')

for user in all\_users:  
    print(user.name)  # 访问指定的字段name,每一次都需要去查询数据库

for user in all\_users:  
    print(user.age)  # 访问不是指定的字段,不需要再查询数据库

五、 验证码

1、随机验证码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

2、如何生成图片

1. 验证码的形式
回想一下,平时我们输入验证码的时候,是不是都是看着一张图片,图片上显示验证码,我们看着图片输入验证码。
当然现在还有滑动的,点击等等,这里我们先学习图片的形式。

  1. 实现步骤
    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,这样登录的时候就可以校验了。

3、在视图中使用验证码

1. urls
urlpatterns = [
# 获取图片的路由
url(r'^login/', views.login),
url(r'^v_code/', views.v_code),
]

  1. 在页面中点击验证码图片,刷新验证码


    Title
{% csrf\_token %} 用户名 密码 图片加载失败


  1. 验证码视图函数
    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')
  1. 登录视图函数
    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})

4、验证码的额外小知识

画完验证码后,可以添加一些干扰
就是在 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())

手机扫一扫

移动阅读更方便

阿里云服务器
腾讯云服务器
七牛云服务器

你可能感兴趣的文章