Django组件拾忆

Posted 不_一

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Django组件拾忆相关的知识,希望对你有一定的参考价值。

一 Django的form组件

二 Django的model form组件

这是一个神奇的组件,通过名字我们可以看出来,这个组件的功能就是把model和form组合起来

三 Django的缓存机制

1.1 缓存介绍

1.缓存的简介

在动态网站中,用户所有的请求,服务器都会去数据库中进行相应的增,删,查,改,渲染模板,执行业务逻辑,最后生成用户看到的页面.

当一个网站的用户访问量很大的时候,每一次的的后台操作,都会消耗很多的服务端资源,所以必须使用缓存来减轻后端服务器的压力.

缓存是将一些常用的数据保存内存或者memcache中,在一定的时间内有人来访问这些数据时,则不再去执行数据库及渲染等操作,而是直接从内存或memcache的缓存中去取得数据,然后返回给用户.

2.Django提供了6种缓存方式

  • 开发调试缓存
  • 内存缓存
  • 文件缓存
  • 数据库缓存
  • Memcache缓存(使用python-memcached模块)
  • Memcache缓存(使用pylibmc模块)

经常使用的有文件缓存和Mencache缓存

1.2 各种缓存配置

1.2.1 开发调试(此模式为开发调试使用,实际上不执行任何操作)

settings.py文件配置

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)
  },
 }
}
View Code

1.2.2 内存缓存(将缓存内容保存至内存区域中)

settings.py文件配置

CACHES = {
 \'default\': {
  \'BACKEND\': \'django.core.cache.backends.locmem.LocMemCache\',  # 指定缓存使用的引擎
  \'LOCATION\': \'unique-snowflake\',         # 写在内存中的变量的唯一值 
  \'TIMEOUT\':300,             # 缓存超时时间(默认为300秒,None表示永不过期)
  \'OPTIONS\':{
   \'MAX_ENTRIES\': 300,           # 最大缓存记录的数量(默认300)
   \'CULL_FREQUENCY\': 3,          # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
  }  
 }
}
View Code

1.2.3 文件缓存(把缓存数据存储在文件中)

settings.py文件配置

CACHES = {
 \'default\': {
  \'BACKEND\': \'django.core.cache.backends.filebased.FileBasedCache\', #指定缓存使用的引擎
  \'LOCATION\': \'/var/tmp/django_cache\',        #指定缓存的路径
  \'TIMEOUT\':300,              #缓存超时时间(默认为300秒,None表示永不过期)
  \'OPTIONS\':{
   \'MAX_ENTRIES\': 300,            # 最大缓存记录的数量(默认300)
   \'CULL_FREQUENCY\': 3,           # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
  }
 }   
}
View Code

1.2.4 数据库缓存(把缓存数据存储在数据库中)

settings.py文件配置

CACHES = {
 \'default\': {
  \'BACKEND\': \'django.core.cache.backends.db.DatabaseCache\',  # 指定缓存使用的引擎
  \'LOCATION\': \'cache_table\',          # 数据库表    
  \'OPTIONS\':{
   \'MAX_ENTRIES\': 300,           # 最大缓存记录的数量(默认300)
   \'CULL_FREQUENCY\': 3,          # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
  }  
 }   
}
View Code

注意,创建缓存的数据库表使用的语句:

python manage.py createcachetable

1.2.5 Memcache缓存(使用python-memcached模块连接memcache)

Memcached是Django原生支持的缓存系统.要使用Memcached,需要下载Memcached的支持库python-memcached或pylibmc.

settings.py文件配置

CACHES = {
 \'default\': {
  \'BACKEND\': \'django.core.cache.backends.memcached.MemcachedCache\', # 指定缓存使用的引擎
  \'LOCATION\': \'192.168.10.100:11211\',         # 指定Memcache缓存服务器的IP地址和端口
  \'OPTIONS\':{
   \'MAX_ENTRIES\': 300,            # 最大缓存记录的数量(默认300)
   \'CULL_FREQUENCY\': 3,           # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
  }
 }
}
View Code

LOCATION也可以配置成如下:

\'LOCATION\': \'unix:/tmp/memcached.sock\',   # 指定局域网内的主机名加socket套接字为Memcache缓存服务器
\'LOCATION\': [         # 指定一台或多台其他主机ip地址加端口为Memcache缓存服务器
 \'192.168.10.100:11211\',
 \'192.168.10.101:11211\',
 \'192.168.10.102:11211\',
]
View Code

1.2.6 Memcache缓存(使用pylibmc模块连接memcache)

settings.py文件配置
 CACHES = {
  \'default\': {
   \'BACKEND\': \'django.core.cache.backends.memcached.PyLibMCCache\',  # 指定缓存使用的引擎
   \'LOCATION\':\'192.168.10.100:11211\',         # 指定本机的11211端口为Memcache缓存服务器
   \'OPTIONS\':{
    \'MAX_ENTRIES\': 300,            # 最大缓存记录的数量(默认300)
    \'CULL_FREQUENCY\': 3,           # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
   },  
  }
 }
View Code

LOCATION也可以配置成如下:

\'LOCATION\': \'/tmp/memcached.sock\',  # 指定某个路径为缓存目录
\'LOCATION\': [       # 分布式缓存,在多台服务器上运行Memcached进程,程序会把多台服务器当作一个单独的缓存,而不会在每台服务器上复制缓存值
 \'192.168.10.100:11211\',
 \'192.168.10.101:11211\',
 \'192.168.10.102:11211\',
]
View Code

Memcached是基于内存的缓存,数据存储在内存中.所以如果服务器死机的话,数据就会丢失,所以Memcached一般与其他缓存配合使用

1.3 Django中的缓存应用

Django提供了不同粒度的缓存,可以缓存某个页面,可以只缓存一个页面的某个部分,甚至可以缓存整个网站.

数据库:

class Book(models.Model):
    name=models.CharField(max_length=32)
    price=models.DecimalField(max_digits=6,decimal_places=1)

视图:

from django.views.decorators.cache import cache_page
import time
from .models import *

@cache_page(15)          #超时时间为15秒
def index(request):

 t=time.time()      #获取当前时间
 bookList=Book.objects.all()
 return render(request,"index.html",locals())

模板(index.html):

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h3>当前时间:-----{{ t }}</h3>

<ul>
    {% for book in bookList %}
       <li>{{ book.name }}--------->{{ book.price }}$</li>
    {% endfor %}
</ul>

</body>
</html>

上面的例子是基于内存的缓存配置,基于文件的缓存该怎么配置呢??

更改settings.py的配置

CACHES = {
 \'default\': {
  \'BACKEND\': \'django.core.cache.backends.filebased.FileBasedCache\', # 指定缓存使用的引擎
  \'LOCATION\': \'E:\\django_cache\',          # 指定缓存的路径
  \'TIMEOUT\': 300,              # 缓存超时时间(默认为300秒,None表示永不过期)
  \'OPTIONS\': {
   \'MAX_ENTRIES\': 300,            # 最大缓存记录的数量(默认300)
   \'CULL_FREQUENCY\': 3,           # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
  }
 }
}

然后再次刷新浏览器,可以看到在刚才配置的目录下生成的缓存文件

通过实验可以知道,Django会以自己的形式把缓存文件保存在配置文件中指定的目录中. 

1.3.2 全站使用缓存

既然是全站缓存,当然要使用Django中的中间件.

用户的请求通过中间件,经过一系列的认证等操作,如果请求的内容在缓存中存在,则使用FetchFromCacheMiddleware获取内容并返回给用户

当返回给用户之前,判断缓存中是否已经存在,如果不存在,则UpdateCacheMiddleware会将缓存保存至Django的缓存之中,以实现全站缓存

缓存整个站点,是最简单的缓存方法

在 MIDDLEWARE_CLASSES 中加入 “update” 和 “fetch” 中间件
MIDDLEWARE_CLASSES = (
    ‘django.middleware.cache.UpdateCacheMiddleware’, #第一
    \'django.middleware.common.CommonMiddleware\',
    ‘django.middleware.cache.FetchFromCacheMiddleware’, #最后
)
“update” 必须配置在第一个
“fetch” 必须配置在最后一个

修改settings.py配置文件

MIDDLEWARE_CLASSES = (
    \'django.middleware.cache.UpdateCacheMiddleware\',   #响应HttpResponse中设置几个headers
    \'django.contrib.sessions.middleware.SessionMiddleware\',
    \'django.middleware.common.CommonMiddleware\',
    \'django.middleware.csrf.CsrfViewMiddleware\',
    \'django.contrib.auth.middleware.AuthenticationMiddleware\',
    \'django.contrib.auth.middleware.SessionAuthenticationMiddleware\',
    \'django.contrib.messages.middleware.MessageMiddleware\',
    \'django.middleware.clickjacking.XFrameOptionsMiddleware\',
    \'django.middleware.security.SecurityMiddleware\',
    \'django.middleware.cache.FetchFromCacheMiddleware\',   #用来缓存通过GET和HEAD方法获取的状态码为200的响应

)


CACHE_MIDDLEWARE_SECONDS=10

视图函数:

from django.views.decorators.cache import cache_page
import time
from .models import *


def index(request):

     t=time.time()      #获取当前时间
     bookList=Book.objects.all()
     return render(request,"index.html",locals())

def foo(request):
    t=time.time()      #获取当前时间
    return HttpResponse("HELLO:"+str(t))

模板(index.html):

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h3 style="color: green">当前时间:-----{{ t }}</h3>

<ul>
    {% for book in bookList %}
       <li>{{ book.name }}--------->{{ book.price }}$</li>
    {% endfor %}
</ul>

</body>
</html>

其余代码不变,刷新浏览器是10秒,页面上的时间变化一次,这样就实现了全站缓存.

1.3.3 局部视图缓存

例子,刷新页面时,整个网页有一部分实现缓存

views视图函数

from django.views.decorators.cache import cache_page
import time
from .models import *


def index(request):

     t=time.time()      #获取当前时间
     bookList=Book.objects.all()

     return render(request,"index.html",locals())

模板(index.html):

{% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
 <h3 style="color: green">不缓存:-----{{ t }}</h3>

{% cache 2 \'name\' %}
 <h3>缓存:-----:{{ t }}</h3>
{% endcache %}

</body>
</html> 

四 Django的信号

Django提供一种信号机制。其实就是观察者模式,又叫发布-订阅(Publish/Subscribe) 。当发生一些动作的时候,发出信号,然后监听了这个信号的函数就会执行。

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

2.1、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 提供了一系列的内建信号,允许用户的代码获得DJango的特定操作的通知。这包含一些有用的通知:
django.db.models.signals.pre_save & django.db.models.signals.post_save

在模型 save()方法调用之前或之后发送。
django.db.models.signals.pre_delete & django.db.models.signals.post_delete

在模型delete()方法或查询集的delete() 方法调用之前或之后发送。
django.db.models.signals.m2m_changed

模型上的 ManyToManyField 修改时发送。
django.core.signals.request_started & django.core.signals.request_finished

Django建立或关闭HTTP 请求时发送。
View Code

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

方式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


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

    pre_save.connect(callback)      # 该脚本代码需要写到app或者项目的初始化文件中,当项目启动时执行注册代码

方式2:

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

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

2.2、自定义信号 

a. 定义信号

1
2
import django.dispatch
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])

b. 注册信号

1
2
3
4
5
def callback(sender, **kwargs):
    print("callback")
    print(sender,kwargs)
  
pizza_done.connect(callback)

c. 触发信号

1
2
3
from 路径 import pizza_done
  
pizza_done.send(sender=\'seven\',toppings=123, size=456)

由于内置信号的触发者已经集成到Django中,所以其会自动调用,而对于自定义信号则需要开发者在任意位置触发。 

练习:数据库添加一条记录时生成一个日志记录。

五 Django的序列化

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

1、serializers

1
2
3
4
5
from django.core import serializers
  
ret = models.BookType.objects.all()
  
data = serializers.serialize("json", ret)

2、json.dumps

1
2
3
4
5
6
7
8
import json
  
#ret = models.BookType.objects.all().values(\'caption\')
ret = models.BookType.objects.all().values_list(\'caption\')
  
ret=list(ret)
  
result = json.dumps(ret)

由于json.dumps时无法处理datetime日期,所以可以通过自定义处理器来做扩展,如:

import json
from datetime import date
from datetime import datetime

d=datetime.now()

class JsonCustomEncoder(json.JSONEncoder):

    def default(self, field):

        if isinstance(field, datetime):
            return field.strftime(\'%Y-%m-%d %H:%M---%S\')
        elif isinstance(field, date):
            return field.strftime(\'%Y-%m-%d\')
        else:
            return json.JSONEncoder.default(self, field)


ds = json.dumps(d, cls=JsonCustomEncoder)

print(ds)
print(type(ds))



\'\'\'
Supports the following objects and types by default:

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

\'\'\'

以上是关于Django组件拾忆的主要内容,如果未能解决你的问题,请参考以下文章

DJANGO 自定义分页组件

Django REST framework 基本组件

using 用法拾忆

sql拾忆sql整理

python小例子小例子拾忆

从List去除重复拾忆集合