自定义过滤器及标签

上节知识复习

前后端合并—-加快软件开发项目流程—-》学习成套知识

常用的模板标签

{% %}标签的语法

基本原则：有开始一定有结束【标签成对出现】

  1. {%if%}
  3. {%endif%}
  5. if .... else
  7. forloop
  9. {%load%}
  11. {%endload%}
  13. {%url 'index_05'%}

模板继承的意义

  1. 方便代码复用，使用继承模板的方式
  3. 继承时，使用标签[extends]

使用模板中的内容

block.super()

调用关系描述

在浏览器中，发出特定request请求，从项目中设置文件指定的urls文件中，匹配URL规则，调用views视图函数，由视图调用HTML文件，该文件中包含自定义过滤器以及指定标签扩展，从标签中调用模板标签，读取自定义过滤器

文件路径配置

【重点】创建自定义模板的步骤

1，在项目文件目录下创建名为common的包（即目录中含有init.py）

2，将common加入到settings文件中

3，在common里面创建目录templates,在目录里面创建自定义过滤器及标签文件

4， 在common_extras.py文件中自定义cut和lower的过滤器功能

  1. def mycut(value, arg):
  2.     return value.replace(arg, '')
  5. def mylower(value):
  6.     return value.lower()

自定义过滤器

概念：自定义过滤器就是一个带有一个或者两个参数的python函数；

  1. (输入的)变量的值 --- 不一定是字符串形式；
  3. 参数的值 --- 可以有一个初始值，或者完全不要这个参数

示例

  1. {{var|fool:"bar"}}  # var:变量； fool：自定义过滤器的名字；"bar":传给变量的值

功能实现

在url访问中调用对应的视图函数，然后从视图函数的返回中我们可以看到：自定义一个字符串，以上下文的方式传递给H5文件，由H5文件处理

  1. def common(request):
  2.     ts = 'YKK   seasame'
  3.     return render(request, 'loads.html', context={
  4.         'ts': ts,  # 上下文中ts的名字需要完全保持一致
  5.     })

进入H5之后，由自定义过滤器处理传入的字符串，字符串是用参数ts传入的，因此我们在H5中书写时必须使用ts作为参数，才有对象处理

  1. {% load common_extras %}
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>测试自定义过滤器及标签</title>
  7. </head>
  8. <body>
  9. <p>展示自定义过滤器---转为小写</p>
  10. {{somevariable|mylower}}<br>
  11. <p>展示自定义过滤器---删除空格</p>
  12. {{somevariable|mycut:''}}<br>
  13. </body>
  14. </html>

注册自定义过滤器

【语法】

  1. django.template.Library.filter()
  2. 1.Library.filter()方法需要两个参数：
  3.     a. 过滤器的名称（一个字符串对象）
  4.     b. 编译的函数 – 一个Python函数（不要把函数名写成字符串）
  5. 2.可以把register.filter()用作装饰器;
  6. 3.没有声明 name 参数，Django将使用函数名作为过滤器的名字。

【总结】过滤器及自定义标签格式解读

形式： @函数名

作用：在不改变原有代码逻辑的情况下，增加功能

自定义装饰器的方法

1 filter()

第一个参数：self是类对象的名字（Library对象）

第二个参数：name = None 返回的是函数的名字

【源码】—- 装饰器filter

  1. def filter(self, name=None, filter_func=None, **flags):
  2.     """
  3.     Register a callable as a template filter. Example:  # 注册一个可以调用的过滤器
  5.     @register.filter
  6.     def lower(value):  # 需要为自定义函数传递参数
  7.         return value.lower()
  8.     """
  9.     if name is None and filter_func is None:  # 如果没有为过滤器传入名字和被装饰的函数的名字
  10.         # @register.filter()
  11.         def dec(func):
  12.             return self.filter_function(func, **flags)
  13.         return dec  # 返回被装饰函数的名字
  14.     elif name is not None and filter_func is None:
  15.         if callable(name):
  16.             # @register.filter
  17.             return self.filter_function(name, **flags)
  18.         else:
  19.             # @register.filter('somename') or @register.filter(name='somename')
  20.             def dec(func):
  21.                 return self.filter(name, func, **flags)
  22.             return dec
  23.     elif name is not None and filter_func is not None:
  24.         # register.filter('somename', somefunc)
  25.         self.filters[name] = filter_func
  26.         for attr in ('expects_localtime', 'is_safe', 'needs_autoescape'):
  27.             if attr in flags:
  28.                 value = flags[attr]
  29.                 # set the flag on the filter for FilterExpression.resolve
  30.                 setattr(filter_func, attr, value)
  31.                 # set the flag on the innermost decorated function
  32.                 # for decorators that need it, e.g. stringfilter
  33.                 if hasattr(filter_func, "_decorated_function"):
  34.                     setattr(filter_func._decorated_function, attr, value)
  35.         filter_func._filter_name = name
  36.         return filter_func
  37.     else:
  38.         raise ValueError(
  39.             "Unsupported arguments to Library.filter: (%r, %r)" %
  40.             (name, filter_func),
  41.         )
  43. def filter_function(self, func, **flags):
  44.     name = getattr(func, "_decorated_function", func).__name__
  45.     return self.filter(name, func, **flags)

2 simple_tag

第一个参数：self是Library对象

第二个参数： func这个是函数

第三个参数：take_context获取上下文

【源码】

  1.     def simple_tag(self, func=None, takes_context=None, name=None):
  2.         """
  3.         Register a callable as a compiled template tag. Example:
  5.         @register.simple_tag
  6.         def hello(*args, **kwargs):
  7.             return 'world'
  8.         """
  9.         def dec(func):
  10.             params, varargs, varkw, defaults, kwonly, kwonly_defaults, _ = getfullargspec(func)
  11.             function_name = (name or getattr(func, '_decorated_function', func).__name__)
  13.             @functools.wraps(func)
  14.             def compile_func(parser, token):
  15.                 bits = token.split_contents()[1:]
  16.                 target_var = None
  17.                 if len(bits) >= 2 and bits[-2] == 'as':
  18.                     target_var = bits[-1]
  19.                     bits = bits[:-2]
  20.                 args, kwargs = parse_bits(
  21.                     parser, bits, params, varargs, varkw, defaults,
  22.                     kwonly, kwonly_defaults, takes_context, function_name,
  23.                 )
  24.                 return SimpleNode(func, takes_context, args, kwargs, target_var)
  25.             self.tag(function_name, compile_func)
  26.             return func
  28.         if func is None:
  29.             # @register.simple_tag(...)
  30.             return dec
  31.         elif callable(func):
  32.             # @register.simple_tag
  33.             return dec(func)
  34.         else:
  35.             raise ValueError("Invalid arguments provided to simple_tag")

【业务代码】

  1. from django import template
  3. register = template.library()
  5. def mycut(value, arg):
  6.     return value.replace(arg, '')
  7. register.filter('mycut', mycut)
  9. @register.filter
  10. def mylower(value):
  11.     return value.lower()

【在模板中使用自定义的过滤器】

需要使用{%load%}标签将我们自定义模块加载进来，{%load%}声明将会载入给定模块名中的标签/过滤器

  1. {%load common_extras%}
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>自定义过滤器及标签</title>
  7. </head>
  8. <body>
  9. {{ts|mylower}}<br>
  10. {{ts|mycut:''}}<br>
  11. </body>
  12. </html>

【代码演示】

在book/views.py文件中定义类—-调用HTML网页文件

【自定义过滤器前端效果】

【show_tag()标签的使用】

业务逻辑

  1. 在与views.py同级目录下创建文件夹templatetags，然后在其中创建init.py便于将此文件夹视为一个函数包，然后再创建一个customtag.py文件，用于在此处自定义标签和过滤器
  2. 首先在customtag中导入template.Library()便于对标签进行函数实例注册
  3. 然后就可以在该文件中自定义标签和装饰器
  4. 访问逻辑
  5. 首先从浏览器中输入正确的URL,输入值与项目urlpattern匹配
  6. 然后进入views.py文件中调用合适的类
  7. 在类中返回特定HTML5网页渲染
  8. 在HTML5文件中首先引入模板标签和过滤器，然后以指定标签格式调用已经定义好的模板标签和过滤器
    代码含义：
    参考与引用 
    1. @register.simple_tag(name='current_time1')  # 用于向Library注册实例，其后的name就是我们定义的类的名字
    2. def current_time1(format_string):  # 用于在网页上展示时间
    3. print(format_string)  # 格式化字符串就是我们在H5中定义的现实格式：%Y 年 %m 月 %I 时 %M 分 %p
    4. return datetime.now().strftime(format_string)  #

首先在common_extra中创建类，利用return语句返回字典对象

  1. def common(request):
  2.     ts = 'YKK   seasame'
  3.     return render(request, 'loads.html', context={
  4.         'ts': ts,
  5.     })

然后在HTML5文件中使用模板标签调用

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>show_tag标签的使用</title>
  6. </head>
  7. <body>
  8. <ul>
  9.     {% for i in choices %}
  10.         <li>{{ i }}</li>
  11.     {% endfor %}
  12. </ul>
  13. </body>
  14. </html>

其次在views视图下创建类，以HTML5为返回对象

  1. def show_tag(request):
  3.     return render(request, 'show_tag.html')

inclusion_tag()装饰器的使用

文件路径：Library.py[136]

定义：

  1.     def inclusion_tag(self, filename, func=None, takes_context=None, name=None):
  2.         """
  3.         Register a callable as an inclusion tag:
  5.         @register.inclusion_tag('results.html')
  6.         def show_results(poll):
  7.             choices = poll.choice_set.all()
  8.             return {'choices': choices}

【源码阅读】

渲染器的处理逻辑

  1. import functools
  2. import os
  4. from django.conf import settings
  5. from django.template.backends.django import DjangoTemplates
  6. from django.template.loader import get_template
  7. from django.utils.functional import cached_property
  8. from django.utils.module_loading import import_string
  10. try:
  11.     from django.template.backends.jinja2 import Jinja2
  12. except ImportError:
  13.     def Jinja2(params):
  14.         raise ImportError("jinja2 isn't installed")
  16. ROOT = os.path.dirname(__file__)
  19. @functools.lru_cache()
  20. def get_default_renderer():
  21.     renderer_class = import_string(settings.FORM_RENDERER)
  22.     return renderer_class()
  25. class BaseRenderer:
  26.     def get_template(self, template_name):
  27.         raise NotImplementedError('subclasses must implement get_template()')
  29.     def render(self, template_name, context, request=None):
  30.         template = self.get_template(template_name)
  31.         return template.render(context, request=request).strip()
  34. class EngineMixin:
  35.     def get_template(self, template_name):
  36.         return self.engine.get_template(template_name)
  38.     @cached_property
  39.     def engine(self):
  40.         return self.backend({
  41.             'APP_DIRS': True,
  42.             'DIRS': [os.path.join(ROOT, self.backend.app_dirname)],
  43.             'NAME': 'djangoforms',
  44.             'OPTIONS': {},
  45.         })
  48. class DjangoTemplates(EngineMixin, BaseRenderer):
  49.     """
  50.     Load Django templates from the built-in widget templates in
  51.     django/forms/templates and from apps' 'templates' directory.
  52.     """
  53.     backend = DjangoTemplates
  56. class Jinja2(EngineMixin, BaseRenderer):
  57.     """
  58.     Load Jinja2 templates from the built-in widget templates in
  59.     django/forms/jinja2 and from apps' 'jinja2' directory.
  60.     """
  61.     backend = Jinja2
  64. class TemplatesSetting(BaseRenderer):
  65.     """
  66.     Load templates using template.loader.get_template() which is configured
  67.     based on settings.TEMPLATES.
  68.     """
  69.     def get_template(self, template_name):
  70.         return get_template(template_name)

LRU算法的实现

  1. def lru_cache(maxsize=128, typed=False):
  2.     """Least-recently-used cache decorator.
  4.     If *maxsize* is set to None, the LRU features are disabled and the cache
  5.     can grow without bound.
  7.     If *typed* is True, arguments of different types will be cached separately.
  8.     For example, f(3.0) and f(3) will be treated as distinct calls with
  9.     distinct results.
  11.     Arguments to the cached function must be hashable.
  13.     View the cache statistics named tuple (hits, misses, maxsize, currsize)
  14.     with f.cache_info().  Clear the cache and statistics with f.cache_clear().
  15.     Access the underlying function with f.__wrapped__.
  17.     See:  http://en.wikipedia.org/wiki/Cache_algorithms#Least_Recently_Used
  19.     """
  21.     # Users should only access the lru_cache through its public API:
  22.     #       cache_info, cache_clear, and f.__wrapped__
  23.     # The internals of the lru_cache are encapsulated for thread safety and
  24.     # to allow the implementation to change (including a possible C version).
  26.     # Early detection of an erroneous call to @lru_cache without any arguments
  27.     # resulting in the inner function being passed to maxsize instead of an
  28.     # integer or None.
  29.     if maxsize is not None and not isinstance(maxsize, int):
  30.         raise TypeError('Expected maxsize to be an integer or None')
  32.     def decorating_function(user_function):
  33.         wrapper = _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo)
  34.         return update_wrapper(wrapper, user_function)
  36.     return decorating_function
  38. def _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo):
  39.     # Constants shared by all lru cache instances:
  40.     sentinel = object()          # unique object used to signal cache misses
  41.     make_key = _make_key         # build a key from the function arguments
  42.     PREV, NEXT, KEY, RESULT = 0, 1, 2, 3   # names for the link fields
  44.     cache = {}
  45.     hits = misses = 0
  46.     full = False
  47.     cache_get = cache.get    # bound method to lookup a key or return None
  48.     cache_len = cache.__len__  # get cache size without calling len()
  49.     lock = RLock()           # because linkedlist updates aren't threadsafe
  50.     root = []                # root of the circular doubly linked list
  51.     root[:] = [root, root, None, None]     # initialize by pointing to self
  53.     if maxsize == 0:
  55.         def wrapper(*args, **kwds):
  56.             # No caching -- just a statistics update after a successful call
  57.             nonlocal misses
  58.             result = user_function(*args, **kwds)
  59.             misses += 1
  60.             return result
  62.     elif maxsize is None:
  64.         def wrapper(*args, **kwds):
  65.             # Simple caching without ordering or size limit
  66.             nonlocal hits, misses
  67.             key = make_key(args, kwds, typed)
  68.             result = cache_get(key, sentinel)
  69.             if result is not sentinel:
  70.                 hits += 1
  71.                 return result
  72.             result = user_function(*args, **kwds)
  73.             cache[key] = result
  74.             misses += 1
  75.             return result
  77.     else:
  79.         def wrapper(*args, **kwds):
  80.             # Size limited caching that tracks accesses by recency
  81.             nonlocal root, hits, misses, full
  82.             key = make_key(args, kwds, typed)
  83.             with lock:
  84.                 link = cache_get(key)
  85.                 if link is not None:
  86.                     # Move the link to the front of the circular queue
  87.                     link_prev, link_next, _key, result = link
  88.                     link_prev[NEXT] = link_next
  89.                     link_next[PREV] = link_prev
  90.                     last = root[PREV]
  91.                     last[NEXT] = root[PREV] = link
  92.                     link[PREV] = last
  93.                     link[NEXT] = root
  94.                     hits += 1
  95.                     return result
  96.             result = user_function(*args, **kwds)
  97.             with lock:
  98.                 if key in cache:
  99.                     # Getting here means that this same key was added to the
  100.                     # cache while the lock was released.  Since the link
  101.                     # update is already done, we need only return the
  102.                     # computed result and update the count of misses.
  103.                     pass
  104.                 elif full:
  105.                     # Use the old root to store the new key and result.
  106.                     oldroot = root
  107.                     oldroot[KEY] = key
  108.                     oldroot[RESULT] = result
  109.                     # Empty the oldest link and make it the new root.
  110.                     # Keep a reference to the old key and old result to
  111.                     # prevent their ref counts from going to zero during the
  112.                     # update. That will prevent potentially arbitrary object
  113.                     # clean-up code (i.e. __del__) from running while we're
  114.                     # still adjusting the links.
  115.                     root = oldroot[NEXT]
  116.                     oldkey = root[KEY]
  117.                     oldresult = root[RESULT]
  118.                     root[KEY] = root[RESULT] = None
  119.                     # Now update the cache dictionary.
  120.                     del cache[oldkey]
  121.                     # Save the potentially reentrant cache[key] assignment
  122.                     # for last, after the root and links have been put in
  123.                     # a consistent state.
  124.                     cache[key] = oldroot
  125.                 else:
  126.                     # Put result in a new link at the front of the queue.
  127.                     last = root[PREV]
  128.                     link = [last, root, key, result]
  129.                     last[NEXT] = root[PREV] = cache[key] = link
  130.                     # Use the cache_len bound method instead of the len() function
  131.                     # which could potentially be wrapped in an lru_cache itself.
  132.                     full = (cache_len() >= maxsize)
  133.                 misses += 1
  134.             return result
  136.     def cache_info():
  137.         """Report cache statistics"""
  138.         with lock:
  139.             return _CacheInfo(hits, misses, maxsize, cache_len())
  141.     def cache_clear():
  142.         """Clear the cache and cache statistics"""
  143.         nonlocal hits, misses, full
  144.         with lock:
  145.             cache.clear()
  146.             root[:] = [root, root, None, None]
  147.             hits = misses = 0
  148.             full = False
  150.     wrapper.cache_info = cache_info
  151.     wrapper.cache_clear = cache_clear
  152.     return wrapper
  154. try:
  155.     from _functools import _lru_cache_wrapper
  156. except ImportError:
  157.     pass

官方文档补充

1.【与过滤器相关的字符串】

1，将参数强制转换为字符串

自定义过滤器部分的代码书写（文件路径：templatetags/extra_tags）

  1. from django.template.defaultfilters import stringfilter  # 用于将传递给类的参数强制转换为字符串
  4. register = template.Library()
  6. @register.filter
  7. @stringfilter
  8. def lower(value):
  9.     return value.lower()

在视图中为该过滤器传入参数(项目下或者app下的均可)

  1. def self_register(request):
  2.     fstring = ('Today', '20170912')
  3.     return render(request, 'load.html', context={'fstring': fstring})

与其匹配的合适URL路径

  1.     path('selfre/',views.self_register, name='self_register'),

HTML中调用过滤器（从view导入的参数）

  1. {% load extra_tags %}
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>自定义模板标签</title>
  7. </head>
  8. <body>
  9. <p>强制转换为字符串格式</p>
  10. {{fstring|lower}}
  11. </body>
  12. </html>

功能说明

  1. ### 强制将传入对象转换为字符串---包括数字，元组，字符串本身
  2. ### 该功能的实现需要导入对应的字符串过滤器，同时使用装饰器注册过滤器已经使用装饰器形式的字符串过滤器

2，自动转义—-安全字符串

自动转义功能的过滤器书写（templatetags/extra_tags）

  1. from django.utils.html import conditional_escape
  2. from django.utils.safestring import mark_safe
  5. register = template.Library()
  7. @register.filter(needs_autoescape=True)  # 参数实际上是一个flag(标记)
  8. def initial_letter_filter(text, autoescape=True):  # 传入参数，一个设置，自动转义已经开启
  9.     """
  10.     安全字符串指的是：可以被安全展示，无需HTML引擎进行转换
  11.     """
  12.     first, other = text[0], text[1:]  # 分别将传入的列表对象赋值给两个变量
  13.     if autoescape:
  14.         esc = conditional_escape  # 如果是
  15.     else:
  16.         esc = lambda x: x  # 如果没有自动转义则显示原文
  17.     result = '<strong>%s  </strong>%s' % (esc(first), esc(other))  # 以格式化字符串的方式展示
  18.     return mark_safe(result)  # 将已经完成转义的字符串标记为安全字符串

视图函数中的传值和调用

  1. def safe_string(request):
  2.     safe_string = ['Javascript', 'Python', 'Django', 'Flask', 'M&G']
  3.     return render(request, 'load.html', context={'safe_string': safe_string})

URL对视图的调用

  1. path('safestring/',views.safe_string, name='safe_string'),

HTML中使用过滤器（指定过滤器名字和传入的变量[由view视图传入]）

  1. {% load extra_tags %}
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>自定义模板标签</title>
  7. </head>
  8. <body>
  9. <p>安全字符串---自动转义</p>
  10. {{safe_string|initial_letter_filter}}
  11. </body>
  12. </html>

【补充】—- 安全字符串的定义

  1. """
  2. Functions for working with "safe strings": strings that can be displayed safely
  3. without further escaping in HTML. Marking something as a "safe string" means
  4. that the producer of the string has already turned characters that should not
  5. be interpreted by the HTML engine (e.g. '<') into the appropriate entities.
  6. """
  7. """
  8. 这个函数和安全字符串一起运行：安全字符串能够被安全展示，无需进一步从HTML转义。
  9. 将变量标记为安全字符串意味着：字符串的生产者已经将字符转换，它就不会需要HTML的引擎将其解释为合适的实体
  10. """
  12. from functools import wraps
  15. class SafeData:
  16.     def __html__(self):
  17.         """
  18.         Return the html representation of a string for interoperability.
  20.         This allows other template engines to understand Django's SafeData.
  21.         """
  22.         return self
  25. [文档]class SafeString(str, SafeData):
  26.     """
  27.     A str subclass that has been specifically marked as "safe" for HTML output
  28.     purposes.
  29.     """
  30.     def __add__(self, rhs):
  31.         """
  32.         Concatenating a safe string with another safe bytestring or
  33.         safe string is safe. Otherwise, the result is no longer safe.
  34.         """
  35.         t = super().__add__(rhs)
  36.         if isinstance(rhs, SafeData):
  37.             return SafeString(t)
  38.         return t
  40.     def __str__(self):
  41.         return self
  45. SafeText = SafeString  # For backwards compatibility since Django 2.0.
  48. def _safety_decorator(safety_marker, func):
  49.     @wraps(func)
  50.     def wrapped(*args, **kwargs):
  51.         return safety_marker(func(*args, **kwargs))
  52.     return wrapped
  55. [文档]def mark_safe(s):
  56.     """
  57.     Explicitly mark a string as safe for (HTML) output purposes. The returned
  58.     object can be used everywhere a string is appropriate.
  60.     If used on a method as a decorator, mark the returned data as safe.
  62.     Can be called multiple times on a single string.
  63.     """
  64.     if hasattr(s, '__html__'):
  65.         return s
  66.     if callable(s):
  67.         return _safety_decorator(mark_safe, s)
  68.     return SafeString(s)

参考与引用