Django【进阶篇 】
2024-04-25 22:13:18
Model
到目前为止，当我们的程序涉及到数据库相关操作时，我们一般都会这么搞：
- 创建数据库，设计表结构和字段
- 使用 MySQLdb 来连接数据库，并编写数据访问层代码
- 业务逻辑层去调用数据访问层执行数据库操作
import MySQLdbdef GetList(sql):db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')cursor = db.cursor()cursor.execute(sql)data = cursor.fetchall()db.close()return datadef GetSingle(sql):db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')cursor = db.cursor()cursor.execute(sql)data = cursor.fetchone()db.close()return data
View Code
django为使用一种新的方式，即：关系对象映射（Object Relational Mapping，简称ORM）。
PHP：activerecord
Java：Hibernate
C#：Entity Framework
django中遵循 Code Frist 的原则，即：根据代码中定义的类来自动生成数据库表。
一、创建表
1、基本结构
from django.db import modelsclass userinfo(models.Model):name = models.CharField(max_length=30)email = models.EmailField()memo = models.TextField()
1、models.AutoField 自增列 = int(11)如果没有的话，默认会生成一个名称为 id 的列，如果要显示的自定义一个自增列，必须将给列设置为主键 primary_key=True。
2、models.CharField 字符串字段必须 max_length 参数
3、models.BooleanField 布尔类型=tinyint(1)不能为空，Blank=True
4、models.ComaSeparatedIntegerField 用逗号分割的数字=varchar继承CharField，所以必须 max_lenght 参数
5、models.DateField 日期类型 date对于参数，auto_now = True 则每次更新都会更新这个时间；auto_now_add 则只是第一次创建添加，之后的更新不再改变。
6、models.DateTimeField 日期类型 datetime同DateField的参数
7、models.Decimal 十进制小数类型 = decimal必须指定整数位max_digits和小数位decimal_places
8、models.EmailField 字符串类型（正则表达式邮箱） =varchar对字符串进行正则表达式
9、models.FloatField 浮点类型 = double
10、models.IntegerField 整形
11、models.BigIntegerField 长整形integer_field_ranges = {'SmallIntegerField': (-32768, 32767),'IntegerField': (-2147483648, 2147483647),'BigIntegerField': (-9223372036854775808, 9223372036854775807),'PositiveSmallIntegerField': (0, 32767),'PositiveIntegerField': (0, 2147483647),}
12、models.IPAddressField 字符串类型（ip4正则表达式）
13、models.GenericIPAddressField 字符串类型（ip4和ip6是可选的）参数protocol可以是：both、ipv4、ipv6验证时，会根据设置报错
14、models.NullBooleanField 允许为空的布尔类型
15、models.PositiveIntegerFiel 正Integer
16、models.PositiveSmallIntegerField 正smallInteger
17、models.SlugField 减号、下划线、字母、数字
18、models.SmallIntegerField 数字数据库中的字段有：tinyint、smallint、int、bigint
19、models.TextField 字符串=longtext
20、models.TimeField 时间 HH:MM[:ss[.uuuuuu]]
21、models.URLField 字符串，地址正则表达式
22、models.BinaryField 二进制
23、models.ImageField 图片
24、models.FilePathField 文件更多字段
1、null=True数据库中字段是否可以为空 2、blank=Truedjango的 Admin 中添加数据时是否可允许空值 3、primary_key = False主键，对AutoField设置主键后，就会代替原来的自增 id 列 4、auto_now 和 auto_now_addauto_now 自动创建---无论添加或修改，都是当前操作的时间auto_now_add 自动创建---永远是创建时的时间 5、choices GENDER_CHOICE = ((u'M', u'Male'),(u'F', u'Female'),) gender = models.CharField(max_length=2,choices = GENDER_CHOICE) 6、max_length 7、default 默认值 8、verbose_name Admin中字段的显示名称 9、name|db_column 数据库中的字段名称 10、unique=True 不允许重复 11、db_index = True 数据库索引 12、editable=True 在Admin里是否可编辑 13、error_messages=None 错误提示 14、auto_created=False 自动创建 15、help_text 在Admin中提示帮助信息 16、validators=[] 17、upload-to
更多参数
2、连表结构
- 一对多：models.ForeignKey(其他表)
- 多对多：models.ManyToManyField(其他表)
- 一对一：models.OneToOneField(其他表)
应用场景：
- 一对多：当一张表中创建一行数据时，有一个单选的下拉框（可以被重复选择）
例如：创建用户信息时候，需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。- 多对多：在某表中创建一行数据是，有一个可以多选的下拉框
例如：创建用户信息，需要为用户指定多个爱好- 一对一：在某表中创建一行数据时，有一个单选的下拉框（下拉框中的内容被用过一次就消失了
例如：原有含10列数据的一张表保存相关信息，经过一段时间之后，10列无法满足需求，需要为原来的表再添加5列数据
二、操作表
1、基本操作
# 增#
# models.Tb1.objects.create(c1='xx', c2='oo') 增加一条数据，可以接受字典类型数据 **kwargs# obj = models.Tb1(c1='xx', c2='oo')# obj.save()# 查#
# models.Tb1.objects.get(id=123) # 获取单条数据，不存在则报错（不建议）# models.Tb1.objects.all() # 获取全部# models.Tb1.objects.filter(name='seven') # 获取指定条件的数据# 删#
# models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据# 改# models.Tb1.objects.filter(name='seven').update(gender='0') # 将指定条件的数据更新，均支持 **kwargs# obj = models.Tb1.objects.get(id=1)# obj.c1 = '111'# obj.save() # 修改单条数据基本操作
2、进阶操作（了不起的双下划线）
利用双下划线将字段和对应的操作连接起来
# 获取个数#
# models.Tb1.objects.filter(name='seven').count()# 大于，小于#
# models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值# models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值# models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值# in#
# models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据# models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in# contains#
# models.Tb1.objects.filter(name__contains="ven")# models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感# models.Tb1.objects.exclude(name__icontains="ven")# range#
# models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and# 其他类似#
# startswith，istartswith, endswith, iendswith,# order by#
# models.Tb1.objects.filter(name='seven').order_by('id') # asc# models.Tb1.objects.filter(name='seven').order_by('-id') # desc# limit 、offset#
# models.Tb1.objects.all()[10:20]# group byfrom django.db.models import Count, Min, Max, Sum# models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"进阶操作
3、连表操作（了不起的双下划线）
利用双下划线和 _set 将表之间的操作连接起来
class UserProfile(models.Model):user_info = models.OneToOneField('UserInfo')username = models.CharField(max_length=64)password = models.CharField(max_length=64)def __unicode__(self):return self.usernameclass UserInfo(models.Model):user_type_choice = ((0, u'普通用户'),(1, u'高级用户'),)user_type = models.IntegerField(choices=user_type_choice)name = models.CharField(max_length=32)email = models.CharField(max_length=32)address = models.CharField(max_length=128)def __unicode__(self):return self.nameclass UserGroup(models.Model):caption = models.CharField(max_length=64)user_info = models.ManyToManyField('UserInfo')def __unicode__(self):return self.captionclass Host(models.Model):hostname = models.CharField(max_length=64)ip = models.GenericIPAddressField()user_group = models.ForeignKey('UserGroup')def __unicode__(self):return self.hostname表结构实例
user_info_obj = models.UserInfo.objects.filter(id=1).first()
print user_info_obj.user_type
print user_info_obj.get_user_type_display()
print user_info_obj.userprofile.passworduser_info_obj = models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first()
print user_info_obj.keys()
print user_info_obj.values()一对一操作
类似一对一 1、搜索条件使用 __ 连接 2、获取值时使用 . 连接
一对多
user_info_obj = models.UserInfo.objects.get(name=u'武沛齐') user_info_objs = models.UserInfo.objects.all()group_obj = models.UserGroup.objects.get(caption='CEO') group_objs = models.UserGroup.objects.all()# 添加数据 #group_obj.user_info.add(user_info_obj) #group_obj.user_info.add(*user_info_objs)# 删除数据 #group_obj.user_info.remove(user_info_obj) #group_obj.user_info.remove(*user_info_objs)# 添加数据 #user_info_obj.usergroup_set.add(group_obj) #user_info_obj.usergroup_set.add(*group_objs)# 删除数据 #user_info_obj.usergroup_set.remove(group_obj) #user_info_obj.usergroup_set.remove(*group_objs)# 获取数据 #print group_obj.user_info.all() #print group_obj.user_info.all().filter(id=1)# 获取数据 #print user_info_obj.usergroup_set.all() #print user_info_obj.usergroup_set.all().filter(caption='CEO') #print user_info_obj.usergroup_set.all().filter(caption='DBA')
多对多操作
# F 使用查询条件的值#
# from django.db.models import F# models.Tb1.objects.update(num=F('num')+1)# Q 构建搜索条件from django.db.models import Q# con = Q()#
# q1 = Q()# q1.connector = 'OR'# q1.children.append(('id', 1))# q1.children.append(('id', 10))# q1.children.append(('id', 9))#
# q2 = Q()# q2.connector = 'OR'# q2.children.append(('c1', 1))# q2.children.append(('c1', 10))# q2.children.append(('c1', 9))#
# con.add(q1, 'AND')# con.add(q2, 'AND')#
# models.Tb1.objects.filter(con)#
# from django.db import connection# cursor = connection.cursor()# cursor.execute("""SELECT * from tb where name = %s""", ['Lennon'])# row = cursor.fetchone()其他操作
注意：xx_set中的【_set】是多对多中的固定搭配
扩展：
a、自定义上传
def upload_file(request):if request.method == "POST":obj = request.FILES.get('fafafa')f = open(obj.name, 'wb')for chunk in obj.chunks():f.write(chunk)f.close()return render(request, 'file.html')View Code
b、Form上传文件实例
class FileForm(forms.Form):ExcelFile = forms.FileField()
Form
from django.db import modelsclass UploadFile(models.Model):userid = models.CharField(max_length = 30)file = models.FileField(upload_to = './upload/')date = models.DateTimeField(auto_now_add=True)
Model
def UploadFile(request):uf = AssetForm.FileForm(request.POST,request.FILES)if uf.is_valid():upload = models.UploadFile()upload.userid = 1upload.file = uf.cleaned_data['ExcelFile']upload.save()print upload.file
View
Form
django中的Form一般有两种功能：
- 输入html
- 验证用户输入
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re
from django import forms
from django.core.exceptions import ValidationErrordef mobile_validate(value):mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')if not mobile_re.match(value):raise ValidationError('手机号码格式错误')class PublishForm(forms.Form):user_type_choice = ((0, u'普通用户'),(1, u'高级用户'),)user_type = forms.IntegerField(widget=forms.widgets.Select(choices=user_type_choice,attrs={'class': "form-control"}))title = forms.CharField(max_length=20,min_length=5,error_messages={'required': u'标题不能为空','min_length': u'标题最少为5个字符','max_length': u'标题最多为20个字符'},widget=forms.TextInput(attrs={'class': "form-control",'placeholder': u'标题5-20个字符'}))memo = forms.CharField(required=False,max_length=256,widget=forms.widgets.Textarea(attrs={'class': "form-control no-radius", 'placeholder': u'详细描述', 'rows': 3}))phone = forms.CharField(validators=[mobile_validate, ],error_messages={'required': u'手机不能为空'},widget=forms.TextInput(attrs={'class': "form-control",'placeholder': u'手机号码'}))email = forms.EmailField(required=False,error_messages={'required': u'邮箱不能为空','invalid': u'邮箱格式错误'},widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': u'邮箱'}))Form
def publish(request):ret = {'status': False, 'data': '', 'error': '', 'summary': ''}if request.method == 'POST':request_form = PublishForm(request.POST)if request_form.is_valid():request_dict = request_form.clean()print request_dictret['status'] = Trueelse:error_msg = request_form.errors.as_json()ret['error'] = json.loads(error_msg)return HttpResponse(json.dumps(ret))View
扩展：ModelForm
在使用Model和Form时，都需要对字段进行定义并指定类型，通过ModelForm则可以省去From中字段的定义
class AdminModelForm(forms.ModelForm):class Meta:model = models.Admin#fields = '__all__'fields = ('username', 'email')widgets = {'email' : forms.PasswordInput(attrs={'class':"alex"}),}View Code
跨站请求伪造
一、简介
django为用户实现防止跨站请求伪造的功能，通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。
全局：
中间件 django.middleware.csrf.CsrfViewMiddleware
局部：
- @csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件。
- @csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。
注：from django.views.decorators.csrf import csrf_exempt,csrf_protect
二、应用
1、普通表单
veiw中设置返回值：return render_to_response('Account/Login.html',data,context_instance=RequestContext(request)) 或者return render(request, 'xxx.html', data)html中设置Token:{% csrf_token %}
2、Ajax
对于传统的form，可以通过表单的方式将token再次发送到服务端，而对于ajax的话，使用如下方式。
view.py
from django.template.context import RequestContext
# Create your views here.def test(request):if request.method == 'POST':print request.POSTreturn HttpResponse('ok')return render_to_response('app01/test.html',context_instance=RequestContext(request))
text.html
<!DOCTYPE html>
<html>
<head lang="en"><meta charset="UTF-8"><title></title>
</head>
<body>{% csrf_token %}<input type="button" οnclick="Do();" value="Do it"/><script src="/static/plugin/jquery/jquery-1.8.0.js"></script><script src="/static/plugin/jquery/jquery.cookie.js"></script><script type="text/javascript">var csrftoken = $.cookie('csrftoken');function csrfSafeMethod(method) {// these HTTP methods do not require CSRF protectionreturn (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));}$.ajaxSetup({beforeSend: function(xhr, settings) {if (!csrfSafeMethod(settings.type) && !this.crossDomain) {xhr.setRequestHeader("X-CSRFToken", csrftoken);}}});function Do(){$.ajax({url:"/app01/test/",data:{id:1},type:'POST',success:function(data){console.log(data);}});}</script>
</body>
</html>
更多：https://docs.djangoproject.com/en/dev/ref/csrf/#ajax
Cookie
1、获取Cookie：
request.COOKIES['key']request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)参数：default: 默认值salt: 加密盐max_age: 后台控制过期时间
2、设置Cookie：
rep = HttpResponse(...) 或 rep ＝ render(request, ...)rep.set_cookie(key,value,...)rep.set_signed_cookie(key,value,salt='加密盐',...)参数：key, 键value='', 值max_age=None, 超时时间expires=None, 超时时间(IE requires expires, so set it if hasn't been already.)path='/', Cookie生效的路径，/ 表示根路径，特殊的：跟路径的cookie可以被任何url的页面访问domain=None, Cookie生效的域名secure=False, https传输httponly=False 只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）由于cookie保存在客户端的电脑上，所以，JavaScript和jquery也可以操作cookie。
<script src='/static/js/jquery.cookie.js'></script>
$.cookie("list_pager_num", 30,{ path: '/' });
Session
Django中默认支持Session，其内部提供了5种类型的Session供开发者使用：
- 数据库（默认）
- 缓存
- 文件
- 缓存+数据库
- 加密cookie
1、数据库Session
Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。a. 配置 settings.pySESSION_ENGINE = 'django.contrib.sessions.backends.db' # 引擎（默认）SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径（默认）SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名（默认）SESSION_COOKIE_SECURE = False # 是否Https传输cookie（默认）SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输（默认）SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）（默认）SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期（默认）SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存（默认）b. 使用def index(request):# 获取、设置、删除Session中数据request.session['k1']request.session.get('k1',None)request.session['k1'] = 123request.session.setdefault('k1',123) # 存在则不设置del request.session['k1']# 所有 键、值、键值对request.session.keys()request.session.values()request.session.items()request.session.iterkeys()request.session.itervalues()request.session.iteritems()# 用户session的随机字符串request.session.session_key# 将所有Session失效日期小于当前日期的数据删除request.session.clear_expired()# 检查 用户session的随机字符串 在数据库中是否request.session.exists("session_key")# 删除当前用户的所有Session数据request.session.delete("session_key")...
2、缓存Session
a. 配置 settings.pySESSION_ENGINE = 'django.contrib.sessions.backends.cache' # 引擎SESSION_CACHE_ALIAS = 'default' # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名SESSION_COOKIE_SECURE = False # 是否Https传输cookieSESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存b. 使用同上
3、文件Session
a. 配置 settings.pySESSION_ENGINE = 'django.contrib.sessions.backends.file' # 引擎SESSION_FILE_PATH = None # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir() # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名SESSION_COOKIE_SECURE = False # 是否Https传输cookieSESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存b. 使用同上
4、缓存+数据库Session
数据库用于做持久化，缓存用于提高效率a. 配置 settings.pySESSION_ENGINE = 'django.contrib.sessions.backends.cached_db' # 引擎b. 使用同上
5、加密cookie Session
a. 配置 settings.pySESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies' # 引擎b. 使用同上
更多参考：猛击这里 和 猛击这里
扩展：Session用户验证
def login(func):def wrap(request, *args, **kwargs):# 如果未登陆，跳转到指定页面if request.path == '/test/':return redirect('http://www.baidu.com')return func(request, *args, **kwargs)return wrap
分页
一、Django内置分页
Paginator二、自定义分页
分页功能在每个网站都是必要的，对于分页来说，其实就是根据用户的输入计算出应该在数据库表中的起始位置。
1、设定每页显示数据条数
2、用户输入页码（第一页、第二页...）
3、根据设定的每页显示条数和当前页码，计算出需要取数据表的起始位置
4、在数据表中根据起始位置取值，页面上输出数据
需求又来了，需要在页面上显示分页的页面。如：［上一页］［1］［2］［3］［4］［5］［下一页］
1、设定每页显示数据条数
2、用户输入页码（第一页、第二页...）
3、设定显示多少页号
4、获取当前数据总条数
5、根据设定显示多少页号和数据总条数计算出，总页数
6、根据设定的每页显示条数和当前页码，计算出需要取数据表的起始位置
7、在数据表中根据起始位置取值，页面上输出数据
8、输出分页html，如：［上一页］［1］［2］［3］［4］［5］［下一页］
#!/usr/bin/env python # _*_coding:utf-8_*_ from django.utils.safestring import mark_safeclass PageInfo(object):def __init__(self,current,totalItem,peritems=5):self.__current=currentself.__peritems=peritemsself.__totalItem=totalItemdef From(self):return (self.__current-1)*self.__peritemsdef To(self):return self.__current*self.__peritemsdef TotalPage(self): #总页数result=divmod(self.__totalItem,self.__peritems)if result[1]==0:return result[0]else:return result[0]+1def Custompager(baseurl,currentPage,totalpage): #基础页，当前页，总页数perPager=11#总页数<11#0 -- totalpage#总页数>11#当前页大于5 currentPage-5 -- currentPage+5#currentPage+5是否超过总页数,超过总页数，end就是总页数#当前页小于5 0 -- 11begin=0end=0if totalpage <= 11:begin=0end=totalpageelse:if currentPage>5:begin=currentPage-5end=currentPage+5if end > totalpage:end=totalpageelse:begin=0end=11pager_list=[]if currentPage<=1:first="<a href=''>首页</a>"else:first="<a href='%s%d'>首页</a>" % (baseurl,1)pager_list.append(first)if currentPage<=1:prev="<a href=''>上一页</a>"else:prev="<a href='%s%d'>上一页</a>" % (baseurl,currentPage-1)pager_list.append(prev)for i in range(begin+1,end+1):if i == currentPage:temp="<a href='%s%d' class='selected'>%d</a>" % (baseurl,i,i)else:temp="<a href='%s%d'>%d</a>" % (baseurl,i,i)pager_list.append(temp)if currentPage>=totalpage:next="<a href='#'>下一页</a>"else:next="<a href='%s%d'>下一页</a>" % (baseurl,currentPage+1)pager_list.append(next)if currentPage>=totalpage:last="<a href=''>末页</a>"else:last="<a href='%s%d'>末页</a>" % (baseurl,totalpage)pager_list.append(last)result=''.join(pager_list)return mark_safe(result) #把字符串转成html语言
分页实例
总结，分页时需要做三件事：
- 创建处理分页数据的类
- 根据分页数据获取数据
- 输出分页HTML，即：［上一页］［1］［2］［3］［4］［5］［下一页］
缓存
由于Django是动态网站，所有每次请求均会去数据进行相应的操作，当程序访问量大时，耗时必然会更加明显，最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者memcache中，5分钟内再有人来访问时，则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回。
Django中提供了6种缓存方式：
- 开发调试
- 内存
- 文件
- 数据库
- Memcache缓存（python-memcached模块）
- Memcache缓存（pylibmc模块）
1、配置
a、开发调试
# 此为开始调试用，实际内部不做任何操作# 配置：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】）
}}# 自定义keydef default_key_func(key, key_prefix, version):"""Default function to generate keys.Constructs the key used by all other methods. By default it prependsthe `key_prefix'. KEY_FUNCTION can be used to specify an alternatefunction 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_funcelse:return import_string(key_func)return default_key_funcView Code
b、内存
# 此缓存将内容保存至内存的变量中# 配置：CACHES = {'default': {'BACKEND': 'django.core.cache.backends.locmem.LocMemCache','LOCATION': 'unique-snowflake',}}# 注：其他配置同开发调试版本View Code
c、文件
# 此缓存将内容保存至文件# 配置：
CACHES = {'default': {'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache','LOCATION': '/var/tmp/django_cache',}}# 注：其他配置同开发调试版本View Code
d、数据库
# 此缓存将内容保存至数据库# 配置：CACHES = {'default': {'BACKEND': 'django.core.cache.backends.db.DatabaseCache','LOCATION': 'my_cache_table', # 数据库表
}}# 注：执行创建表命令 python manage.py createcachetableView Code
e、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',]}}View Code
f、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',]}}View Code
2、应用
a. 全站使用
使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存MIDDLEWARE = ['django.middleware.cache.UpdateCacheMiddleware',# 其他中间件...'django.middleware.cache.FetchFromCacheMiddleware',]CACHE_MIDDLEWARE_ALIAS = ""CACHE_MIDDLEWARE_SECONDS = ""CACHE_MIDDLEWARE_KEY_PREFIX = ""
View Code
b. 单独视图缓存
方式一：from django.views.decorators.cache import cache_page@cache_page(60 * 15)def my_view(request):...方式二：from django.views.decorators.cache import cache_pageurlpatterns = [url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),]View Code
c、局部视图使用
a. 引入TemplateTag{% load cache %}b. 使用缓存{% cache 5000 缓存key %}缓存内容{% endcache %}View Code
更多：猛击这里
序列化
关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户，特别的Ajax请求一般返回的为Json格式。
1、serializers
from django.core import serializersret = models.BookType.objects.all()data = serializers.serialize("json", ret)
2、json.dumps
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 class JsonCustomEncoder(json.JSONEncoder): def default(self, field): if isinstance(field, datetime): return o.strftime('%Y-%m-%d %H:%M:%S') elif isinstance(field, date): return o.strftime('%Y-%m-%d') else: return json.JSONEncoder.default(self, field) # ds = json.dumps(d, cls=JsonCustomEncoder)
信号
Django中提供了“信号调度”，用于在框架执行操作时解耦。通俗来讲，就是一些动作发生的时候，信号允许特定的发送者去提醒一些接受者。
1、Django内置信号
Model signalspre_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 signalspre_migrate # 执行migrate命令前，自动触发post_migrate # 执行migrate命令后，自动触发Request/response signalsrequest_started # 请求到来前，自动触发request_finished # 请求结束后，自动触发got_request_exception # 请求异常后，自动触发Test signalssetting_changed # 使用test测试修改配置文件时，自动触发template_rendered # 使用test测试渲染模板时，自动触发Database Wrappersconnection_created # 创建数据库连接时，自动触发
对于Django内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数：
from django.core.signals import request_finishedfrom django.core.signals import request_startedfrom django.core.signals import got_request_exceptionfrom django.db.models.signals import class_preparedfrom django.db.models.signals import pre_init, post_initfrom django.db.models.signals import pre_save, post_savefrom django.db.models.signals import pre_delete, post_deletefrom django.db.models.signals import m2m_changedfrom django.db.models.signals import pre_migrate, post_migratefrom django.test.signals import setting_changedfrom django.test.signals import template_renderedfrom django.db.backends.signals import connection_createddef callback(sender, **kwargs):print("xxoo_callback")print(sender,kwargs)xxoo.connect(callback)# xxoo指上述导入的内容View Code
from django.core.signals import request_finished
from django.dispatch import receiver@receiver(request_finished)
def my_callback(sender, **kwargs):print("Request finished!")View Code
2、自定义信号
a. 定义信号
import django.dispatchpizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])b. 注册信号
def callback(sender, **kwargs):print("callback")print(sender,kwargs)pizza_done.connect(callback)
c. 触发信号
from 路径 import pizza_donepizza_done.send(sender='seven',toppings=123, size=456)
由于内置信号的触发者已经集成到Django中，所以其会自动调用，而对于自定义信号则需要开发者在任意位置触发。
更多：猛击这里
转载于:https://www.cnblogs.com/wanghzh/p/5991911.html
Django【进阶篇 】相关推荐
- Python之路【第十六篇续】Django进阶篇
Django请求生命周期 首先:对于所有的web框架来说本质就是一个socket服务端,浏览器是socket客户端 路由系统 在Django的urls中我们可以根据一个URL对应一个函数名来定义路由规 ...
- Python学习-day20 django进阶篇
Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行 ...
- Django 进阶篇之 CSRF,COOIKE,SESSION
1.CSRF(Cross Site Request Forgery, 跨站域请求伪造) CSRF 背景与介绍 CSRF(Cross Site Request Forgery, 跨站域请求伪造)是一种网 ...
- django 菜鸟篇+进阶篇
django自带web server, 故django开发的项目可以独立的运行,也可以安置在apache(+mod_python)下运行 django wiki django主页 django源码和a ...
- python 面向对象（进阶篇）
上一篇<Python 面向对象(初级篇)>文章介绍了面向对象基本知识: 面向对象是一种编程方式,此编程方式的实现是基于对 类 和 对象 的使用 类 是一个模板,模板中包装了多个" ...
- django进阶07用户模块与权限系统
原创:django进阶07用户模块与权限系统 Django默认提供了用户权限管理模块auth, 1 2 3 user表,User是auth模块中维护用户信息的表,在数据库中该表被命名为auth_use ...
- Django进阶教程
Django进阶教程 Queryset特性及高级查询技巧 什么是QuerySet QuerySet是Django提供的强大的数据库接口(API).正是因为通过它,我们可以使用filter, exclu ...
- Django进阶: 如何自定义manage.py管理命令
每次在启动Django服务之前,我们都会在终端运行python manage.py xxx的管理命令.其实我们还可以自定义管理命令,这对于执行独立的脚本或任务非常有用,比如清除缓存.导出用户邮件清单或 ...
- 达内 python 是一种更纯粹的面向对象_python 面向对象（进阶篇）-转发自武SIR
面向对象是一种编程方式,此编程方式的实现是基于对 类 和 对象 的使用 类 是一个模板,模板中包装了多个"函数"供使用(可以讲多函数中公用的变量封装到对象中) 对象,根据模板创建的 ...
- Enterprise Library Step By Step系列（十二）：异常处理应用程序块——进阶篇
一．把异常信息Logging到数据库 在日志和监测应用程序块中,有朋友提意见说希望能够把异常信息Logging到数据库中,在这里介绍一下具体的实现方法. 1．创建相关的数据库环境: 我们可以用日志和监 ...
最新文章
- 网络连接、路由配置等
- 疫情之下的网站优化该怎样进行？
- 【译】Android中的安全数据— Android中的加密（第2部分）
- 网际协议：动态主机配置协议（DHCP）和NAT
- LVS之VS/NAT搭建web集群实战！！！
- 面试提问vue中v-if与v-show的区别以及使用场景
- 北大博士的论文发表经验：快写、细改、慢投
- 小米10至尊纪念版今日开卖：120hz高刷+120W秒充
- java输出5行星型三角_JAVA图形小动画之简单行星运动
- Springboot属性文件application.properties配置大全，版本:1.5.4
- pp助手苹果版_PP助手下线iOS版，曾首发iOS 9完美越狱工具，再见~
- Hybrid App的架构
- 器件选型-OLED液晶显示原理和选型
- vue实时获取当前时间
- 前端基础入门课程推荐
- 电源模块DC-DC隔离型测试方法
- ESMap三维地图开发流程
- 2020-12-19 nn.CrossEntropyLoss()
- 数据分析——员工离职预测
- ubuntu——sudo权限问题（sudo:/etc/sudoers is world writable sudo:no valid sudoers sources found,quitting..）