\n\n定制自定义模板 tags 和 filters 的位置就是 Django 应用内。如果它们关联至某个已存在的应用，在那里将它们打包就很有用；否则，它们能被添加至新应用。当一个 Django 应用被添加至 INSTALLED_APPS
\n该应用应包含一个 templatetags 目录，与 models.py， views.py 等同级。若该目录不存在，创建它——不要忘了用 __init__.py 文件确保目录被视作一个 Python 包。
\n\n自定义的 tags 和 filters 会保存在模块名为 templatetags 的目录内。模块文件的名字即稍候你用来加载 tags 的名字，所以小心不要采用一个可能与其它应用自定义的 tags 和 filters 冲突的名字。
\n例如，如果你的自定义标签/过滤器位于一个名为 poll_extras.py 的文件中，你的应用程序布局可能如下所示：
\nText Copy
polls/\n __init__.py\n models.py\n templatetags/\n __init__.py\n poll_extras.py\n views.py\n在模板中你会使用以下代码：
\nDjango template Copy
{% load poll_extras %} \n为了使 {% load %}INSTALLED_APPS
\n我们并未限制放入 templatetags 包中的模块数量。只需牢记 {% load %}
\n要成为一个可用的 tag 库，模块必须包含一个名为 register 的模块级变量，它是一个 template.Library 实例。所有的 tags 和 filters 均在其中注册。所以，在模块的开始，输入以下内容:
\nCode Copy
from django import template\n\nregister = template. Library() \n或者，模板标签模块能通过 DjangoTemplates'libraries' 参数注册。这在加载模板名字时，想为模板标签起个别名时很有用。这也让你能在未安装应用的情况下注册标签。
\n\n \n\n自定义的过滤器就是一些有一到两个参数的 Python 函数：
\n\n（输入的）变量的值，不一定得是字符串类型
而参数的值，它们可以有一个默认值，或者被排除在外
\n举个例子，在过滤器 {{ var|foo:"bar" }} 中，变量 var 和参数 bar 会传递给过滤器 foo。
\n因为模板语言不提供异常处理机制，所以任何从模板过滤器中抛出的异常都将被视为服务器异常。因此，如果有一个合理的返回值将要被返回的话，过滤器函数应当避免产生异常。万一模板中出现有明显错误的输入，产生异常也仍然比隐藏这个 bug 要好。
\n这是一个过滤器定义的例子:
\nCode Copy
def cut ( value, arg): \n """Removes all values of arg from the given string""" \n return value. replace( arg, "" ) \n这个例子展示了如何使用这个过滤器：
\nDjango template Copy
{{ somevariable | cut :"0" }} \n大部分的过滤器并没有参数。这样的话，只需要把这些参数从你的函数中去掉就好。
\nCode Copy
def lower ( value): # Only one argument. \n """Converts a string into all lowercase""" \n return value. lower() \n\n\n\n\ndjango.template.Library. filter ( ) Link to this definition # \n \n\n每当你写好你的过滤器定义的时候，你需要用你的 Library 实例去注册它，从而让它对于 Django 模板语言而言是可用的
\nCode Copy
register. filter( "cut" , cut) \nregister. filter( "lower" , lower) \nLibrary.filter() 方法有两个参数：
\n\n过滤器的名称——字符串。
编辑函数——一个 Python 函数（不是函数名的字符串）。
\n你也能以装饰器的模式使用 register.filter():
\nCode Copy
@register . filter( name= "cut" ) \ndef cut ( value, arg): \n return value. replace( arg, "" ) \n\n\n@register . filter\ndef lower ( value): \n return value. lower() \n若你不填 name 参数，像第二个例子展示的一样，Django 会将函数名当做过滤器名。
\n最后， register.filter() 也接受 3 个关键字参数， is_sage， needs_autoescape，和 expects_localtime。这些参数在下面的 过滤器和自动转义 过滤器和时区
\n \n\n\n\n\ndjango.template.defaultfilters. stringfilter ( ) Link to this definition # \n \n\n如果编写只接收一个字符串作为第一个参数的模板过滤器，你需要使用 stringfilter 的装饰器。它会将参数前转为字符串后传递给函数:
\nCode Copy
from django import template\nfrom django.template.defaultfilters import stringfilter\n\nregister = template. Library() \n\n\n@register . filter\n@stringfilter \ndef lower ( value): \n return value. lower() \n这样，您就可以将一个整数传递给这个过滤器，而不会导致 AttributeError (因为整数没有 lower() 方法)。
\n \n\n编写自定义过滤器时，考虑一下过滤器将如何与 Django 的自动转义行为交互。
\n\n原始字符串 指原生 Python 字符串。在输出时，如果自动转义生效，则对它们进行转义，否则将保持不变。
安全字符串 是在输出时被标记为安全的字符串，不会进一步转义。必要的转义已在之前完成。它们通常用于原样输出 HTML，HTML 会在客户端被解释。
\n实质上，这些字符串是 SafeString
\nCode Copy
from django.utils.safestring import SafeString\n\nif isinstance ( value, SafeString): \n # Do something with the "safe" string. \n ... \n \n模板过滤器代码有两种情况：
\n\n你的过滤器不会将任何 HTML 不安全的字符(<, >, ', " or &)引入尚未出现的结果中。这种情况下，可以让 Django 自动为您处理所有的转义操作。你只需在注册自己的过滤器函数时，将 is_safe 标志置为 True，像这样:
\nCode Copy
@register . filter( is_safe= True ) \ndef myfilter ( value): \n return value\n该标志告诉 Django，若一个“安全”字符串传给您的过滤器，结果仍会是安全的。若传入了不安全的字符串，Django 会在需要时自动转义。
\n你可以这么认为，“过滤器是安全的——它不会产生任何不安全的 HTML。”
\n一定要 is_safe 的原因是大量的字符串操作会将 SafeData 对象返回为普通 str 对象，而不是尝试全部捕获（挺难的），Django 在过滤完成后尝试修复这些损伤。
\n举例来说，假定有个过滤器，会在任何输入后追加 xx。由于此操作不会在结果产生任何 HTML 危险的字符（除了那些已存在的），你需要用 is_safe 标记你的过滤器:
\nCode Copy
@register . filter( is_safe= True ) \ndef add_xx ( value): \n return " %s xx" % value\n当该过滤器对某个启用了自动转义的模板生效时，Django 会对输出自动转义，不管输入是否被标记为“安全的”。
\n默认情况下， is_sate 为 False，你可以为不要求此项的过滤器忽略它。
\n在确定过滤器是否确实将安全字符串保留为安全字符串时要千万小心。如果你正在 删除 字符，你可能不经意的在结果中留下不成对的 HTML 标记或实体。例如，从输入中删除一个 > 可能将 <a> 转为 <a，后者可能需要转移，避免导致输出错误。类似的，删除一个分号(;)会将 & 转为 &，后者不再是一个有效的实体，因此需要转义。大多数情况下都没这么复杂，但是检查代码时要注意类似的问题。
\n标记过滤器的 is_safe 会强制该过滤器的返回值为字符串。如果你的过滤器要返回一个布尔值或非字符串值，将其标记为 is_safe 可能会导致出乎意料的结果（类似将一个布尔值 False 转为字符串 'False'）。
\n或者，你的过滤器代码要手动关注必须的转义操作。这在输出新 HTML 标记时是必须的。想要避免你的 HTML 标记不被后续操作转义，你要将输出标记为安全的，且需要自己处理输入。
\n要将输出标记为安全字符串，使用 django.utils.safestring.mark_safe()
\n不过还是要小心，你要做的不只是将输出标记为安全的。你需要确保它 真的是 安全的，你所做的取决于自动转义是否生效。理想状态下，编写的过滤器在自动转义开启与关闭的情况下均能正确的操作模板，这样模板作者用起来就更简单了。
\n为了让你的过滤器知道自动转移开关的状态，在你注册过滤器函数时将 needs_autoescape 标志（默认 False）设置为 True。该标志告诉 Django 过滤器函数额外接受一个名为 autoescape 关键字参数，值为 True 时说明自动转义生效中， False 说明关闭。推荐将 autoescape 参数的默认值设为 True，这样，从 Python 代码调用此函数时，默认开启自动转义功能。
\n例子，让我们编写一个强制大写字符串的首字母的过滤器:
\nCode Copy
from django import template\nfrom django.utils.html import conditional_escape\nfrom django.utils.safestring import mark_safe\n\nregister = template. Library() \n\n\n@register . filter( needs_autoescape= True ) \ndef initial_letter_filter ( text, autoescape= True ): \n first, other = text[ 0 ], text[ 1 :] \n if autoescape: \n esc = conditional_escape\n else : \n esc = lambda x: x\n result = "<strong> %s </strong> %s " % ( esc( first), esc( other)) \n return mark_safe( result) \nneeds_autoescape 标志和 autoescape 自动转义关键字参数意味着函数会在过滤器被调用时知道自动转义是否生效。我们利用 autoescape 来决定是否要将输入数据传递给 django.utils.html.conditional_escape。（后续实例中，我们使用同一函数作为“转义”函数。） conditional_escape() 函数除了它只转义 不是 一个 SafeData 的实例的输入之外其他等同于 escape() 。如果一个 SafeData 实例经过 conditional_escape() ，数据将会不经过修改返回。
\n最后，在上述例子中，我们牢记将结果标为安全的，所以 HMTL 未经转义就直接插入模板中。
\n这种场景下无需担心 is_safe 标志（虽然包含它不会有什么问题）。无论你何时决定手动处理自动转义，并返回安全字符串， is_safe 标志不会有任何影响。
\n \n\nWarning
\n在重用内置过滤器时避免 XSS 漏洞
\nDjango 内置的过滤器默认配置 autoescape=True，获取合适的自动转义行为，并避免跨站脚本漏洞。
\n在旧版本的 Django 中，复用 Django 内置过滤器时要小心，因为 自动转义 默认为 None。你需要传入 autoescape=True 启用自动转义。
\n举个例子，如果你想编写一个联合 urlizelinebreaksbrurlize_and_linebreaks 的自定义过滤器，可通过以下代码:
\nCode Copy
from django.template.defaultfilters import linebreaksbr, urlize\n\n\n@register . filter( needs_autoescape= True ) \ndef urlize_and_linebreaks ( text, autoescape= True ): \n return linebreaksbr( urlize( text, autoescape= autoescape), autoescape= autoescape) \n接下来：
\nDjango template Copy
{{ comment | urlize_and_linebreaks }} \n等价于：
\nDjango template Copy
{{ comment | urlize | linebreaksbr }} \n \n \n\n如果你编写了一个自定义过滤器，处理 datetimeexpects_localtime 标志置为 True:
\nCode Copy
@register . filter( expects_localtime= True ) \ndef businesshours ( value): \n try : \n return 9 <= value. hour < 17 \n except AttributeError : \n return "" \n设置该标志后，如果过滤器接收的第一个参数是一个时区敏感的 datetime，Django 在将其传递给过滤器前的某个合适时间将其转换为当前时区的时间，依据 模板中的时区转换规则
\n \n \n\n标签比过滤器更复杂，因为标签啥都能做。Django 提供了很多快捷方式，简化了编写绝大多数类型的标签过程。我们先探索这些快捷方式，然后解释如何在快捷方式不够强大的情况下从零编写标签。
\n\n\n\n\n\ndjango.template.Library. inclusion_tag ( ) Link to this definition # \n \n\n另一种常见的模板标签会为 另一个 模板渲染数据。例如， Django 的后台利用自定义模板标签在表单页的底部展示按钮。这些按钮看起来一样，但是连接目标根据被编辑的对象不同而不同——所以，这是一个极好的例子，展示如何用当前对象的细节填充小模板。（在后台例子中，即 submit_row 标签。）
\n这种标签被称为“包含标签”。
\n编写包含标签可能最好通过实例来展示。让我们编写一个标签，它会将指定 Poll 对象（就像 教程
\nDjango template Copy
{% show_results poll %} \n输出看起来像这样：
\nHtml Copy
< ul > \n < li > First choice</ li > \n < li > Second choice</ li > \n < li > Third choice</ li > \n</ ul > \n首先，定义一个函数，接受参数，并返回一个字典。此处的要点是我们只需返回一个字典，不是任何其它复杂的东西。这将作为一个模板上下文被模板碎片使用。例子:
\nCode Copy
def show_results ( poll): \n choices = poll. choice_set. all() \n return { "choices" : choices} \n随后，创建用于渲染标签输出的模板。该模板是标签的一个固有特性：标签作者指定它，而不是模板设计者。跟随我们的例子，模板非常简短：
\nDjango template Copy
< ul > \n{% for choice in choices %} \n < li > {{ choice }} </ li > \n{% endfor %} \n</ ul > \n现在，在 Library 对象上调用 inclusion_tag() 创建并注册该包含标签。如果上述模板位于一个名为 results.html 的文件中，在模板加载器搜索的目录中，我们像这样注册该标签:
\nCode Copy
# Here, register is a django.template.Library instance, as before \n@register . inclusion_tag( "results.html" ) \ndef show_results ( poll): ... \n或者，也能用 django.template.Template
\nCode Copy
from django.template.loader import get_template\n\nt = get_template( "results.html" ) \nregister. inclusion_tag( t)( show_results) \n在第一次创建该函数时。
\n有时候，你的包含标签可能要求超多参数，模板作者不得不传入所有参数，并牢记它们的顺序，非常痛苦。为了解决此问题， Django 为包含标签提供了一个 take_context 选项。如果在创建模板标签时指定了 takes_context，该标签将没有必要的参数，底层 Python 函数将只有一个参数——标签创建时的模板上下文。
\n举个例子，假设你编写了一个包含标签，总会在一个包含指向首页的 home_link 和 home_title 的上下文环境下使用。Python 函数看起来会像这样:
\nCode Copy
@register . inclusion_tag( "link.html" , takes_context= True ) \ndef jump_link ( context): \n return { \n "link" : context[ "home_link" ], \n "title" : context[ "home_title" ], \n } \n注意，该函数的第一个参数 必须 是 context。
\n在 register.inclusion_tag() 行，我们制定了模板名并设置 takes_context=True。以下是模板 link.html 的样子：
\nDjango template Copy
Jump directly to < a href = " {{ link }} " > {{ title }} </ a > .\n后面，当你想用该自定义标签时，加载它的库，并不带任何参数的调用它，像这样：
\nDjango template Copy
{% jump_link %} \n注意，只要使用了 takes_context=True，就无需为模板标签传递参数。它自动从上下文获取。
\ntakes_context 参数默认为 False。当其为 True，标签会被传入上下文对象，像本例展示的那样。这是本例和之前的 包含标签 实例的唯一不同之处。
\n包含标签 函数能接受任意个数的位置或关键字参数。例子:
\nCode Copy
@register . inclusion_tag( "my_template.html" ) \ndef my_tag ( a, b, * args, ** kwargs): \n warning = kwargs[ "warning" ] \n profile = kwargs[ "profile" ] \n ... \n return ... \n随后在模板中，任意数量的，以空格分隔的参数会被传递给模板标签。与 Python 中类似，关键字参数的赋值使用等号（"="），且必须在位置参数后提供。例子：
\nDjango template Copy
{% my_tag 123 "abcd" book.title warning = message | lower profile = user.profile %} \n \n\n\n\n模板系统工作只需两步：编译和渲染。为了定义自定义模板标签，你需指定如何编译和渲染。
\nDjango 编译模板时，会将原始模板文本划为“节点”。每个节点都是一个 django.template.Node 实例，拥有一个 render() 方法。编译完的模板就是一个包含 节点 对象的列表。当你在已编译的模板上调用 render()，该模板会为节点列表中的每个 节点 携带指定上下文调用 render() 方法。结果会自动连接，形成模板的输出。
\n因此，要定义一个自定义模板标签，你要指定如何将原始模板标签转换为 节点 （编译函数），还要指定 render() 方法的操作。
\n \n\n\n模板解析器遇到的每个模板标签，解析器都会调用一个 Python 函数，参数是标签内容和解析器对象本身。该函数需要基于标签的内容返回一个 节点 实例。
\n举个例子，让我们完整地实现模板标签 {% current_time %}，该标签根据标签中指定的参数，以 strftime()
\nDjango template Copy
< p > The time is {% current_time "%Y-%m-%d %I:%M %p" %} .</ p > \n这个函数的解析器应用获取参数，并创建一个 节点 对象:
\nCode Copy
from django import template\n\n\ndef do_current_time ( parser, token): \n try : \n # split_contents() knows not to split quoted strings. \n tag_name, format_string = token. split_contents() \n except ValueError : \n raise template. TemplateSyntaxError( \n " %r tag requires a single argument" % token. contents. split()[ 0 ] \n ) \n if not ( format_string[ 0 ] == format_string[ - 1 ] and format_string[ 0 ] in ( '"' , "'" )): \n raise template. TemplateSyntaxError( \n " %r tag's argument should be in quotes" % tag_name\n ) \n return CurrentTimeNode( format_string[ 1 : - 1 ]) \n注意：
\n\nparser 是模板解析器对象。本例中不需要。
token.contents 是包含标签原始内容的字符串。本例中是 'current_time "%Y-%m-%d %I:%M %p"'。
token.split_contents() 方法按空格分隔字符串，但不会分隔引号包裹的部分。二愣子 token.contents.split() 就没那么健壮了，它直接在空格处分割字符串，不论它们是否被引号包裹。推荐总是使用 token.split_contents()。
该方法要在语法错误发生时抛出包含有用信息的 django.template.TemplateSyntaxError。
TemplateSyntaxError 异常使用了 tag_name 变量。不要在错误消息中硬编码标签名，因为这会使的标签名与函数耦合。 token.contents.split()[0] 总会返回标签名——即便标签没有参数。
该函数返回一个 CurrentTimeNode，内含节点需要了解的标签的一切信息。在本例中，传递了参数—— "%Y-%m-%d %I:%M %p"。开头和结尾的引号由 format_string[1:-1] 删除。
这种解析是很低级的。Django 开发者已试着在该解析系统之上编写小型解析框架，使用类似 EBNF 语法，但这些尝试使得模板引擎运行的很慢。低级意味着快。
\n \n\n\n编写自定义标签的第二步是定义一个 Node 子类，带有一个 render() 方法。
\n承接上述例子，我们需要定义 CurrentTimeNode:
\nCode Copy
import datetime \nfrom django import template\n\n\nclass CurrentTimeNode ( template. Node): \n def __init__ ( self , format_string): \n self . format_string = format_string\n\n def render ( self , context): \n return datetime. datetime. now() . strftime( self . format_string) \n注意：
\n\n__init__() 从 do_current_time() 获取 format_string。总是通过 节点 的 __init__() 方法为其传入 options/parameters/arguments。
render() 方法是实际干活的地方。
render() 应该无声失败，尤其是在生产环境。不过，某些场景下，尤其是 context.template.engine.debug 为 True 时，该方法可能抛出一个异常，简化调式流程。例如，某些核心标签在接受个数不对的参数时抛出 django.template.TemplateSyntaxError。
\n最终，这种对编译和渲染的解耦会产生一个高效的模板系统，因为一个模板无需多次解析就能渲染多个上下文。
\n \n\n模板标签的输出 不会 自动通过自动转义过滤器（除了上述的 simple_tag()
\n若模板标签的 render() 方法在上下文变量中存储结果（而不是以字符串返回结果），它要小心地在合适的时机调用 mark_safe()。当变量最后一次被渲染时，它会在这个时候受到自动转义配置的影响，所以为了避免变量被进一步转义，需要如此配置。
\n同理，如果你的模板标签为某些子渲染进程创建了新的上下文，那么就需要将当前上下文对应的自动转义属性传入。 Context 类的方法 __init__ 的参数 autoescape 就是为此目的设计的。例如:
\nCode Copy
from django.template import Context\n\n\ndef render ( self , context): \n # ... \n new_context = Context({ "var" : obj}, autoescape= context. autoescape) \n # ... Do something with new_context ... \n该场景不常见，但在自助渲染模板时很有用。例如:
\nCode Copy
def render ( self , context): \n t = context. template. engine. get_template( "small_fragment.html" ) \n return t. render( Context({ "var" : obj}, autoescape= context. autoescape)) \n在本例中，如果我们忽略了将当前的 context.autoescape 值传递给新 Context，结果 总会 被自动转义，这可能与期望不同，尤其是模板标签被用于 {% autoescape off %}
\n \n\n节点被解析后，其 render 方法可能被任意次地调用。由于 Django 有可能运行于多线程环境，一个节点可能同时以不同的上下文进行渲染，以相应不同的请求。因此，确保你的模板标签是线程安全就非常重要了。
\n为了确保你的模板标签是线程安全的，你应该永远不要在节点中存储状态信息。例如，Django 提供了一个内置的 cycle
\nDjango template Copy
{% for o in some_list %} \n < tr class = " {% cycle 'row1' 'row2' %} " > \n ...\n </ tr > \n{% endfor %} \nCycleNode 的原生实现看起来可能像这样:
\nCode Copy
import itertools \nfrom django import template\n\n\nclass CycleNode ( template. Node): \n def __init__ ( self , cyclevars): \n self . cycle_iter = itertools. cycle( cyclevars) \n\n def render ( self , context): \n return next ( self . cycle_iter) \n但是，假设有两个模板渲染器同时渲染上述模板片段：
\n\n线程 1 执行其第一次迭代， CycleNode.render() 返回 'row1'
线程 2 执行其第一次迭代， CycleNode.render() 返回 'row2'
线程 1 执行其第二次迭代， CycleNode.render() 返回 'row1'
线程 2 执行其第二次迭代， CycleNode.render() 返回 'row2'
\nCycleNode 正在被迭代，却是全局范围的。就像线程 1 和线程 2 担心的那样，它们总是返回同样的值。这不是我们想要的。
\n为了定位此问题，Django 提供了一个 render_context，关联至当前正在渲染的模板的 context。 render_context 表现的像一个 Python 字典，应该在其中保存多次同时调用 render 方法时的 Node 状态。
\n让我们用 render_context 重构我们的 CycleNode 实现:
\nCode Copy
class CycleNode ( template. Node): \n def __init__ ( self , cyclevars): \n self . cyclevars = cyclevars\n\n def render ( self , context): \n if self not in context. render_context: \n context. render_context[ self ] = itertools. cycle( self . cyclevars) \n cycle_iter = context. render_context[ self ] \n return next ( cycle_iter) \n注意，将 Node 生命周期中都不会发生变化的全局信息保存为属性是非常安全的。在 CycleNode 例中， cyclevars 参数在 Node 初始化后就不会变了，所以无需将其放入 render_context。但是当前正在渲染的模板的状态信息，类似 CycleNode 的当前迭代信息，就应该被保存在 render_context。
\n\nNote
\n注意我们是如何利用 self 将 CycleNode 的特定参数装入 render_context 的。一个模板中可能有多个 CycleNodes，所以我们要十分小心，不要破坏其它节点的状态信息。最简单的方式就是一直将 self 作为键存入 render_context。如果你同时追踪好几个状态变量，将 render_context[self] 做成一个字典。
\n \n \n\n\n最后，用你的模块的 Library 实例注册该标签，像上文 编写自定义模板标签 1 介绍的那样。举个例子：
\nCode Copy
register. tag( "current_time" , do_current_time) \ntag 方法接收两个参数：
\n\n模板标签的名字——一个字符串。若为空，将会使用编译函数的名字。
编辑函数——一个 Python 函数（不是函数名的字符串）。
\n就像过滤器注册一样，这里也能用装饰器:
\nCode Copy
@register . tag( name= "current_time" ) \ndef do_current_time ( parser, token): ... \n\n\n@register . tag\ndef shout ( parser, token): ... \n若未输入 name 参数，像上述第二个例子一样，Django 会将函数名作为标签名。
\n \n\n\n虽然你能利用 token.split_contents() 将任意数量的变量传递给一个模板标签，但是解包出来的参数均是字符串文本。要将一个动态内容（一个模板变量）作为参数传递给模板标签需要额外工作。
\n前文的例子已经成功将当前时间转为字符串并将之返回，假设你想传入一个 DateTimeField
\nDjango template Copy
< p > This post was last updated at {% format_time blog_entry.date_updated "%Y-%m-%d %I:%M %p" %} .</ p > \n首先，token.split_contents() 会返回 3 个值：
\n\n标签名 format_time。
字符串 'blog_entry.date_updated' （不包含引号）。
格式化字符串 '"%Y-%m-%d %I:%M %p"'。 split_contents() 的返回值会为类似这样的字符串保留引号。
\n现在，你的标签应该看起来像这样:
\nCode Copy
from django import template\n\n\ndef do_format_time ( parser, token): \n try : \n # split_contents() knows not to split quoted strings. \n tag_name, date_to_be_formatted, format_string = token. split_contents() \n except ValueError : \n raise template. TemplateSyntaxError( \n " %r tag requires exactly two arguments" % token. contents. split()[ 0 ] \n ) \n if not ( format_string[ 0 ] == format_string[ - 1 ] and format_string[ 0 ] in ( '"' , "'" )): \n raise template. TemplateSyntaxError( \n " %r tag's argument should be in quotes" % tag_name\n ) \n return FormatTimeNode( date_to_be_formatted, format_string[ 1 : - 1 ]) \n你也需要修改 renderer，让其获取 blog_entry 对象的 date_updated 属性的真实内容。这能通过在 django.template 中使用 Variable() 完成。
\n要使用 Variable 类，用变量名实例化它，并调用 variable.resolve(context) 上下文。举个例子：
\nCode Copy
class FormatTimeNode ( template. Node): \n def __init__ ( self , date_to_be_formatted, format_string): \n self . date_to_be_formatted = template. Variable( date_to_be_formatted) \n self . format_string = format_string\n\n def render ( self , context): \n try : \n actual_date = self . date_to_be_formatted. resolve( context) \n return actual_date. strftime( self . format_string) \n except template. VariableDoesNotExist: \n return "" \n变量解决方案会在无法在当前页的上下文中找到指定字符串时抛出 VariableDoesNotExist 异常。
\n \n\n\n上述例子输出了一个值。一般来说，如果你的模板标签设置模板变量，会比直接输出更加灵活。这样，模板作者在你的模板标签创建时能复用这些值。
\n要在上下文中设置变量，需要在 render() 方法中对其上下文使用字典赋值。新版的 CurrentTimeNode 设置了一个模板变量 current_time，而不是直接输出:
\nCode Copy
import datetime \nfrom django import template\n\n\nclass CurrentTimeNode2 ( template. Node): \n def __init__ ( self , format_string): \n self . format_string = format_string\n\n def render ( self , context): \n context[ "current_time" ] = datetime. datetime. now() . strftime( self . format_string) \n return "" \n注意， render() 返回了空字符串。 render() 应该总是返回字符串。如果所有的模板标签都设置了变量， render() 应该返回空字符串。
\n下面是如何使用新版标签的实例：
\nDjango template Copy
{% current_time "%Y-%m-%d %I:%M %p" %} < p > The time is {{ current_time }} .</ p > \n\n上下文中的变量作用域
\n上下文内变量仅在模板中相同 block 内生效。这是故意的；提供有作用域的变量不会与其它区块中的上下文发生冲突。
\n \n但是， CurrentTimeNode2 有个问题：变量名 current_time 是硬编码的。这意味着你需要确认模板未在其它地方使用 {{ current_time }}，因为 {% current_time %} 会绑定兵重写该变量的值。一个简洁的方法是让模板标签指定输出变量的值，像这样：
\nDjango template Copy
{% current_time "%Y-%m-%d %I:%M %p" as my_current_time %} \n< p > The current time is {{ my_current_time }} .</ p > \n为此，你需要重构编译函数和 Node 类，像这样:
\nCode Copy
import re \n\n\nclass CurrentTimeNode3 ( template. Node): \n def __init__ ( self , format_string, var_name): \n self . format_string = format_string\n self . var_name = var_name\n\n def render ( self , context): \n context[ self . var_name] = datetime. datetime. now() . strftime( self . format_string) \n return "" \n\n\ndef do_current_time ( parser, token): \n # This version uses a regular expression to parse tag contents. \n try : \n # Splitting by None == splitting by spaces. \n tag_name, arg = token. contents. split( None , 1 ) \n except ValueError : \n raise template. TemplateSyntaxError( \n " %r tag requires arguments" % token. contents. split()[ 0 ] \n ) \n m = re. search( r "(.*?) as (\\w+)" , arg) \n if not m: \n raise template. TemplateSyntaxError( " %r tag had invalid arguments" % tag_name) \n format_string, var_name = m. groups() \n if not ( format_string[ 0 ] == format_string[ - 1 ] and format_string[ 0 ] in ( '"' , "'" )): \n raise template. TemplateSyntaxError( \n " %r tag's argument should be in quotes" % tag_name\n ) \n return CurrentTimeNode3( format_string[ 1 : - 1 ], var_name) \n此处的不同点是 do_current_time() 处理了格式化字符串和变量名，并将它们传递给 CurrentTimeNode3。
\n最后，如果你的自定义上下文更新模板标签只需要简单的语法，考虑使用 simple_tag()
\n \n\n\n模板标签能串联工作。例如，标准标签 {% comment %}{% endcomment %}。要创建一个类似的标签，在编译函数中使用 parser.parse()。
\n以下是如何实现一个简单的 {% comment %} 标签的介绍:
\nCode Copy
def do_comment ( parser, token): \n nodelist = parser. parse(( "endcomment" ,)) \n parser. delete_first_token() \n return CommentNode() \n\n\nclass CommentNode ( template. Node): \n def render ( self , context): \n return "" \n\nNote
\n{% comment %}{% comment %} 和 {% endcomment %} 出现破损的标记。它通过调用 parser.skip_past('endcomment') （而不是 parser.parse(('endcomment',))），后跟 parser.delete_first_token()，从而避免生成节点列表。
\n \nparser.parse() 接受一个包含 “解析直到” 区块标签的元组。它返回一个 django.template.NodeList 实例，它解析器遇到元组中的标签前解析的 Node 对象。
\n上文例子 "nodelist = parser.parse(('endcomment',))" 中， nodelist 是一个包含了 {% comment %} 和 {% endcomment %} 之间所有节点的列表，但不包含 {% comment %} 和 {% endcomment %} 本身。
\n在调用 parser.parse() 后，解析还未 “消费掉” {% endcomment %} 标签，所以代码需要显示地调用 parser.delete_first_token()。
\nCommentNode.render() 返回了一个空字符串。 {% comment %} 和 {% endcomment %} 注释之间的全部内容均被忽略。
\n \n\n\n在前文的例子中， do_comment 抛弃了 {% comment %} 和 {% endcomment %} 之间的所有内容。现在我们不这么做，我们要对区块标签之间的东西做点什么。
\n举个例子，这里有个模板标签， {% upper %}，它将自己与 {% endupper %} 之间的内容全部大写。
\n用法：
\nDjango template Copy
{% upper %} This will appear in uppercase, {{ your_name }} .{% endupper %} \n与之前的例子一样，我们将使用 parser.parse()。但这次，我们将生成的 nodelist 传递给 Node:
\nCode Copy
def do_upper ( parser, token): \n nodelist = parser. parse(( "endupper" ,)) \n parser. delete_first_token() \n return UpperNode( nodelist) \n\n\nclass UpperNode ( template. Node): \n def __init__ ( self , nodelist): \n self . nodelist = nodelist\n\n def render ( self , context): \n output = self . nodelist. render( context) \n return output. upper() \n唯一的新概念是 UpperNode.render() 中的 self.nodelist.render(context)。
\n要获取更多复杂渲染的示例，请查看 django/template/defaulttags.py 中的 {% for %}django/template/smartif.py 中的 {% if %}
\n \n ","rootId":"how-to-create-custom-template-tags-and-filters","toc":[{"title":"代码布局","anchor":"code-layout","children":[]},{"title":"编写自定义的模板过滤器","anchor":"writing-custom-template-filters","children":[{"title":"注册自定义过滤器","anchor":"registering-custom-filters","children":[]},{"title":"模板过滤器期望字符串","anchor":"template-filters-that-expect-strings","children":[]},{"title":"过滤器和自动转义","anchor":"filters-and-auto-escaping","children":[]},{"title":"过滤器和时区","anchor":"filters-and-time-zones","children":[]}]},{"title":"编写自定义模板标签","anchor":"writing-custom-template-tags","children":[{"title":"简单标签","anchor":"simple-tags","children":[]},{"title":"Simple block tags","anchor":"simple-block-tags","children":[{"title":"一个复杂的案例","anchor":"a-complete-example","children":[]}]},{"title":"包含标签","anchor":"inclusion-tags","children":[]},{"title":"进阶自定义模板标签","anchor":"advanced-custom-template-tags","children":[]},{"title":"简介","anchor":"a-quick-overview","children":[]},{"title":"编写编译函数","anchor":"writing-the-compilation-function","children":[]},{"title":"编写渲染器","anchor":"writing-the-renderer","children":[]},{"title":"自动转义的注意事项","anchor":"auto-escaping-considerations","children":[]},{"title":"线程安全的注意事项","anchor":"thread-safety-considerations","children":[]},{"title":"注册该标签","anchor":"registering-the-tag","children":[]},{"title":"传递模板变量给标签","anchor":"passing-template-variables-to-the-tag","children":[]},{"title":"在上下文中设置变量","anchor":"setting-a-variable-in-the-context","children":[]},{"title":"解析直到碰到另一区块的标签","anchor":"parsing-until-another-block-tag","children":[]},{"title":"解析直到碰到另一区块标签，并保存内容。","anchor":"parsing-until-another-block-tag-and-saving-contents","children":[]}]}],"breadcrumbs":[{"docname":"howto/index","title":"如何引导","url":"/zh-hans/5.2/howto/"}],"prev":{"docname":"howto/custom-template-backend","title":"如何编写一个自定义的模板后端","url":"/zh-hans/5.2/howto/custom-template-backend/"},"next":{"docname":"howto/static-files/index","title":"如何管理静态文件（如图片、JavaScript、CSS）","url":"/zh-hans/5.2/howto/static-files/"},"formats":{"html":"/zh-hans/5.2/howto/custom-template-tags/","markdown":"/zh-hans/5.2/howto/custom-template-tags.md","json":"/zh-hans/5.2/howto/custom-template-tags.json"},"source":"https://github.com/django/django/blob/stable/5.2.x/docs/howto/custom-template-tags.txt","official":"https://docs.djangoproject.com/zh-hans/5.2/howto/custom-template-tags/","inVersions":["6.1","6.0","5.2","5.1","5.0","4.2","4.1","4.0","3.2","3.1","3.0","2.2","2.1","2.0"],"inLocales":["en","sv","zh-hans","ga","fr","ja","id","it","pt-br","ko","es","el","pl"]}