django 补充篇
from验证
django中的Form一般有两种功能：
- 输入html-----------不能你自己写一些标签，而帮你自动生成
- 验证用户输入-------将用户验证信息保存起来，可以传到前端
# !/usr/bin/env python # -*- coding:utf-8 -*- from django.shortcuts import render,HttpResponse from app01.forms import Form1 from django.forms.utils import ErrorDict def form1(request): if request.method == 'POST': #判断是否使用了POST方法 # 获取请求内容，做验证 f = Form1(request.POST) #如果是使用了POST方法，即就绑定到f变量，Form1是forms.py上定义好的类字段，参数可以获取错误信息 if f.is_valid(): #判断表单上传进来的数据是否一致， 一致就执行下面的语句 print(f.cleaned_data) #输出正确答案 else: # 如果表单上传进来的数据不一致 for k in f.errors: # 循环所有的错误信息 print(k) # 输出错误信息 return render(request,'account/form1.html', {'error': f.errors, 'form': f}) # 进行渲染在前端显示 else: # 如果不是post 方法 f = Form1() # 绑定 f 变量 为空值 不可获取信息 return render(request, 'account/form1.html', {'form': f}) # 进行渲染在前端显示
#!/usr/bin/env python # -*- coding:utf-8 -*- from django import forms from app01 import models class Form1(forms.Form): user = forms.CharField( # 自定义错误信息 widget=forms.TextInput(attrs={'class': 'c1'}), #自定义标签内容 error_messages={'required': '用户名不能为空'},) pwd = forms.CharField(max_length=4,min_length=2, error_messages={'required': '密码不能为空'},) email = forms.EmailField(error_messages={'required': '邮箱不能为空', 'invalid': '邮箱格式错误'}) memo = forms.CharField( widget=forms.Textarea() #设置文本框 ) # user_type_choice = ( # (0, '普通用户'), # (1, '高级用户'), # ) user_type_choice = models.BookType.objects.values_list('id','caption') #连接数据库 book_type = forms.CharField( # 获取数据库内容 widget=forms.widgets.Select(choices=user_type_choice,attrs={'class': "form-control"})) #绑定在页面显示 只能获取一次数据 def __init__(self,*args, **kwargs): # 每次创建都要执行一次 super(Form1, self).__init__(*args, **kwargs) # 继承父类函数执行完 在执行父类的init方法 self.fields['book_type'] = forms.CharField( #继承父类 重新定义字段 widget=forms.widgets.Select(choices=models.BookType.objects.values_list('id','caption'),attrs={'class': "form-control"}))
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> <style> .input-group{ position: relative; padding: 20px; width: 250px; } .input-group input{ width: 200px; display: inline-block; } .input-group span{ display: inline-block; position: absolute; height: 12px; font-size: 8px; border: 1px solid darkred; background-color: coral; color: white; top: 41px; left: 20px; width: 202px; } </style> </head> <body> <form action="/form1/" method="POST"> <div class="input-group"> {{ form.user }} {% if error.user.0 %} <span>{{ error.user.0 }}</span> {% endif %} </div> <div class="input-group"> {{ form.pwd }} {% if error.pwd.0 %} <span>{{ error.pwd.0 }}</span> {% endif %} </div> <div class="input-group"> {{ form.email }} {% if error.email.0 %} <span>{{ error.email.0 }}</span> {% endif %} </div> <div class="input-group"> {{ form.memo }} {% if error.memo.0 %} <span>{{ error.memo.0 }}</span> {% endif %} </div> <div class="input-group"> {{ form.book_type }} {% if error.book_type.0 %} <span>{{ error.book_type.0 }}</span> {% endif %} </div> <div> <input type="submit" value="提交"/> </div> </form> </body> </html>
3、定制From表单
（1）设置报错信息，添加属性样式
class UserForm(forms.Form):
host = forms.CharField(error_messages={"required":"主机不能为空"},#设置显示的错误信息
widget=forms.TextInput(attrs={"class":"form-control",
"placeholder": "主机"})#添加属性和样式
)
port = forms.CharField()
email = forms.EmailField()
mobile = forms.CharField()
（2）多行文本框
#多行文本框，备注
memo = forms.CharField(required=False, #可以为空
widget=forms.Textarea(attrs={"class":"form-control",
"placeholder": "备注"})#添加属性和样式
)
（3）下拉框
#下拉框
user_type_choice=(
(0,"普通用户"),
(1,"高级用户")
)
user_type = forms.IntegerField(widget=forms.widgets.Select(choices=user_type_choice,
attrs={'class': "form-control"}))
（4）动态生成select标签
文件中取数据
#动态下拉框
u_type = forms.IntegerField(widget=forms.widgets.Select( attrs={'class': "form-control"}))
def __init__(self, *args, **kwargs):
super(UserForm, self).__init__(*args, **kwargs)
import json
f=open("u_type_db")
data = f.read()
data_tuple = json.loads(data)
self.fields['u_type'].widget.choices = data_tuple
user_type_choice = (
(0, "普通用户"),
(1, "高级用户")
)
数据库中取数据
最开始的form就是数据库中去数据，而且在数据库修改时，下拉框的内容不需要刷新页面也可以生成。
def __init__(self, *args, **kwargs):
super(UserForm, self).__init__(*args, **kwargs)
data_tuple=models.UserInfo.objects.all().values_list('id','username')
self.fields['u_type'].widget.choices = data_tuple
下拉框，参数choices=xxx是固定格式，参数a的形式必须写成下面这种形式，当我们往数据库中添加数据的时候，在不从新启动服务的情况下，下拉框中的数据不会更新，因为类下的静态字段只创建一次，创建对象只执行__init__方法，所以必须在创建对象执行__init__方法的时候再一次执行一下静态字段就可以达到更新的目的
扩展：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"}),
}
自定义错误验证：
#!/usr/bin/env/python
# -*- coding:utf-8 -*-
from django import forms
import re
from django.core.exceptions import ValidationError
def 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 Form1(forms.Form): #required=False 表示可以为空
user = forms.CharField(
error_messages={'required':'用户名不能为空'}
)
pwd = forms.CharField(max_length=4,min_length=2,error_messages={'required':'密码不能为空'}) #最大长度 和最小限制
email = forms.CharField(error_messages={'required':'邮箱不能为空'})
phone = forms.CharField(
validators=[mobile_validate],
error_messages={'required':'手机号不能为空','invalid':'邮箱格式错误'})
#!/usr/bin/env/python
# -*- coding:utf-8 -*-
from django.shortcuts import render, HttpResponse
from app01.forms import Form1
# Create your views here.
def form1(request):
if request.method == 'POST': # 内部默认执行了upper方法
request.POST.get('user', None) # 用POST.get获取数据
request.POST.get('pwd', None)
request.POST.get('email', None)
request.POST.get('phone', None)
f = Form1(request.POST) # 获取请求内容，在Form1中进行验证
if f.is_valid(): #判断 验证请求的内容是否Form1验证和一致
print(f.cleaned_data)
else:
print(f.errors.get('user',None)) #如果不一致返回错误信息
print(f.errors.get('pwd',None)) #如果不一致返回错误信息
print(f.errors.get('email',None)) #如果不一致返回错误信息
print(f.errors.get('phone',None)) #如果不一致返回错误信息
return render(request, 'account/form1.html',{'error':f.errors})
return render(request, 'account/form1.html')
文件上传:
a、自定义上传
def upload_file(request):
if request.method == 'POST':
obj = request.FILES.get('fafafa')
f = open('static/img/%s'%obj.name, 'wb')
for chunk in obj.chunks():
f.write(chunk)
f.close()
return render(request,'file.html')
----------------------------------------------------------------
<body>
<form action="/file/" method="POST" enctype="multipart/form-data">
{% csrf_token %}
<input type="file" name="fafafa"/>
<input type="submit" name="action" value="提交"/>
</form>
</body>
</html>
b、Form上传文件实例
class FileForm(forms.Form):
ExcelFile = forms.FileField()
from django.db import models class UploadFile(models.Model): userid = models.CharField(max_length = 30) file = models.FileField(upload_to = './upload/') date = models.DateTimeField(auto_now_add=True)
def UploadFile(request): uf = AssetForm.FileForm(request.POST,request.FILES) if uf.is_valid(): upload = models.UploadFile() upload.userid = 1 upload.file = uf.cleaned_data['ExcelFile'] upload.save() print upload.file
模板
1、模版的执行
模版的创建过程，对于模版，其实就是读取模版（其中嵌套着模版标签），然后将 Model 中获取的数据插入到模版中，最后将信息返回给用户
def current_datetime(request):
now = datetime.datetime.now()
html = "<html><body>It is now %s.</body></html>" % now
return HttpResponse(html)
from django import template
t = template.Template('My name is {{ name }}.')
c = template.Context({'name': 'Adrian'})
print t.render(c)
import datetime
from django import template
import DjangoDemo.settings
now = datetime.datetime.now()
fp = open(settings.BASE_DIR+'/templates/Home/Index.html')
t = template.Template(fp.read())
fp.close()
html = t.render(template.Context({'current_date': now}))
return HttpResponse(html)
from django.template.loader import get_template
from django.template import Context
from django.http import HttpResponse
import datetime
def current_datetime(request):
now = datetime.datetime.now()
t = get_template('current_datetime.html')
html = t.render(Context({'current_date': now}))
return HttpResponse(html)
return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))
2、模版语言 模板中也有自己的语言，该语言可以实现数据展示
django 模板语言就基本语法
from django.template.loader import get_template
# 使用函数 django.template.loader.get_template()模块
from django.template import Context
注释：
{% comment %}
hello !word!!这里是注释内容
{% endcomment %}
小例子
name = "alex"
t = get_template('index.html') # 该 get_template() 函数以模板名称为参数，在文件系统中找出模块的位置，打开文件并返回一个编译好的 Template 对象。
heml = t.render(Context(locals())) # 接收变量context， 将模板中的标签或变量被context值替换 #locals它返回的字典对所有局部变量的名称与值进行映射
return HttpResponse(html) # 将渲染后的模板返回
temp =
{'name':'alex'},
{'name':'alex2'},
{'name':'alex3'},
{'name':'alex4'},
{'name':'alex5'},
]
return render(req, 'index.html', {"obj":temp}) #通过大括号定义temp变量 渲染到前端并显示
if/else
{% if %}标签计算一个变量值，如果是“true”，即它存在、不为空并且不是false的boolean值系统则会显示{% if %}和{% endif %}间的所有内容：
并且 {% if %}标签接受and，or或者not来测试多个变量值或者否定一个给定的变量
{% if obj.name == 'alex2' %} #判断条件
<li style="color: aqua">{{ obj.name}}</li>
{% else %}
<li>{{ obj.name}}</li>
{% endif %}
没有{% elif %}标签，使用嵌套的{% if %}标签可以做到同样的事情
- {% if athlete_list %}
- <p>Here are the athletes: {{ athlete_list }}.</p>
- {% else %}
- <p>No athletes are available.</p>
- {% if coach_list %}
- <p>Here are the coaches: {{ coach_list }}.</p>
- {% endif %}
- {% endif %}
确认使用{% endif %}来关闭{% if %}标签，否则Django触发TemplateSyntaxError
循环
{% for %}标签允许你按顺序遍历一个序列中的各个元素
Python的for语句语法为for X in Y，X是用来遍历Y的变量
每次循环模板系统都会渲染{% for %}和{% endfor %}之间的所有内容
{% for objin temp %} #循环
<h1>{{ obj.name}}</h1>
{% endfor %}
循环语句 使用empty关键字来进行为空时候的跳转。
{% for item in date_all %}
<li>{{ item.name }}</li>
{% empty %}
<li>你输入的为空奥</li>
{% endfor %}
循环元素
{% for %}标签内置了一个forloop模板变量，这个变量含有一些属性可以提供给你一些关于循环的信息
1，forloop.counter表示循环的次数，它从1开始计数，第一次循环设为1
2，forloop.counter0 循环次数 从第 0 个位置开始计数
{% for temp in temp %}
{% if forloop.counter %} #循环取值 默认从 1 开始计数
{# {% if forloop.counter0 == 4 %}#} #循环取值从第0个位置取
<li style="color: rebeccapurple">{{ temp.name}}</li>
{% else %}
<li>{{ temp.name}}</li>
{% endif %}
{% endfor %}
forloop.first当第一次循环时值为True，在特别情况下很有用
forloop.last当最后一次循环时值为True
<ul>
{% for temp in temp %}
{% if forloop.first %}
### {% if forloop.last %}
<li style="color: red ">{% else %}<li>
{% endif %}
{{ temp.name }}
{% endfor %}
</ul>
过滤器:
使用(|)管道来申请一个过滤器
模板过滤器是变量显示前转换它们的值的方式
{{ item.event_start|date:"Y-m-d H:i:s"}}
{{ name|truncatewords:"30" }} 前30个字，过滤器参数一直使用双引号
{{ name|lower }} #将文本转为小写
过滤器可以串成链，即一个过滤器的结果可以传向下一个
下面是escape文本内容然后把换行转换成p标签的习惯用法
{{ temp.name|escape|linebreaks}}
继承：
{% include %}的使用
如： index.html 中 写内容
{% include 'index.html' %},用来引入其它模板的内容，减少重复的模板代码
return render_to_response('index.html',{'blog_list':'text.html'})
{% include blog_list %} 可以传来变量名
母版：
index.html
{% block content %} ##母板内容，
{% endblock %}
bolck.html
{% extends 'index.html' %}子版调用得导入母板,模板继承
{% block content %}
##子版内容
{% endblock %}
3、自定义simple_tag
a、在app中创建templatetags模块
b、创建任意 .py 文件，如：xx.py
#!/usr/bin/env python
#coding:utf-8
from django import template
from django.utils.safestring import mark_safe
from django.template.base import resolve_variable, Node, TemplateSyntaxError
register = template.Library()
@register.simple_tag
def my_simple_time(v1,v2,v3):
return v1 + v2 + v3
@register.simple_tag
def my_input(id,arg):
result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
return mark_safe(result)
c、在使用自定义simple_tag的html文件中导入之前创建的 xx.py 文件名
{% load xx %}
d、使用simple_tag
{% my_simple_time 1 2 3%}
{% my_input 'id_username' 'hide'%}
e、在settings中配置当前app，不然django无法找到自定义的simple_tag
INSTALLED_APPS = (
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'app01',
)
分享一个实例：
import json from django.shortcuts import render,HttpResponse from app01 import models # Create your views here. def index(request): # models.BxSlider.objects.filter(status=1) 对象 queryset_dict = models.BxSlider.objects.filter(status=1).values('img','href','name') # queryset_list = models.BxSlider.objects.filter(status=1).values_list('img','href','name') return render(request,'index.html', {'queryset_dict': queryset_dict}) def student(request): # student # studentDetail detail_list = models.StudentDetail.objects.filter(student__status=1).values('letter_of_thanks',"student__name","student__salary",'student__company', 'student__pic') print(detail_list) return render(request,'student.html', {'detail_list': detail_list}) def video(request,*args,**kwargs): print(kwargs) print(request.path) direction_list = models.Direction.objects.all().values('id','name') class_list = models.Classification.objects.all().values('id', 'name') # level_list = models.Video.level_choice ret = map(lambda x:{"id": x[0], 'name': x[1]}, models.Video.level_choice) level_list = list(ret) return render(request, 'video.html', {'direction_list': direction_list, 'class_list': class_list, 'level_list': level_list, 'current_url': request.path})
#!/usr/bin/env python # -*- coding:utf-8 -*- from django import template from django.utils.safestring import mark_safe from django.template.base import Node, TemplateSyntaxError register = template.Library() @register.simple_tag def my_simple_time(v1,v2,v3): return v1 + v2 + v3 @register.simple_tag def detail1(item,counter,allcount,remainder): temp = """ <div style="width: 245px;"> <img style="width: 245px;height: 200px;" src="/%s"> <p>%s</p> <p>%s</p> <p>%s</p> </div> """ if counter%allcount == remainder: temp = temp %(item['student__pic'], item['student__name'], item['student__salary'], item['letter_of_thanks']) return mark_safe(temp) else: return "" # @register.simple_tag # def detail2(counter,allcount,remainder): # """ # 查看余数是否等于remainder # :param counter: # :param allcount: # :param remainder: # :return: # """ # if counter%allcount == remainder: # return True # return False @register.filter def detail3(value,arg): """ 查看余数是否等于remainder arg="1,2" :param counter: :param allcount: :param remainder: :return: """ allcount, remainder = arg.split(',') allcount = int(allcount) remainder = int(remainder) if value%allcount == remainder: return True return False @register.simple_tag def action1(current_url, item): # videos-0-0-1.html # item: id name url_part_list = current_url.split('-') url_part_list[1] = str(item['id']) print(url_part_list) ur_str = '-'.join(url_part_list) temp = "<a href='%s'>%s</a>" %(ur_str, item['name']) return mark_safe(temp) @register.simple_tag def action2(current_url, item): # videos-0-0-1.html # item: id name url_part_list = current_url.split('-') url_part_list[2] = str(item['id']) print(url_part_list) ur_str = '-'.join(url_part_list) temp = "<a href='%s'>%s</a>" %(ur_str, item['name']) return mark_safe(temp) @register.simple_tag def action3(current_url, item): # videos-0-0-1.html # item: id name url_part_list = current_url.split('-') url_part_list[3] = str(item['id']) + '.html' print(url_part_list) ur_str = '-'.join(url_part_list) temp = "<a href='%s'>%s</a>" %(ur_str, item['name']) return mark_safe(temp)
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> <link rel="stylesheet" href="/static/plugins/bxSlider/jquery.bxslider.css" /> </head> <body> <ul class="bxslider"> {% for item in queryset_dict %} <li> <a href="{{ item.href }}"> <img src="/{{ item.img }}" alt="{{ item.name }}" /> </a> </li> {% endfor %} </ul> <script src="/static/js/jquery-2.1.4.min.js"></script> <script src="/static/plugins/bxSlider/jquery.bxslider.min.js"></script> <script> $(function () { $('.bxslider').bxSlider({ auto: true }); }) </script> </body> </html>
{% load xx %}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<div>
</div>
<style>
.clearfix:after{
content: '.';
visibility: hidden;
height: 0;
clear: both;
display: block;
}
</style>
<div style="margin: 0 auto;width: 980px;" class="clearfix">
<div style="width: 245px;float: left">
{% for item in detail_list %}
{% detail1 item forloop.counter 4 1 %}
{% endfor %}
</div>
<div style="width: 245px;float: left">
{% for item in detail_list %}
{% detail1 item forloop.counter 4 2 %}
{% endfor %}
</div>
<div style="width: 245px;float: left">
{% for item in detail_list %}
{% detail1 item forloop.counter 4 3 %}
{% endfor %}
</div>
<div style="width: 245px;float: left">
{% for item in detail_list %}
{% if forloop.counter|detail3:"4,0" %}
<div style="width: 245px;">
<img style="width: 245px;height: 200px;" src="/{{ item.student__pic }}">
<p>{{ item.student__name }}</p>
<p>{{ item.student__salary }}</p>
<p>{{ item.letter_of_thanks }}</p>
</div>
{% endif %}
{% endfor %}
</div>
</div>
</body>
</html>
{% load xx %}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
a{
display: inline-block;
padding: 8px;
}
</style>
</head>
<body>
<h3>选择：</h3>
<div>
<a>全部</a>：
{% for item in direction_list %}
{% action1 current_url item %}
{% endfor %}
</div>
<div>
<a>全部</a>：
{% for item in class_list %}
{% action2 current_url item %}
{% endfor %}
</div>
<div>
<a>全部</a>：
{% for item in level_list %}
{% action3 current_url item %}
{% endfor %}
</div>
<hr />
<div>
</div>
<h3>视频：</h3>
<hr />
</body>
</html>
cookie
获取cookie：
request.COOKIES['key']
request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
参数：
default: 默认值
salt: 加密盐
max_age: 后台控制过期时间
设置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
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from django.shortcuts import render,HttpResponse
def form1(request):
print(request.COOKIES)
print(request.COOKIES['k9']) #如果没有的话会报错
print(request.get_signed_cookie('k3',salt='alex',default=None)) #获取的时候也得加salt
rep = HttpResponse('GHHG')
rep.set_cookie('k1',1213)
rep.set_signed_cookie('k3',456,salt='alex',)
return rep
max_age=None, 后面直接写时间就可以了
expires=None ， 必须写获取当前时间，再设置以当前时间为准，多长时间后失效 expires= time.time() + 10
由于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.py
SESSION_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'] = 123
request.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.py
SESSION_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传输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. 使用
同上
3、文件Session
a. 配置 settings.py
SESSION_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传输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. 使用
同上
4、缓存+数据库Session
数据库用于做持久化，缓存用于提高效率
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db' # 引擎
b. 使用
同上
5、加密cookie Session
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies' # 引擎
b. 使用
同上
扩展：Session用户验证(装饰器)
def login(func):
def wrap(request, *args, **kwargs):
# 如果未登陆，跳转到指定页面
if request.session['is_login']:
return redirect('http://www.baidu.com')
return func(request, *args, **kwargs)
return wrap
return HttpResponse('GHHG')
跨站请求伪造（csrf）
一、简介
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.POST
return 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" onclick="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 protection
return (/^(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>
中间件
django 中的中间件（middleware），在django中，中间件其实就是一个类，在请求到来和结束后，django会根据自己的规则在合适的时机执行中间件中相应的方法。
MIDDLEWARE = [
# 'zhongjianjia.test.test1Middleware',
# 'zhongjianjia.test.test2Middleware',
# 'zhongjianjia.test.test3Middleware',
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
中间件中可以定义四个方法，分别是：
process_request(self,request) process_view(self, request, callback, callback_args, callback_kwargs) process_template_response(self,request,response) process_exception(self, request, exception) process_response(self, request, response)
以上方法的返回值可以是None和HttpResonse对象，如果是None，则继续按照django定义的规则向下执行，如果是HttpResonse对象，则直接将该对象返回给用户
djanjo 中间件版本差异报错处理：
1.9.x版本以下djanjo中间件定义规则
class CommonMiddleware(object):
def process_request(self, request):
return None
def process_response(self, request, response):
return response
最新的1.10.x版本djanjo中间件定义规则----------不是执行的类下的方法，而是执行MiddlewareMixin对象的__call__方法（方法中调用，process_request等方法）
from djanjo.utils.deprecation import MiddlewareMixin
class CommonMiddleware(MiddlewareMixin):
def process_request(self, request):
return None
def process_response(self, request, response):
return response
下面的方法就可以让 中间件 兼容 Django新版本和旧版本------------上面俩种的合并
__call__ 方法会先调用 self.process_request(request)，接着执行 self.get_response(request) 然后调用 self.process_response(request, response)
try:
from django.utils.deprecation import MiddlewareMixin # Django 1.10.x
except ImportError:
MiddlewareMixin = object # Django 1.4.x - Django 1.9.x
class SimpleMiddleware(MiddlewareMixin):
def process_request(self, request):
pass
def process_response(request, response):
pass
新版本中 django.utils.deprecation.MiddlewareMixin 的 源代码 如下：
class MiddlewareMixin(object):
def __init__(self, get_response=None):
self.get_response = get_response
super(MiddlewareMixin, self).__init__()
def __call__(self, request):
response = None
if hasattr(self, 'process_request'):
response = self.process_request(request)
if not response:
response = self.get_response(request)
if hasattr(self, 'process_response'):
response = self.process_response(request, response)
return response
中间件生命周期（1.9.x版本以下）：
1，正常情况（有俩个中间件的情况）
process_request1---->process_request2---->process_view1------process_view2----->url---->views---> process_response2----->process_response1
2，在任意一个process_request中只要有return直接跳到process_response
process_request1---->process_request2----> process_response2----->process_response1
3，如果返回值中有render的话走process_template_response
process_request1---->process_request2---->process_view1------process_view2----->url---->views--->process_template_response2----> process_template_response1--->process_response2----->process_response1
4，views中出现错误的时候走process_exceptionprocess_response
process_request1---->process_request2---->process_view1--->process_view2----->url---->views---> process_exceptionprocess_response2--->
process_exceptionprocess_response1
中间件生命周期（1.10.x版本及以上）：
和1.9.x版本以下相比，不同点在于，当request中出现return的时候，直接到最外层的response，而不经过里层的response
自定义中间件
1、创建中间件类
from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse
class test1Middleware(MiddlewareMixin):
def process_request(self, request):
print(1111111111)
def process_response(self, request,response):
print('response 11111')
return response
class test2Middleware(MiddlewareMixin):
def process_repuest(self,request):
return HttpResponse('SB')
class test3Middleware(MiddlewareMixin):
def process_request(self,request):
print(33333333333)
def process_response(self,request ,response ):
print('response 33333')
return response
2、注册中间件
MIDDLEWARE = [
# 'zhongjianjia.test.test1Middleware',
# 'zhongjianjia.test.test2Middleware',
# 'zhongjianjia.test.test3Middleware',
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
缓存：
由于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】） } } # 自定义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
b、内存
# 此缓存将内容保存至内存的变量中 # 配置： CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'LOCATION': 'unique-snowflake', } } # 注：其他配置同开发调试版本
c、文件
# 此缓存将内容保存至文件 # 配置： CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', 'LOCATION': '/var/tmp/django_cache', } } # 注：其他配置同开发调试版本
d、数据库
此缓存将内容保存至数据库 # 配置： CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.db.DatabaseCache', 'LOCATION': 'my_cache_table', # 数据库表 } } # 注：执行创建表命令 python manage.py createcachetable
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', ] } }
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', ] } }
2、应用
a. 全站使用
使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存 MIDDLEWARE = [ 'django.middleware.cache.UpdateCacheMiddleware', # 其他中间件... 'django.middleware.cache.FetchFromCacheMiddleware', ] CACHE_MIDDLEWARE_ALIAS = "" CACHE_MIDDLEWARE_SECONDS = "" CACHE_MIDDLEWARE_KEY_PREFIX = ""
b. 单独视图缓存
方式一： 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)), ]
c、局部视图使用
a. 引入TemplateTag {% load cache %} b. 使用缓存 {% cache 5000 缓存key %} 缓存内容 {% endcache %}
def cache1(request):
t = time.time()
print('before')
models.Userinfo.objects.create(name='qwe')
print('after')
return render(request,'cache1.html',{'t': t})
++++++++++++++++++++++++++
{% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
{{ t }}
<hr />
{% cache 10 nnn %}
{{ t }}
{% endcache %}
</body>
</html>
序列化
关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户，特别的Ajax请求一般返回的为Json格式
1、serializers
from django.core import serializers
ret = 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 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内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数：
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("xxoo_callback")
print(sender,kwargs)
xxoo.connect(callback)
# xxoo指上述导入的内容
from django.core.signals import request_finished
from django.dispatch import receiver
@receiver(request_finished)
def my_callback(sender, **kwargs):
print("Request finished!")
注：注册的时候我们可以给上面的代码放到我们创建的project下的__init__.py文件中（或新建一.py文件，最后在__init__中导入）就注册成功了
2、自定义信号
a. 定义信号
import django.dispatch pizza_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_done pizza_done.send(sender='seven',toppings=123, size=456)
由于内置信号的触发者已经集成到Django中，所以其会自动调用，而对于自定义信号则需要开发者在任意位置触发。
