python第二十天-----Django補充

學習python已經20天了啊，從一個不萌萌噠的戰5渣升級到了一個萌萌噠的戰5渣

1.分頁（這是一個很通用的模塊，不論在任何框架裏均可以使用哦）

 1 class Page(object):
 2     def __init__(self, current_page):
 3         """
 4         
 5         :param current_page: 當前的頁碼
 6         """
 7         self.current_page = int(current_page)
 8 
 9     @property
10     def start(self):
11         """
12         
13         :return: 返回頁碼展現的起始頁碼
14         """
15         return (self.current_page-1)*10
16 
17     @property
18     def end(self):
19         """
20         
21         :return: 返回頁碼展現的結束頁碼
22         """
23         return self.current_page*10
24 
25     def page_str(self, all_item, base_url):
26         """
27         頁碼展現的具體驗證方法
28         :param all_item: 數據庫內全部數據的條數
29         :param base_url: 基礎url，由於是通用的的，因此要傳遞不一樣的url
30         :return: 
31         """
32         all_page, div = divmod(all_item, 10)    # 按每頁10條展現
33         if div > 0:
34             all_page += 1
35         page_list = []
36         if all_page <= 11:                      # 當總頁碼少於11個時，直接展現1-最後頁碼
37             start = 1
38             end = all_page
39         else:
40             if self.current_page <= 6:          # 若是當前點擊頁碼小於6，則仍是展現1-11頁
41                 start = 1
42                 end = 12
43             else:
44                 start = self.current_page-5     # 以當前點擊頁碼爲中心顯示前5個跟後5個頁碼
45                 end = self.current_page+6
46                 if self.current_page+6 > all_page:
47                     start = all_page-11
48                     end = all_page
49         for i in range(start, end):
50             if i == self.current_page:
51                 temp = '<a href="%s%d" style="color:red;font-size:18px">%d</a>' % (base_url, i, i)
52             else:
53                 temp = '<a href="%s%d">%d</a>' % (base_url, i, i)
54             page_list.append(temp)
55         if self.current_page > 1:
56             pre_page = '<a href="%s%d">上一頁</a>' % (base_url, self.current_page-1)
57         else:
58             pre_page = '<a href="javascript:void(0)">上一頁</a>'
59         if self.current_page < all_page:
60             next_page = '<a href="%s%d">下一頁</a>' % (base_url, self.current_page+1)
61         else:
62             next_page = '<a href="javascript:void(0)">下一頁</a>'
63         page_list.append(next_page)
64         page_list.insert(0, pre_page)
65         first_page = '<a href="%s1">首頁</a>' % base_url
66         last_page = '<a href="%s%d">末頁</a>' % (base_url, all_page)
67         page_list.append(last_page)
68         page_list.insert(0, first_page)
69         page_str = ''.join(page_list)
70         return page_str

xss安全只須要在前端接收後面加‘XXXX|safe‘’便可

2.中間件（運維角度：在用戶提交請求後到服務器處理該請求以前所經歷的一切均可以稱之爲中間件）

在django中只須要記住這種那個圖便可：

自定義中間件後須要在setting中註冊便可使用：

 1 MIDDLEWARE= [
 2     # 'md.bfmq.M1',
 3     # 'md.bfmq.M2',
 4     'django.middleware.security.SecurityMiddleware',
 5     'django.contrib.sessions.middleware.SessionMiddleware',
 6     'django.middleware.common.CommonMiddleware',
 7     # 'django.md.csrf.CsrfViewMiddleware',
 8     'django.contrib.auth.middleware.AuthenticationMiddleware',
 9     'django.contrib.messages.middleware.MessageMiddleware',
10     'django.middleware.clickjacking.XFrameOptionsMiddleware',
11 ]

須要注意的問題是如今有一些版本問題，自定義的中間件須要繼承一個類：

 1 #!/usr/bin/env python
 2 from django.utils import deprecation
 3 
 4 
 5 class M1(deprecation.MiddlewareMixin):
 6     def process_request(self, request):
 7         print('M1.request')
 8 
 9     def process_response(self, request, response):
10         print('M1.response')
11         return response

3.信號（就是知足觸發條件時執行些什麼）

內置信號
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          # 建立數據庫鏈接時，自動觸發

 

 1 from django.core.signals import request_finished
 2     from django.core.signals import request_started
 3     from django.core.signals import got_request_exception
 4 
 5     from django.db.models.signals import class_prepared
 6     from django.db.models.signals import pre_init, post_init
 7     from django.db.models.signals import pre_save, post_save
 8     from django.db.models.signals import pre_delete, post_delete
 9     from django.db.models.signals import m2m_changed
10     from django.db.models.signals import pre_migrate, post_migrate
11 
12     from django.test.signals import setting_changed
13     from django.test.signals import template_rendered
14 
15     from django.db.backends.signals import connection_created
16 
17 
18     def callback(sender, **kwargs):
19         print("bfmq_callback")
20         print(sender,kwargs)
21 
22     bfmq.connect(callback)
23     # bfmq指上述導入的內容

4.緩存

a.調試（無任何操做，只是練習時用）

 1 # 此爲開始調試用，實際內部不作任何操做
 2     # 配置：
 3         CACHES = {
 4             'default': {
 5                 'BACKEND': 'django.core.cache.backends.dummy.DummyCache',     # 引擎
 6                 'TIMEOUT': 300,                                               # 緩存超時時間（默認300，None表示永不過時，0表示當即過時）
 7                 'OPTIONS':{
 8                     'MAX_ENTRIES': 300,                                       # 最大緩存個數（默認300）
 9                     'CULL_FREQUENCY': 3,                                      # 緩存到達最大個數以後，剔除緩存個數的比例，即：1/CULL_FREQUENCY（默認3）
10                 },
11                 'KEY_PREFIX': '',                                             # 緩存key的前綴（默認空）
12                 'VERSION': 1,                                                 # 緩存key的版本（默認1）
13                 'KEY_FUNCTION' 函數名                                          # 生成key的函數（默認函數會生成爲：【前綴:版本:key】）
14             }
15         }
16 
17 
18     # 自定義key
19     def default_key_func(key, key_prefix, version):
20         """
21         Default function to generate keys.
22 
23         Constructs the key used by all other methods. By default it prepends
24         the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
25         function with custom key making behavior.
26         """
27         return '%s:%s:%s' % (key_prefix, version, key)
28 
29     def get_key_func(key_func):
30         """
31         Function to decide which key function to use.
32 
33         Defaults to ``default_key_func``.
34         """
35         if key_func is not None:
36             if callable(key_func):
37                 return key_func
38             else:
39                 return import_string(key_func)
40         return default_key_func

b.內存

1 # 此緩存將內容保存至內存的變量中
2     # 配置：
3         CACHES = {
4             'default': {
5                 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
6                 'LOCATION': 'unique-snowflake',
7             }
8         }

c.文件

1 # 此緩存將內容保存至文件
2     # 配置：
3 
4         CACHES = {
5             'default': {
6                 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
7                 'LOCATION': '/var/tmp/django_cache',
8             }
9         }

d.數據庫

 1 # 此緩存將內容保存至數據庫
 2 
 3     # 配置：
 4         CACHES = {
 5             'default': {
 6                 'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
 7                 'LOCATION': 'my_cache_table', # 數據庫表
 8             }
 9         }
10 
11     # 注：執行建立表命令 python manage.py createcachetable

e.Memcache緩存（python-memcached模塊）

 1 # 此緩存使用python-memcached模塊鏈接memcache
 2 
 3     CACHES = {
 4         'default': {
 5             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
 6             'LOCATION': '127.0.0.1:11211',
 7         }
 8     }
 9 
10     CACHES = {
11         'default': {
12             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
13             'LOCATION': 'unix:/tmp/memcached.sock',
14         }
15     }   
16 
17     CACHES = {
18         'default': {
19             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
20             'LOCATION': [
21                 '172.19.26.240:11211',
22                 '172.19.26.242:11211',
23             ]
24         }
25     }

f.Memcache緩存（pylibmc模塊）

 1 # 此緩存使用pylibmc模塊鏈接memcache
 2     
 3     CACHES = {
 4         'default': {
 5             'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
 6             'LOCATION': '127.0.0.1:11211',
 7         }
 8     }
 9 
10     CACHES = {
11         'default': {
12             'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
13             'LOCATION': '/tmp/memcached.sock',
14         }
15     }   
16 
17     CACHES = {
18         'default': {
19             'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
20             'LOCATION': [
21                 '172.19.26.240:11211',
22                 '172.19.26.242:11211',
23             ]
24         }
25     }

g.redis須要下載第三方模塊實現，ps：大家都不知道我大tair麼？哈哈哈

全站進行緩存：

 1 使用中間件，通過一系列的認證等操做，若是內容在緩存中存在，則使用FetchFromCacheMiddleware獲取內容並返回給用戶，當返回給用戶以前，判斷緩存中是否已經存在，若是不存在則UpdateCacheMiddleware會將緩存保存至緩存，從而實現全站緩存
 2 
 3     MIDDLEWARE = [
 4         'django.middleware.cache.UpdateCacheMiddleware',
 5         # 其餘中間件...
 6         'django.middleware.cache.FetchFromCacheMiddleware',
 7     ]
 8 
 9     CACHE_MIDDLEWARE_ALIAS = ""
10     CACHE_MIDDLEWARE_SECONDS = ""
11     CACHE_MIDDLEWARE_KEY_PREFIX = ""

某視圖進行緩存：

 1 方式一：
 2         from django.views.decorators.cache import cache_page
 3 
 4         @cache_page(60 * 15)
 5         def my_view(request):
 6             ...
 7 
 8     方式二：
 9         from django.views.decorators.cache import cache_page
10 
11         urlpatterns = [
12             url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),
13         ]

html某部分緩存（緩存母板~）

1 a. 引入TemplateTag
2 
3　　　　{% load cache %}
4 
5 b. 使用緩存
6 
7　　　　{% cache 5000 緩存key %}
8       　　緩存內容
9　　　　{% endcache %}

5.form補充

 1 class IndexForm(forms.Form):
 2     c = models.UserType.objects.all().values_list('id','caption')
 3     user_type_id = forms.IntegerField(widget=forms.Select(choices=c))
 4     
 5     def __init__(self, *args, **kwargs):
 6         """
 7         在每次url訪問後函數調用類時都執行次就會獲取到數據庫最新數據
 8         :param args: 
 9         :param kwargs: 
10         """
11         super(IndexForm, self).__init__(*args, **kwargs)
12         self.fields['user_type_id'].widget.choices = models.UserType.objects.all().values_list('id','caption')
13 
14 
15 def index(request):
16     form = IndexForm()
17     return render(request, 'index.html', {'form': form})