一，信号：
内置信号的引入from django.core.signals import request_finishedfrom 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
对于Django内置信号，只需在项目的__init__.py文件里配置相应的callback函数，并进行注册就可以（放在__init__.py文件是因为该文件是Django项目启动时必经之路，这样只要项目一启动就会纪录信号的状态，并根据信号状态
决定是否执行回调函数
）
除了内置信号，还可以自定制信号函数：
自己定制的信号可以放置在任何地方，只要保证在__init__.py文件里引入就可以，但是函数的callback函数以及注册和信号触发都需要自行写入代码
自定制信号函数：
import django.dispatch
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])
注册信号函数进入回调函数：
from mypizza import pizza_done（信号函数写在该py文件中）
def callback(sender, **kwargs):
print('xxoo_callback',sender, kwargs)
pizza_done.connect(callback)
信号触发：
def index(request):（这是Django应用里的view视图函数）
# # 自定制操作，触发pizza_done信号
from mypizza import pizza_done
pizza_done.send(sender='seven', toppings=request, size=456)
user_list = models.UserInfo.objects.all().defer('name')
for row in user_list:
print(row.pwd)
return render(request,'index.html',{'user_list':user_list})
二：Django缓存机制（只写以后常用的缓存配置以及应用）
# 配置：（写在配置文件里）
①缓存存储在文件中
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', #引擎
'LOCATION': '/var/tmp/django_cache',
'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】）
}
}
②缓存按照分布式存储在内存中
# 此缓存使用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',
]
}
}
或者
# 此缓存使用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',
]
}
}
应用有三种：
①使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存
MIDDLEWARE = [
'django.middleware.cache.UpdateCacheMiddleware',（该中间件在第一层，用于从后端获取未缓存的数据再存入缓存中）
# 其他中间件...
'django.middleware.cache.FetchFromCacheMiddleware',（该中间件在最后一层，用于查找缓存）
]
CACHE_MIDDLEWARE_ALIAS = ""
CACHE_MIDDLEWARE_SECONDS = ""
CACHE_MIDDLEWARE_KEY_PREFIX = ""
②单独视图缓存
方式一：
from django.views.decorators.cache import cache_page
@cache_page(60 * 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 %}
三：序列化
def get_data(request):（视图函数中的get_data函数）
# 方案一：
####################################################################################################################
#对于方案一，因为使用的是objects.all（对象的操作方法），所以无法连表，也就是说serializer只可以支持单表的序列化
# queryset[UserInfo对象,]
# user_list = models.UserInfo.objects.all()
# from django.core import serializers
# user_list_str = serializers.serialize("json", user_list)
# return HttpResponse(user_list_str)
# 方案二：
###################################################################################################################
#对于方案二，由于使用的是values方法，可以实现连表操作，所以json.dumps,cls=...可以实现跨表查询以及查询结果的序列化，
# 使用起来更加便捷以及实用
# querset=[{},{},{}]
user_list = models.UserInfo.objects.values('name','pwd')
user_list = list(user_list)
#cls是json自带的一个处理类，对于无法处理的datetime类型，可以在继承json.JSONEncoder的基础上自定义default方法。
val = json.dumps(user_list,cls=json.JSONEncoder)
return HttpResponse(val)
四：与性能有关的数据库查询
数据库表关系如下：
from django.db import models
class UserType(models.Model):
caption = models.CharField(max_length=32)
class UserInfo(models.Model):
name = models.CharField(max_length=32)
pwd = models.CharField(max_length=64)
ut = models.ForeignKey(to='UserType',to_field='id',null=True,blank=True)
这里是视图函数：
def index(request):（视图函数中的index函数）
# [obj,obj,obj]
# 查询用户表models.UserInfo.objects.all() 1000
# 把用户表中所有的ut_id拿到, 用户类型ID [1,2,3]
再去拿对应外键的表的所有对象组成的Queryset（这两个步骤对应prefetch_related查询方法）
对于select_related则是根据外键将两张表连接起来进行连表查询
# select * from UsetType where id in [1,2,3]
# user_list = models.UserInfo.objects.all().prefetch_related('ut')
# for row in user_list:
# print(row.name, row.pwd, row.ut.caption)
# for row in user_list:
# print(row.name,row.pwd,row.ut.caption)
#
# # [{},{},{}]
# user_list = models.UserInfo.objects.values('name','pwd','ut__caption')
# for row in user_list:
# print(row['name'],row['pwd'],row['ut__caption'])
# [obj,obj,obj]
# user_list = models.UserInfo.objects.all().only('name')
user_list = models.UserInfo.objects.all().defer('name')
for row in user_list:
print(row.pwd)
return render(request,'index.html',{'user_list':user_list})