day_21 Cookie

1、獲取Cookie：

request.COOKIES['key']
request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
    參數：
        default: 默認值
           salt: 加密鹽
        max_age: 後臺控制過期時間

2、設置Cookie：

rep = HttpResponse(...) 或 rep ＝ render(request, ...)
 
rep.set_cookie(key,value,...)
rep.set_signed_cookie(key,value,salt='加密鹽',...)
    參數：
        key,              鍵
        value='',         值
        max_age=None,     超時時間
        expires=None,     超時時間(IE requires expires, so set it if hasn't been already.)
        path='/',         Cookie生效的路徑，/ 表示根路徑，特殊的：跟路徑的cookie可以被任何url的頁面訪問
        domain=None,      Cookie生效的域名
        secure=False,     https傳輸
        httponly=False    只能http協議傳輸，無法被JavaScript獲取（不是絕對，底層抓包可以獲取到也可以被覆蓋）

由於cookie保存在客戶端的電腦上，所以，JavaScript和jquery也可以操作cookie。

<script src='/static/js/jquery.cookie.js'></script>
$.cookie("list_pager_num", 30,{ path: '/' });

Session

Django中默認支持Session，其內部提供了5種類型的Session供開發者使用：

數據庫（默認）

緩存

文件

緩存+數據庫

加密cookie

1、數據庫Session

Django默認支持Session，並且默認是將Session數據存儲在數據庫中，即：django_session 表中。
 
a. 配置 settings.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")
 
        request.session.set_expiry(value)
            * 如果value是個整數，session會在些秒數後失效。
            * 如果value是個datatime或timedelta，session就會在這個時間後失效。
            * 如果value是0,用戶關閉瀏覽器session就會失效。
            * 如果value是None,session會依賴全局session失效策略。

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.path == '/test/':            
            return redirect('http://www.baidu.com')        
            return func(request, *args, **kwargs)    
            return wrap

跨站請求僞造

一、簡介

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內置分頁

Paginator

二、自定義分頁

分頁功能在每個網站都是必要的，對於分頁來說，其實就是根據用戶的輸入計算出應該在數據庫表中的起始位置。

1、設定每頁顯示數據條數

2、用戶輸入頁碼（第一頁、第二頁...）

3、根據設定的每頁顯示條數和當前頁碼，計算出需要取數據表的起始位置

4、在數據表中根據起始位置取值，頁面上輸出數據

需求又來了，需要在頁面上顯示分頁的頁面。如：［上一頁］［1］［2］［3］［4］［5］［下一頁］

1、設定每頁顯示數據條數

2、用戶輸入頁碼（第一頁、第二頁...）

3、設定顯示多少頁號

4、獲取當前數據總條數

5、根據設定顯示多少頁號和數據總條數計算出，總頁數

6、根據設定的每頁顯示條數和當前頁碼，計算出需要取數據表的起始位置

7、在數據表中根據起始位置取值，頁面上輸出數據

8、輸出分頁html，如：［上一頁］［1］［2］［3］［4］［5］［下一頁］

分頁實例

#!/usr/bin/env python# _*_coding:utf-8_*_from django.utils.safestring import mark_safe 
class PageInfo(object):
    def __init__(self,current,totalItem,peritems=5):
        self.__current=current
        self.__peritems=peritems
        self.__totalItem=totalItem    def From(self):
        return (self.__current-1)*self.__peritems    def To(self):
        return self.__current*self.__peritems    def TotalPage(self):  #總頁數
        result=divmod(self.__totalItem,self.__peritems)        if result[1]==0:            return result[0]        else:            return result[0]+1
 def Custompager(baseurl,currentPage,totalpage):  #基礎頁，當前頁，總頁數
    perPager=11
    #總頁數<11
    #0 -- totalpage
    #總頁數>11
        #當前頁大於5 currentPage-5 -- currentPage+5
            #currentPage+5是否超過總頁數,超過總頁數，end就是總頁數
        #當前頁小於5 0 -- 11
    begin=0
    end=0
    if totalpage <= 11:
        begin=0
        end=totalpage    else:        if currentPage>5:
            begin=currentPage-5
            end=currentPage+5
            if end > totalpage:
                end=totalpage        else:
            begin=0
            end=11
    pager_list=[]    if currentPage<=1:
        first="<a href=''>首頁</a>"
    else:
        first="<a href='%s%d'>首頁</a>" % (baseurl,1)
    pager_list.append(first) 
    if currentPage<=1:
        prev="<a href=''>上一頁</a>"
    else:
        prev="<a href='%s%d'>上一頁</a>" % (baseurl,currentPage-1)
    pager_list.append(prev) 
    for i in range(begin+1,end+1):        if i == currentPage:
            temp="<a href='%s%d' class='selected'>%d</a>" % (baseurl,i,i)        else:
            temp="<a href='%s%d'>%d</a>" % (baseurl,i,i)
        pager_list.append(temp)    if currentPage>=totalpage:
        next="<a href='#'>下一頁</a>"
    else:
        next="<a href='%s%d'>下一頁</a>" % (baseurl,currentPage+1)
    pager_list.append(next)    if currentPage>=totalpage:
        last="<a href=''>末頁</a>"
    else:
        last="<a href='%s%d'>末頁</a>" % (baseurl,totalpage)
    pager_list.append(last)
    result=''.join(pager_list)    return mark_safe(result)   #把字符串轉成html語言

總結，分頁時需要做三件事：

創建處理分頁數據的類

根據分頁數據獲取數據

輸出分頁HTML，即：［上一頁］［1］［2］［3］［4］［5］［下一頁］

緩存

由於Django是動態網站，所有每次請求均會去數據進行相應的操作，當程序訪問量大時，耗時必然會更加明顯，最簡單解決方式是使用：緩存，緩存將一個某個views的返回值保存至內存或者memcache中，5分鐘內再有人來訪問時，則不再去執行view中的操作，而是直接從內存或者Redis中之前緩存的內容拿到，並返回。

Django中提供了6種緩存方式：

開發調試

內存

文件

數據庫

Memcache緩存（python-memcached模塊）

Memcache緩存（pylibmc模塊）

1、配置

a、開發調試

# 此爲開始調試用，實際內部不做任何操作
   # 配置：
       CACHES = {
           'default': {
               'BACKEND': 'django.core.cache.backends.dummy.DummyCache',     # 引擎
               'TIMEOUT': 300,                                               # 緩存超時時間（默認300，None表示永不過期，0表示立即過期）
               'OPTIONS':{
                   'MAX_ENTRIES': 300,                                       # 最大緩存個數（默認300）
                   'CULL_FREQUENCY': 3,                                      # 緩存到達最大個數之後，剔除緩存個數的比例，即：1/CULL_FREQUENCY（默認3）
               },
               'KEY_PREFIX': '',                                             # 緩存key的前綴（默認空）
               'VERSION': 1,                                                 # 緩存key的版本（默認1）
               'KEY_FUNCTION' 函數名                                          # 生成key的函數（默認函數會生成爲：【前綴:版本:key】）
           }
       }


   # 自定義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 %}

序列化

關於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)

linux Zabbix監控的安裝

python基礎-列表,文件,運算符

Python,Day2 - 數據類型,運算,列表操作,字典

Python,Day3 - 函數,文件操作,字符編碼,json模塊

Python,Day4 - Python基礎4

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結