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}) # 进行渲染在前端显示
views.py
#!/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"}))
forms.py
<!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>
form.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':'邮箱格式错误'})
phone forms.py
#!/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')
views.py
文件上传:
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})
views.py
#!/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)
xx.py
<!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>
index.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>
student.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>
video.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中，所以其会自动调用，而对于自定义信号则需要开发者在任意位置触发。
django 补充篇的更多相关文章
- Django进阶篇【1】
注:本篇是Django进阶篇章,适合人群:有Django基础,关于Django基础篇,将在下一章节中补充! 首先我们一起了解下Django整个请求生命周期: Django 请求流程,生命周期: 路由部 ...
- 02：Django进阶篇
目录:Django其他篇 01:Django基础篇 02:Django进阶篇 03:Django数据库操作--->Model 04: Form 验证用户数据 & 生成html 05:Mo ...
- 01: Django基础篇
目录:Django其他篇 01:Django基础篇 02:Django进阶篇 03:Django数据库操作--->Model 04: Form 验证用户数据 & 生成html 05:Mo ...
- Python3实现ICMP远控后门(上)_补充篇
ICMP后门(上)补充篇 前言 在上一篇文章Python3实现ICMP远控后门(上)中,我简要讲解了ICMP协议,以及实现了一个简单的ping功能,在文章发表之后,后台很多朋友留言,说对校验和的计算不 ...
- django补充CBV和FBV模式
django补充CBV和FBV模式FBV模式---函数:经常用的方式CBV模式---类CBV中url连接时函数名后面要接.as_view()class index(views.View): @... ...
- 01：django基础篇
Django其他篇 目录: 1.1 django初探 1.2 第一个django项目 1.3 django render/redirect/HttpResponse 和 request.GET req ...
- C# 9 新特性 —— 补充篇
C# 9 新特性 -- 补充篇 Intro 前面我们分别介绍了一些 C# 9 中的新特性,还有一些我觉得需要了解一下的新特性,写一篇作为补充. Top-Level Statements 在以往的代码里 ...
- 剖析虚幻渲染体系（13）- RHI补充篇：现代图形API之奥义与指南
目录 13.1 本篇概述 13.1.1 本篇内容 13.1.2 概念总览 13.1.3 现代图形API特点 13.2 设备上下文 13.2.1 启动流程 13.2.2 Device 13.2.3 Sw ...
- 21-Python-Django进阶补充篇
1. 路由部分补充 1.1 默认值 url: url(r'^index/', views.index, {'name': 'root'}), views: def index(request,name ...
随机推荐
- C++_系列自学课程_第_11_课_类型转换_《C++ Primer 第四版》
上次说了关于表达式的一些内容,说到还有一些关于数据类型转换的内容,今天我们接着八一八C++中的数据类型转换. 一.隐式类型转换 在表达式中,有些操作符可以对多种类型的操作数进行操作, 例如 + 操作符 ...
- ActiveMQ 简单搭建
========== ActiveMQ ============== JMS : topic : 一对多: 发布订阅: 不保证数据是否被接受: 不存储topic信息: Queue : 一对一: 点对点 ...
- 类型转换和类型相关函数.png
- 微信小程序之基础简介
创建小程序项目后进入编辑环境中会有以下的初始配置文件: 文件夹: 1.pages(存放小程序的页面) 1.index 2.logs (页面里的js文件 以Page()方法开头 所有参数对象都存放在其里 ...
- SharePoint 2013 沙盒解决方案不能激活(激活按钮不可用)
把沙盒解决方案上传到目标站点的"解决方案"库中,发现"激活"按钮是灰掉的,不可用. 首先,我想到的是权限不足,所以 "以管理员身份"启动IE ...
- IOS 开发小技巧总结
一.添加自定义字体 1.把字体文件拖到工程中. 2.plist 文件中添加字段:<Array>Fonts provided by application</Array> 把字体 ...
- Android开发学习—— ContentProvider内容提供者
* 应用的数据库是不允许其他应用访问的* 内容提供者的作用就是让别的应用访问到你的数据库.把私有数据暴露给其他应用,通常,是把私有数据库的数据暴露给其他应用. Uri:包含一个具有一定格式的字符串的对 ...
- javaScript基础语法（上）
相关理论概念: 直接量的概念:直接描述某个(些)存储空间的值的量,如变量的值.对象的值.数组的值. 数据类型:在数据结构中的定义是一个值的集合以及定义在这个值集上的一组操作. 1.变量的声明和使用 变 ...
- 搞不清FastCgi与PHP-fpm之间是个什么样的关系？
问 我在网上查fastcgi与php-fpm的关系,查了快一周了,基本看了个遍,真是众说纷纭,没一个权威性的定义. 网上有的说,fastcgi是一个协议,php-fpm实现了这个协议: 有的说,php ...
- MapReduce工作流多种实现方式
学习 hadoop,必不可少的就是编写 MapReduce 程序.当然,对于简单的分析程序,我们只需一个 MapReduce 任务就能搞定,然而对于比较复杂的分析程序,我们可能需要多个Job或者多个M ...