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

学习python已经20天了啊，从一个不萌萌哒的战5渣升级到了一个萌萌哒的战5渣

1.分页（这是一个很通用的模块，不论在任何框架里都可以使用哦）

 class Page(object):
     def __init__(self, current_page):
         """

         :param current_page: 当前的页码
         """
         self.current_page = int(current_page)

     @property
     def start(self):
         """

         :return: 返回页码展示的起始页码
         """
         return (self.current_page-1)*10

     @property
     def end(self):
         """

         :return: 返回页码展示的结束页码
         """
         return self.current_page*10

     def page_str(self, all_item, base_url):
         """
         页码展示的具体验证方法
         :param all_item: 数据库内所有数据的条数
         :param base_url: 基础url，因为是通用的的，所以要传递不同的url
         :return:
         """
         all_page, div = divmod(all_item, 10)    # 按每页10条展示
         if div > 0:
             all_page += 1
         page_list = []
         if all_page <= 11:                      # 当总页码少于11个时，直接展示1-最后页码
             start = 1
             end = all_page
         else:
             if self.current_page <= 6:          # 如果当前点击页码小于6，则还是展示1-11页
                 start = 1
                 end = 12
             else:
                 start = self.current_page-5     # 以当前点击页码为中心显示前5个跟后5个页码
                 end = self.current_page+6
                 if self.current_page+6 > all_page:
                     start = all_page-11
                     end = all_page
         for i in range(start, end):
             if i == self.current_page:
                 temp = '<a href="%s%d" style="color:red;font-size:18px">%d</a>' % (base_url, i, i)
             else:
                 temp = '<a href="%s%d">%d</a>' % (base_url, i, i)
             page_list.append(temp)
         if self.current_page > 1:
             pre_page = '<a href="%s%d">上一页</a>' % (base_url, self.current_page-1)
         else:
             pre_page = '<a href="javascript:void(0)">上一页</a>'
         if self.current_page < all_page:
             next_page = '<a href="%s%d">下一页</a>' % (base_url, self.current_page+1)
         else:
             next_page = '<a href="javascript:void(0)">下一页</a>'
         page_list.append(next_page)
         page_list.insert(0, pre_page)
         first_page = '<a href="%s1">首页</a>' % base_url
         last_page = '<a href="%s%d">末页</a>' % (base_url, all_page)
         page_list.append(last_page)
         page_list.insert(0, first_page)
         page_str = ''.join(page_list)
         return page_str

xss安全只需要在前端接收后面加‘XXXX|safe‘’即可

2.中间件（运维角度：在用户提交请求后到服务器处理该请求之前所经历的一切都可以称之为中间件）

在django中只需要记住这种那个图即可：

自定义中间件后需要在setting中注册即可使用：

 MIDDLEWARE= [
     # 'md.bfmq.M1',
     # 'md.bfmq.M2',
     'django.middleware.security.SecurityMiddleware',
     'django.contrib.sessions.middleware.SessionMiddleware',
     'django.middleware.common.CommonMiddleware',
     # 'django.md.csrf.CsrfViewMiddleware',
     'django.contrib.auth.middleware.AuthenticationMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     'django.middleware.clickjacking.XFrameOptionsMiddleware',
 ]

需要注意的问题是现在有一些版本问题，自定义的中间件需要继承一个类：

 #!/usr/bin/env python
 from django.utils import deprecation

 class M1(deprecation.MiddlewareMixin):
     def process_request(self, request):
         print('M1.request')

     def process_response(self, request, response):
         print('M1.response')
         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          # 创建数据库连接时，自动触发

 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("bfmq_callback")
         print(sender,kwargs)

     bfmq.connect(callback)
     # bfmq指上述导入的内容

4.缓存

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',
             ]
         }
     }

g.redis需要下载第三方模块实现，ps：你们都不知道我大tair么？哈哈哈

全站进行缓存：

 使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存

     MIDDLEWARE = [
         'django.middleware.cache.UpdateCacheMiddleware',
         # 其他中间件...
         'django.middleware.cache.FetchFromCacheMiddleware',
     ]

     CACHE_MIDDLEWARE_ALIAS = ""
     CACHE_MIDDLEWARE_SECONDS = ""
     CACHE_MIDDLEWARE_KEY_PREFIX = ""

某视图进行缓存：

 方式一：
         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)),
         ]

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

 a. 引入TemplateTag

3　　　　{% load cache %}

5 b. 使用缓存

7　　　　{% cache 5000 缓存key %}
       　　缓存内容
9　　　　{% endcache %}

5.form补充

 class IndexForm(forms.Form):
     c = models.UserType.objects.all().values_list('id','caption')
     user_type_id = forms.IntegerField(widget=forms.Select(choices=c))

     def __init__(self, *args, **kwargs):
         """
         在每次url访问后函数调用类时都执行次就会获取到数据库最新数据
         :param args:
         :param kwargs:
         """
         super(IndexForm, self).__init__(*args, **kwargs)
         self.fields['user_type_id'].widget.choices = models.UserType.objects.all().values_list('id','caption')

 def index(request):
     form = IndexForm()
     return render(request, 'index.html', {'form': form})