django 補充篇
from驗證
django中的Form通常有兩種功能：javascript
- 輸入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>
三、定製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__方法的時候再一次執行一下靜態字段就能夠達到更新的目的css
擴展：ModelFormhtml
在使用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"}),
}
自定義錯誤驗證：java
#!/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、自定義上傳python
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上傳文件實例jquery
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
模板
一、模版的執行git
模版的建立過程，對於模版，其實就是讀取模版（其中嵌套着模版標籤），而後將 Model 中獲取的數據插入到模版中，最後將信息返回給用戶github
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))
二、模版語言 模板中也有本身的語言，該語言能夠實現數據展現
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 %}
三、自定義simple_tagajax
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
一、數據庫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. 使用
同上
三、文件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. 使用
同上
四、緩存+數據庫Session
數據庫用於作持久化，緩存用於提升效率
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db' # 引擎
b. 使用
同上
五、加密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）
1、簡介
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
2、應用
一、普通表單
veiw中設置返回值：
return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))
或者
return render(request, 'xxx.html', data)
html中設置Token:
{% csrf_token %}
二、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
自定義中間件
一、建立中間件類
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
二、註冊中間件
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模塊）
一、配置
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', ] } }
二、應用
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格式
一、serializers
from django.core import serializers
ret = models.BookType.objects.all()
data = serializers.serialize("json", ret)
二、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中提供了「信號調度」，用於在框架執行操做時解耦。通俗來說，就是一些動做發生的時候，信號容許特定的發送者去提醒一些接受者。
一、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__中導入）就註冊成功了
二、自定義信號
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中，因此其會自動調用，而對於自定義信號則須要開發者在任意位置觸發。
相關文章
- 1. Django補充
- 2. Django - 補充目錄
- 3. Django用法補充
- 4. Django進階（補充）
- 5. Django知識補充
- 6. 補充上一篇
- 7. Django 基礎筆記補充
- 8. Django ORM 查詢補充
- 9. Django ORM操做補充
- 10. Django之Form組件補充
- 更多相關文章...
- • XML Schema complexContent 元素 - XML Schema 教程
- • HTTP 請求方法 - HTTP 教程
- • 三篇文章瞭解 TiDB 技術內幕——說存儲
- • 再有人問你分佈式事務，把這篇扔給他
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Django補充
- 2. Django - 補充目錄
- 3. Django用法補充
- 4. Django進階（補充）
- 5. Django知識補充
- 6. 補充上一篇
- 7. Django 基礎筆記補充
- 8. Django ORM 查詢補充
- 9. Django ORM操做補充
- 10. Django之Form組件補充