Python自動化運維之2八、Django(二)
1、FORM
一、概述
django表單系統中，全部的表單類都做爲django.forms.Form的子類建立，包括ModelForm
關於django的表單系統，主要分兩種
關於django的表單系統，主要分兩種
基於django.forms.Form： 全部表單類的父類
基於django.forms.ModelForm： 能夠和模型類綁定的Form
django中的Form通常有兩種功能：html
- 輸入html
- 驗證用戶輸入
一、forms.Form
from django.conf.urls import url from hello import views urlpatterns = [ url(r'^add_publisher/$', views.add_publisher, name='add_publisher'), ]
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>添加出版社信息</title> </head> <body> <form action="{% url 'add_publisher' %}" method="post"> {% csrf_token %} {{ publisher_form.as_p }} <input type="submit" value="提交"><br> </form> </body> </html>
from django.db import models class Publisher(models.Model): name = models.CharField(max_length=30, verbose_name="名稱") address = models.CharField("地址", max_length=50) city = models.CharField("城市", max_length=60) state_province = models.CharField("省份", max_length=30) country = models.CharField("國家", max_length=50) website = models.URLField("網址")
from django import forms from hello.models import Publisher class PublisherForm(forms.Form): name = forms.CharField(label="名稱", error_messages={"required": "這個項必須填寫"}) address = forms.CharField(label="地址", error_messages={"required": "這個項必須填寫"}) city = forms.CharField(label="城市", error_messages={"required": "這個項必須填寫"}) state_province = forms.CharField(label="省份", error_messages={"required": "這個項必須填寫"}) country = forms.CharField(label="國家", error_messages={"required": "這個項必須填寫"}) website = forms.URLField(label="網址", error_messages={"required": "這個項必須填寫"})
from django.shortcuts import render, render_to_response, redirect,HttpResponse from hello.models import Publisher from hello.forms import PublisherForm def add_publisher(request): if request.method == "POST": publisher_form = PublisherForm(request.POST) if publisher_form.is_valid(): Publisher.objects.create( name = publisher_form.cleaned_data['name'], address = publisher_form.cleaned_data['address'], city = publisher_form.cleaned_data['city'], state_province = publisher_form.cleaned_data['state_province'], country = publisher_form.cleaned_data['country'], website = publisher_form.cleaned_data['website'], ) return HttpResponse("添加出版社信息成功！") else: publisher_form = PublisherForm() return render(request, 'add_publisher.html', locals())
二、forms.ModelForm
from django import forms from hello.models import Publisher class PublisherForm(forms.ModelForm): class Meta: model = Publisher # 把models中的Publisher類綁定過來 exclude = ("id",) # 指定不要顯示的字段,fields是指定要顯示的字段
from django.shortcuts import render, render_to_response, redirect,HttpResponse from hello.models import Publisher from hello.forms import PublisherForm def add_publisher(request): if request.method == "POST": publisher_form = PublisherForm(request.POST) if publisher_form.is_valid(): publisher_form.save() # 這裏這一句就把前端傳過來的值所有寫入數據庫中了 return HttpResponse("添加出版社信息成功！") else: publisher_form = PublisherForm() return render(request, 'add_publisher.html', locals())
其餘配置和上面同樣前端
三、Django驗證表單
(1)表單字段的驗證器validators
from django import forms from hello.models import Publisher from django.core.exceptions import ValidationError def validate_name(value): try: Publisher.objects.get(name=value) raise ValidationError("%s的信息已經存在" %value) except Publisher.DoesNotExist: pass class PublisherForm(forms.ModelForm): name = forms.CharField(label="名稱", validators=[validate_name,]) #validate_name是上面定義的 class Meta: model = Publisher exclude = ("id",)
(2)clean_filedname，驗證字段，針對某個字段進行驗證python
from django import forms from hello.models import Publisher class PublisherForm(forms.ModelForm): def clean_name(self): value = self.cleaned_data.get('name') try: Publisher.objects.get(name=value) raise ValidationError("%s的信息已經存在" % value) except Publisher.DoesNotExist: pass return value class Meta: model = Publisher exclude = ("id",)
(3)表單clean方法，可針對整個表單進行驗證jquery
from django import forms from hello.models import Publisher class PublisherForm(forms.ModelForm): def clean(self): cleaned_data = super(PublisherForm, self).clean() value = cleaned_data.get('name') try: Publisher.objects.get(name=value) self._errors['name']=self.error_class(["%s的信息已經存在" % value]) except Publisher.DoesNotExist: pass return cleaned_data class Meta: model = Publisher exclude = ("id",)
(4)一個經常使用的驗證器validatorsgit
#!/usr/bin/env python # -*- coding:utf-8 -*- import re from django import forms 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 PublishForm(forms.Form): user_type_choice = ( (0, '普通用戶'), (1, '高級用戶'), ) user_type = forms.IntegerField(widget=forms.widgets.Select(choices=user_type_choice, attrs={'class': "form-control"})) title = forms.CharField(max_length=20, min_length=5, error_messages={'required': '標題不能爲空', 'min_length': '標題最少爲5個字符', 'max_length': '標題最多爲20個字符'}, widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': '標題5-20個字符'})) memo = forms.CharField(required=False, max_length=256, widget=forms.widgets.Textarea(attrs={'class': "form-control no-radius", 'placeholder': '詳細描述', 'rows': 3})) phone = forms.CharField(validators=[mobile_validate, ], error_messages={'required': '手機不能爲空'}, widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': '手機號碼'})) email = forms.EmailField(required=False, error_messages={'required': '郵箱不能爲空','invalid': '郵箱格式錯誤'}, widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': '郵箱'}))
def publish(request): ret = {'status': False, 'data': '', 'error': '', 'summary': ''} if request.method == 'POST': request_form = PublishForm(request.POST) if request_form.is_valid(): request_dict = request_form.clean() print request_dict ret['status'] = True else: error_msg = request_form.errors.as_json() ret['error'] = json.loads(error_msg) return HttpResponse(json.dumps(ret))
更多驗證器官網：github
四、例子
(1)Ajax提交form驗證web
from django.conf.urls import url from django.contrib import admin from app01 import views urlpatterns = [ url(r'^admin/', admin.site.urls), url(r'^login/', views.login), ]
#!/usr/bin/env python # -*- coding:utf-8 -*- from django import forms class LoginForm(forms.Form): # 這個字段username要和html中input標籤的name的屬性值同樣 username = forms.CharField(min_length=10, required=True, label='用戶名', error_messages={'required':'用戶名必須填寫', 'invalid':'格式不對', 'min_length':'最少10位字母'}) # 這個字段password要和html中input標籤的name的屬性值同樣 password = forms.CharField(min_length=10, max_length = 18, required=True, label='密碼', error_messages={'required':'這個選項必填', 'invalid':'格式不對', 'min_length':'最少10個字母', 'max_length': '最多18個字母',}) num = forms.IntegerField(min_value=10, max_value=18, label='數字', error_messages={'required':'這個選項必填', 'invalid':'格式不對', 'min_value':'最小值10', 'max_value':'最大值18'}) email = forms.EmailField(label='郵箱', error_messages={'required':'這個選項必填', 'invalid':'格式不對',}) url = forms.URLField(label='網址', error_messages={'required':'這個選項必填', 'invalid':'格式不對',}) # 自定義標籤和樣式,上面的字段默認是forms.TextInput test = forms.CharField(widget=forms.TextInput(attrs={'class':'c1','placeholder':'自定義輸入框'})) # 備註 test1 = forms.CharField(widget=forms.Textarea(attrs={'class':'c1','placeholder':'自定義輸入框'})) # 複選框(講數據庫時補充) test_choice = ( (0,'上海'), (1,'深圳'), ) test2 = forms.IntegerField(widget=forms.Select(choices=test_choice))
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>FORM驗證(AJAX)</title> <style> .error-msg{ color:red; } </style> </head> <body> <div> <input type="text" name="username" placeholder="用戶名"> </div> <div> <input type="password" name="password" placeholder="密碼"> </div> <div> <input type="text" name="num" placeholder="數字"> </div> <div> <input type="email" name="email" placeholder="郵箱"> </div> <div> <input type="url" name="url" placeholder="網址"> </div> <input type="button" value="提交" onclick="DoSubmit();"> <script src="/static/jquery-1.12.4.js"></script> <script> function DoSubmit() { var input_dict = {}; $("div input").each(function () { var v = $(this).val(); var k = $(this).attr('name'); input_dict[k] = v; }); console.log(input_dict); $('.error-msg').remove(); $.ajax({ url : '/login/', type : 'POST', data : input_dict, dataType:'json', success:function (result) { console.log(result); if(result.status){ location.href = '/index/' }else{ $.each(result.message,function (k,v) { console.log(v[0].message); // <span class="error-msg">錯誤信息</span> var tag = document.createElement('span'); tag.className = 'error-msg'; tag.innerText = v[0].message; // input(name="username") $('input[name="' + k + '"]').after(tag); }) } }, error:function () { } }); } </script> </body> </html>
from django.shortcuts import render,HttpResponse,redirect from myproject.forms import LoginForm,LoginForm1 import json def login(request): if request.method == 'POST': result = {'status':False,'message':None} obj = LoginForm(request.POST) ret = obj.is_valid() if ret: print(obj.clean()) result['status'] = True else: from django.forms.utils import ErrorDict print(type(obj.errors),obj.errors.as_json()) error_dict = obj.errors.as_json() result['message'] = json.loads(error_dict) return HttpResponse(json.dumps(result)) return render(request,'login.html')
(2)form生成html並驗證ajax
from django.conf.urls import url from django.contrib import admin from app01 import views urlpatterns = [ url(r'^admin/', admin.site.urls), url(r'^login/', views.login), url(r'^login1/', views.login1), url(r'^index/', views.index), ]
#!/usr/bin/env python # -*- coding:utf-8 -*- from django import forms class LoginForm1(forms.Form): # 這個字段username要和html中input標籤的name的屬性值同樣 username = forms.CharField(min_length=10, required=True, label='用戶名', error_messages={'required':'用戶名必須填寫', 'invalid':'格式不對', 'min_length':'最少10位字母'}) # 這個字段password要和html中input標籤的name的屬性值同樣 password = forms.CharField(min_length=10, max_length = 18, required=True, label='密碼', error_messages={'required':'這個選項必填', 'invalid':'格式不對', 'min_length':'最少10個字母', 'max_length': '最多18個字母',}) num = forms.IntegerField(min_value=10, max_value=18, label='數字', error_messages={'required':'這個選項必填', 'invalid':'格式不對', 'min_value':'最小值10', 'max_value':'最大值18'}) email = forms.EmailField(label='郵箱', error_messages={'required':'這個選項必填', 'invalid':'格式不對',}) url = forms.URLField(label='網址', error_messages={'required':'這個選項必填', 'invalid':'格式不對',}) # 自定義標籤和樣式,上面的字段默認是forms.TextInput test = forms.CharField(label='test', error_messages={'required':'這個選項必填','invalid':'格式不對',}, widget=forms.TextInput(attrs={'class':'c1','placeholder':'自定義輸入框'})) # 備註 test1 = forms.CharField(label='test1', error_messages={'required':'這個選項必填','invalid':'格式不對',}, widget=forms.Textarea(attrs={'class':'c1','placeholder':'自定義輸入框'})) # 複選框(講數據庫時補充) test_choice = ( (0,'上海'), (1,'深圳'), ) test2 = forms.IntegerField(widget=forms.Select(choices=test_choice))
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>FORM驗證並生成HTML</title> <style> .error-msg{ color:red; } </style> </head> <body> <form action="/login1/" method="post"> <div> {{ obj1.username }} {% if obj1.errors.username %} <span class="error-msg">{{ obj1.errors.username.0 }}</span> {% endif %} </div> <div> {{ obj1.password }} {% if obj1.errors.password %} <span class="error-msg">{{ obj1.errors.password.0 }}</span> {% endif %} </div> <div> {{ obj1.num }} {% if obj1.errors.num %} <span class="error-msg">{{ obj1.errors.num.0 }}</span> {% endif %} </div> <div> {{ obj1.email }} {% if obj1.errors.email %} <span class="error-msg">{{ obj1.errors.email.0 }}</span> {% endif %} </div> <div> {{ obj1.url }} {% if obj1.errors.url %} <span class="error-msg">{{ obj1.errors.url.0 }}</span> {% endif %} </div> <div> {{ obj1.test }} {% if obj1.errors.test %} <span class="error-msg">{{ obj1.errors.test.0 }}</span> {% endif %} </div> <div> {{ obj1.test1 }} {% if obj1.errors.test1 %} <span class="error-msg">{{ obj1.errors.test1.0 }}</span> {% endif %} </div> <div> {{ obj1.test2 }} {% if obj1.errors.test2 %} <span class="error-msg">{{ obj1.errors.test2.0 }}</span> {% endif %} </div> <input type="submit" value="提交""> </form> </body> </html>
from django.shortcuts import render,HttpResponse,redirect from myproject.forms import LoginForm,LoginForm1 import json def login1(request): if request.method == 'POST': objPost = LoginForm1(request.POST) ret = objPost.is_valid() if ret: print(objPost.clean()) else: pass return render(request, 'login1.html', {'obj1': objPost}) else: objGet = LoginForm() return render(request,'login1.html',{'obj1':objGet}) def index(request): return HttpResponse('ok')
forms.py中的choice若是是從數據庫中取的數據：只要choice=models.類名.objects.all().values_list('id','name'),由於values_list返回的是元組列表,choice = [(1,'普通用戶'),(2,'超級用戶')]redis
可是這樣choice仍是第一次取的數據,若是增長了數據,則不會時時更新,重啓能夠解決,可是在生產環境是不現實的,so 還有一種方法：數據庫
class IndexForm(forms.Form): #c = [ # (1,'CEO'), # (2,'CTO') #] c = models.UserType.objects.all().values_list('id','name') user_type_id = forms.IntergetField(widget=forms.Select(choices=c)) def __init__(self,*args,**kwargs): # 在views中實例化時,執行構造方法,就會時時更新了 super(IndexForm,self).__init__(*args,**kwargs) self.fields['user_type_id'].widget.choices = models.UserType.objects.all().values_list('id','name')
官網更多：https://docs.djangoproject.com/en/1.10/ref/forms/fields/
2、中間件
django 中的中間件（middleware），在django中，中間件其實就是一個類，在請求到來和結束後，django會根據本身的規則在合適的時機執行中間件中相應的方法。
在django項目的settings模塊中，有一個 MIDDLEWARE_CLASSES 變量，其中每個元素就是一箇中間件，每個中間件是一個類，類中不必定要寫5個方法
MIDDLEWARE_CLASSES = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.auth.middleware.SessionAuthenticationMiddleware', '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) 最後必須return response
以上方法的返回值能夠是None和HttpResonse對象，若是是None，則繼續按照django定義的規則向下執行，若是是HttpResonse對象，則直接將該對象返回給用戶。
django 1.10如下版本,若是process_request方法中有return語句則後面的全部request都不執行，全部的process_response都會執行，在django 1.10中有return則後面的
全部rerquest方法都不會執行,response只會這個request所屬的這個的response纔會執行，其餘的response不會執行
請求先經過中間件執行全部的process_request方法，而後再執行process_view方法，而後執行views中的方法，
若是views中的方法包含render_to_response()方法則會執行process_template_response方法，若是views中的
方法執行錯誤了，則會執行process_exception方法，最後執行process_response方法。
自定義中間件
一、建立中間件類
class defindemiddleware:
def process_request(self,request):
print(123)
def process_view(self, request, callback, callback_args, callback_kwargs):
print(456)
def process_exception(self, request, exception):
print(error)
def process_response(self, request, response):
print(end)
return response
二、註冊中間件
MIDDLEWARE_CLASSES = (
'my.middleware.defindedmiddleware', # 目錄結構my/middleware/類名 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.auth.middleware.SessionAuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', )
django 1.10中有點不同,建立時須要繼承父類：
from django.utils import deprecation class defindemiddleware(deprecation.MiddlewareMixin): def process_request(self,request): print(123)
3、跨站請求僞造
1、簡介
django爲用戶實現防止跨站請求僞造的功能，經過中間件 django.middleware.csrf.CsrfViewMiddleware 來完成。而對於django中設置防跨站請求僞造功能有分爲全局和局部。
django的csrf作了兩件事：1.往form表單中寫入了csrf_token(普通表單post時用的是這裏的token) 2.往cookie中也寫入了csrf_token(Ajax post提交時用的是這裏的token)
全局：
中間件 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的話，使用以下方式。須要下載導入jquery.cookie.js
from django.conf.urls import url from django.contrib import admin from app01 import views urlpatterns = [ url(r'^admin/', admin.site.urls), url(r'^csrf/', views.csrf), ]
from django.shortcuts import render,HttpResponse,redirect def csrf(request): return render(request,'csrf.html')
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>csrf跨站請求僞造</title> </head> <body> <form action="/csrf/" method="post"> {% csrf_token %} <input type="text" name="v"/> <input type="submit" value="提交"> </form> <input type="button" value="Ajax提交" onclick="DoAjax();"/> <script src="/static/jquery-1.12.4.js"></script> <script src="/static/jquery.cookie.js"></script> <script> 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 DoAjax() { $.ajax({ url:'/csrf/', type: 'post', data:{'k1':'va'}, sucess:function (data) { console.log(data); } }); } </script> </body> </html>
官網：https://docs.djangoproject.com/en/1.9/ref/csrf/#ajax
4、Cookie
Cookie，有時也用其複數形式Cookies,指某些網站爲了辨別用戶身份、進行session跟蹤而儲存在用戶本地終端上的數據（一般通過加密）,（能夠叫作瀏覽器緩存）,http是無狀態的,一般cookie配合session進行狀態的跟蹤,cookie是存在客戶端,session是存在服務器,sessionid是存在cookie中的鍵值對,因此session是依賴cookie的,django中的cookie默認是保存2周時間，用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保存在客戶端的電腦上，因此，JavaScript和jquery也能夠操做cookie。
<script src='/static/js/jquery.cookie.js'></script>
$.cookie("list_pager_num", 30,{ path: '/' });
用戶登陸驗證
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^index/', views.index),
url(r'^log/', views.log),
]
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title></title> </head> <body> <form action="/log/" method="POST"> <input type="text" name="user"> <input type="text" name="pwd"> <input type="submit" value="提交" /> </form> </body> </html>
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title></title> </head> <body> <h1>歡迎：{{ user }}登陸</h1> </body> </html>
from django.shortcuts import render,HttpResponse,redirect from django import forms def log(request): if request.method == 'POST': u = request.POST.get('user') p = request.POST.get('pwd') if u == 'tom' and p == '123': print(u) red = redirect('/index/') red.set_cookie('username', u) return red else: return render(request, 'log.html') else: return render(request, 'log.html') def index(request): user = request.COOKIES.get('username') if user: return render(request, 'index.html', {'user':user}) else: return redirect('/log/')
5、Session
Session在計算機中，尤爲是在網絡應用中，稱爲「會話控制」。Session 對象存儲特定用戶會話所需的屬性及配置信息。這樣，當用戶在應用程序的 Web 頁之間跳轉時，存儲在 Session 對象中的變量將不會丟失，而是在整個用戶會話中一直存在下去。當用戶請求來自應用程序的 Web 頁時，若是該用戶尚未會話，則 Web 服務器將自動建立一個 Session 對象。當會話過時或被放棄後，服務器將終止該會話。Session 對象最多見的一個用法就是存儲用戶的首選項。例如，若是用戶指明不喜歡查看圖形，就能夠將該信息存儲在 Session 對象中。會話狀態僅在支持 cookie 的瀏覽器中保留。
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")
...
二、緩存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用戶驗證
from django.conf.urls import url from django.contrib import admin from app01 import views urlpatterns = [ url(r'^admin/', admin.site.urls), url(r'^session_login/', views.session_login), url(r'^session_index/', views.session_index), url(r'^session_logout/', views.session_logout), ]
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>session用戶登陸驗證</title> </head> <body> <form action="/session_login/" method="POST"> {% csrf_token %} <input type="text" name="user"> <input type="text" name="pwd"> <input type="submit" value="提交" /> </form> </body> </html>
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>session用戶登陸驗證</title> </head> <body> <h1>歡迎：{{ username }}登陸</h1> <a href="/session_logout/">註銷</a> </body> </html>
def session_login(request): if request.method == 'POST': user = request.POST.get('user') password = request.POST.get('pwd') if password == '123' and user in USER_LIST: request.session['username'] = user return redirect('/session_index/') return render(request,'session_login.html') """ # 未使用裝飾器 def session_index(request): user = request.session.get('user',None) if not user: return redirect('/session_login/') else: return render(request,'session_index.html',{'user': user}) """ def auth(func): def inner(request,*args,**kwargs): user = request.session.get('username',None) if not user: return redirect('/session_login/') return func(request,*args,**kwargs) return inner @auth def session_index(request): user = request.session.get('username',None) return render(request,'session_index.html',{'username':user}) @auth def session_logout(request): del request.session['username'] return redirect('/session_login/')
設置session過程request.session['username'] = user 在session中設置屬性的時候,django作了兩件事：
1.往客戶端的cookie中寫入了sessionid和隨機字符串
2.默認在數據庫django_session中插入session_key,session_data,expire_date
更多參考：
https://docs.djangoproject.com/en/1.9/topics/http/sessions/
https://docs.djangoproject.com/en/1.9/ref/settings/#settings-sessions
6、分頁
1、Django內置分頁
Paginator
更多django分頁：
https://docs.djangoproject.com/en/1.9/topics/pagination/
2、自定義分頁
分頁功能在每一個網站都是必要的，對於分頁來講，其實就是根據用戶的輸入計算出應該在數據庫表中的起始位置。
一、設定每頁顯示數據條數
二、用戶輸入頁碼（第一頁、第二頁...）
三、根據設定的每頁顯示條數和當前頁碼，計算出須要取數據表的起始位置
四、在數據表中根據起始位置取值，頁面上輸出數據
需求又來了，須要在頁面上顯示分頁的頁面。如：［上一頁］［1］［2］［3］［4］［5］［下一頁］
一、設定每頁顯示數據條數
二、用戶輸入頁碼（第一頁、第二頁...）
三、設定顯示多少頁號
四、獲取當前數據總條數
五、根據設定顯示多少頁號和數據總條數計算出，總頁數
六、根據設定的每頁顯示條數和當前頁碼，計算出須要取數據表的起始位置
七、在數據表中根據起始位置取值，頁面上輸出數據
八、輸出分頁html，如：［上一頁］［1］［2］［3］［4］［5］［下一頁］
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> <style> .pager a{ display: inline-block; padding:5px; background-color: cadetblue; margin: 2px; } .pager a.active{ background-color: chartreuse; } </style> </head> <body> <table border="1"> <tr> <th>主機名</th> <th>IP</th> </tr> {% for i in data %} <tr> <td>{{ i.hostname }}</td> <td>{{ i.ip}}</td> </tr> {% endfor %} </table> <div> 總共：{{ count }}頁 </div> <div class="pager"> {{ page }} </div> </body> </html>
from django.conf.urls import url,include
from django.contrib import admin
from app02.views import *
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^page/', page),
]
from django.shortcuts import render,render_to_response,redirect from django.utils.safestring import mark_safe from app02 import models def try_int(arg,default): try: arg = int(arg) except Exception: arg = default return arg class PageInfo(): def __init__(self,current_page,all_count,per_item=10): self.CurrentPage = current_page self.AllCount = all_count self.PerItem = per_item @property def start(self): return (self.CurrentPage-1)*self.PerItem @property def end(self): return self.CurrentPage*self.PerItem @property def all_page_count(self): temp = divmod(self.AllCount, self.PerItem) if temp[1] == 0: all_page_count = temp[0] else: all_page_count = temp[0] + 1 return all_page_count def Pager(page,all_page_count): ''' page:當前頁 all_page_count:全部頁 ''' page_html = [] first_html = "<a href='/page?p=%d'>首頁</a>" %(1,) page_html.append(first_html) if page <= 1: prv_html = "<a href='#'>上一頁</a>" else: prv_html = "<a href='/page?p=%d'>上一頁</a>" %(page-1,) page_html.append(prv_html) begin = 0 end =0 if all_page_count <= 11: begin = 0 end = all_page_count else: if page < 6: begin = 0 end = 11 else: if page + 6 > all_page_count: begin = page - 6 end = all_page_count if end > all_page_count: end = all_page_count else: begin = page - 6 end = page + 6 for i in range(begin+1,end+1): if page == i: a_html = "<a class='active' href='/page?p=%d'>%d</a>" %(i,i) #mark_safe讓他轉義爲html else: a_html = "<a href='/page?p=%d'>%d</a>" %(i,i) page_html.append(a_html) if page >= all_page_count: next_html = "<a href='#'>下一頁</a>" else: next_html = "<a href='/page?p=%d'>下一頁</a>" %(page+1,) page_html.append(next_html) end_html = "<a href='/page?p=%d'>尾頁</a>" %(all_page_count,) page_html.append(end_html) page_string = mark_safe(''.join(page_html)) return page_string def page(request): page = request.GET.get('p',1) page = try_int(page, 1) count = models.HostInfo.objects.all().count() pageObj = PageInfo(page,count) result = models.HostInfo.objects.all()[pageObj.start:pageObj.end] page_string = Pager(page, pageObj.all_page_count) ret = {'data':result,'count':count,'page':page_string} return render_to_response('page.html',ret)
from django.db import models
# Create your models here.
class HostInfo(models.Model):
hostname = models.CharField(max_length=50)
ip = models.GenericIPAddressField()
總結，分頁時須要作三件事：
- 建立處理分頁數據的類
- 根據分頁數據獲取數據
- 輸出分頁HTML，即：［上一頁］［1］［2］［3］［4］［5］［下一頁］
7、緩存
因爲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 %} # 5000秒 緩存內容 {% endcache %}
官網更多：
https://docs.djangoproject.com/en/1.9/topics/cache/
二、redis緩存須要第三方
Django-redis 文檔：
http://niwinz.github.io/django-redis/latest/
http://django-redis-cache.readthedocs.org/en/latest/
Django-redis 緩存後端安裝：
$ sudo apt-get install redis-server # 安裝Redis Server $ . ~/myprojectenv/bin/active # Source 到虛擬環境 $ pip install django-redis-cache # 安裝緩存後端
Django-redis 緩存後端配置：
CACHES = { 'default': { 'BACKEND': 'redis_cache.RedisCache', 'LOCATION': '127.0.0.1:6379', 'OPTIONS': { 'DB': 1, 'PASSWORD': 'yadayada', 'PARSER_CLASS': 'redis.connection.HiredisParser', 'CONNECTION_POOL_CLASS': 'redis.BlockingConnectionPool', 'PICKLE_VERSION': -1, }, }, }
(1)LOCATION： Redis 服務器信息，能夠是 address/port，也能夠是 unix 域套接字。 可配置單個string，或者是 strings 的列表。 示例： 127.0.0.1:6379 #普通的TCP鏈接 /path/to/socket # Unix 域套接字鏈接 redis://[:password]@localhost:6379/0 # 普通的TCP鏈接 rediss://[:password]@localhost:6379/0 # SSL 封裝的 TCP 鏈接 # http://redis.io/topics/encryption unix://[:password]@/path/to/socket.sock?db=0 # Unix 域套接字鏈接 (2)Database Number： 設置存儲空間， 可在 OPTIONS 和 LOCATION 中配置 ( Default DB: 1) redis://@localhost:6379/0 CACHES = { 'default': { 'OPTIONS': { 'DB': 1, .. }, ... } } (3)Password： 若是 Redis Server 設置了密碼，則 CACHE 中也須要設置密碼, 可在 OPTIONS 中配置，也可在 LOCATION 中配置 CACHES = { 'default': { 'OPTIONS': { 'PASSWORD': 'yadayada', ... }, ... } }
Django-redis 緩存後端配置(redis主從)：
CACHES = { 'default': { 'LOCATION': [ '127.0.0.1:6379', # Primary '127.0.0.1:6380', # Secondary '127.0.0.1:6381', # Secondary ], 'OPTIONS': { 'PASSWORD': 'yadayada', 'MASTER_CACHE': '127.0.0.1:6379', ... }, ... } }
基於Redis緩存的項目實例：
這裏使用redis主從架構,作以前須要配置好redis主從,配置好兩份redis.conf配置文件便可，slaveof 127.0.0.1 6379
(1)配置好redis主從 $ sudo cp /etc/redis/redis.conf{,1} $ sudo vi /etc/redis/redis.conf 37 daemonize yes 45 port 6379 64 bind 127.0.0.1 391 requirepass 123456 $ sudo vi /etc/redis/redis.conf1 37 daemonize yes 45 port 6380 64 bind 127.0.0.1 206 slaveof 127.0.0.1 6379 391 requirepass 123456 $ sudo redis-server /etc/redis/redis.conf $ sudo redis-server /etc/redis/redis.conf1 $ ps -ef | grep redis-server root 44429 1627 0 14:53 ? 00:00:00 redis-server 127.0.0.1:6379 root 44447 1627 1 14:54 ? 00:00:00 redis-server 127.0.0.1:6380 xiaozhi+ 44480 27618 0 14:54 pts/1 00:00:00 grep --color=auto redis-server (2)配置settings CACHES = { 'default': { 'BACKEND': 'redis_cache.RedisCache', 'LOCATION': ['127.0.0.1:6379','127.0.0.1:6380'], 'OPTIONS': { 'MASTER_CACHE': '127.0.0.1:6379', 'DB': 2, 'PASSWORD': '123456', }, 'KEY_PREFIX': 'MyProject', 'TIMEOUT': 480 } } (3)使用url方式進行view緩存 from django.views.decorators.cache import cache_page urlpatterns = [ url(r'^admin/', include(admin.site.urls)), url(r'^$',cache_page(60 * 15)(Index.as_view())=,name='INDEX'), url(r'^index2/$',Index2.as_view(),name='INDEX2'), ] 或者在views中的方法上調用裝飾器 from django.views.decorators.cache import cache_page @cache_page(60 * 15, key_prefix='index2') def Index2(request): return render(request,'index.html') (4)使用template片斷緩存 {% extends 'base.html' %} {% load cache %} {% load staticfiles %} . . {% cache 500 sidebar %} . {% endcache %}
8、序列化
關於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)
8、信號
Django中提供了「信號調度」，用於在框架執行操做時解耦。通俗來說，就是一些動做發生的時候，信號容許特定的發送者去提醒一些接受者。
通常把信號卸載和項目同名的__init__文件中
一、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!")
二、自定義信號
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中，因此其會自動調用，而對於自定義信號則須要開發者在任意位置觸發。
更多官網：https://docs.djangoproject.com/en/1.9/topics/signals/
相關文章
- 1. Python自動化運維之2五、Ajax
- 2. Python自動化運維之2七、Django(一)
- 3. python自動化運維八：Ansible
- 4. python自動化運維學習第二十八天--Django中間件
- 5. 自動化運維--ansible(2)
- 6. 運維自動化-Ansible ( 二 )
- 7. Ansible自動化運維(二)
- 8. Python 自動化運維 difflib
- 9. Python 自動化運維 XlsxWriter
- 10. Python自動化運維
- 更多相關文章...
- • Maven 自動化部署 - Maven教程
- • SQLite - Python - SQLite教程
- • SpringBoot中properties文件不能自動提示解決方法
- • IntelliJ IDEA中SpringBoot properties文件不能自動提示問題解決
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
