模板引擎的核心就是这个 Templite 类(Template Lite)

Templite 有一个小的接口。一旦你构造了这样一个类，后面就可以通过调用 render 方法实现对特定 context(内容字典) 的渲染：

# Make a Templite object.  
templite = Templite('''  
    
Hello {{name|upper}}!
  
    {% for topic in topics %}  
        
You are interested in {{topic}}.
  
    {% endfor %}  
    ''',  
    {'upper': str.upper},  
)  
# Later, use it to render some data.  
text = templite.render({  
    'name': "Ned",  
    'topics': ['Python', 


    
'Geometry', 'Juggling'],  
})  

这里，我们在例化的时候已经将模板传入，之后我们就可以直接对模板进行一次编译，在之后就可以通过 render 方法对模板进行多次调用。

构造函数接受一个字典参数作为内容的初始化，他们直接被存储在类内部，在后期调用 render 方法的时候可以直接引用。同样，一些会用到的函数或常量也可以在这里输入，比如之前的 upper 函数。

再开始讨论 Temlite 类实现之前，我们先来看一下这样一个类:CodeBuilder。

CodeBuilder

我们编写模板引擎的主要工作就是模板解析和产生必要的 Python 代码。为了帮助我们更好的产生 Python 代码，我们需要一个 CodeBuilder 的类，这个类主要负责代码的生成：添加代码，管理缩进以及返回最后的编译结果。

一个 CodeBuilder 实例完成一个 Python 方法的构建，虽然在我们模板引擎中只需要一个函数，但是为了更好的抽象，降低模块耦合，我们的 CodeBuilder 将不仅仅局限于生成一个函数。

虽然我们可能直到最后才会知道我们的结果是什么样子，我们还是把这部分拿到前面来说一下。

CodeBuilder 主要有两个元素，一个是用于保存代码的字符串列表，另外一个是标示当前的缩进级别。

class CodeBuilder(object):  
    """Build source code conveniently."""  
    def __init__(self, indent=0):  
        self.code = 


    
[]  
        self.indent_level = indent  

下面我们来看一下我们需要的接口和具体实现。 
add_line 方法将添加一个新的代码行，缩进将自动添加

def add_line(self, line):  
    """Add a line of source to the code.  
    Indentation and new line will be added for you, don't provide them.  
    """  
    self.code.extend([" " * self.indent_level, line, "n"])  

indent 和 dedent 增加和减少缩进级别的函数:

INDENT_STEP = 4  
def indent(self


    
):  
    """Increase the current indent for following lines."""  
    self.indent_level  = self.INDENT_STEP  
def dedent(self):  
    """Decrease the current indent for following lines."""  
    self.indent_level -= self.INDENT_STEP  

add_section 通过另一个 CodeBuilder 管理，这里先预留一个位置，后面再继续完善， self.code 主要由代码字符列表构成，但同时也支持对其他代码块的引用。

def add_section(self):  
    """Add a secton, a sub-CodeBuilder."""  
    section = CodeBuilder(self.indent_level)  
    self.code.append(section)


    
  
    return section  

__str__ 用于产生所有代码，它将遍历 self.code 列表，而对于 self.code 中的 sections，它也会进行递归调用：

def __str__(self):  
    return ''.join(str(c) for c in self.code)  

get_globals 通过执行代码迭代生成结果：

def get_globals(self):  
    """Executer the code, and return a dict of globals if defnes."""  
    # A check that caller really finished all the blocks  
    assert self.indent_level == 0  



    
    # Get the Python source as a single string   
    python_source = str(self)  
    # Execute the source, defining globals, and return them.  
    global_namespace = {}  
    exec(python_source, global_namespace)  
    return global_namespace  

在这里面用到了 Python 一个非常有特色的功能， exec 函数，该函数可以将字符串作为代码执行，函数的第二个参数是一个用于收集代码定义全局变量的一个字典，比如：

python_source = """  
SEVENTEEN = 17  
def three():  
    return 3  
"""  
global_namespace = {}  
exec(python_source, global_namespace)  



    
print(global_namespace['SEVENTEEN'], global_namespace['three'])  

输出结果：

(17, <function three at 0x029FABB0>)  
[Finished in 0.1s]  

虽然我们只需要 CodeBuilder 产生一个函数，但是实际 CodeBuilder 的使用并不局限于一个函数，它实际是一个更为通用的类。

CodeBuilder 可以产生 Python 代码，但是并不依赖于我们的模板，比如我们要产生三个函数，那么 get_global 实际就可以产生含有三个函数的字典，这是一种非常实用的程序设计方法。

下面我们回归 Templite 类，看一下如何去实现这样一个类

Templite 类的实现

就像之前我们所讲的一样，我们的主要任务在于实现模板发解析和渲染。

编译（解析 Compiling）

这部分工作需要完成模板代码到 python 代码的转换，我们先尝试写一下构造器：

def __init__(self, text, *contexts):  
    """Construct a Templite with the given 'text'.  
    'contexts' are dictionaries of values to future renderings.  
    These are good for filters and global values.  
    """  
    super(


    
Templite, self).__init__()  
    self.context = {}  
    for context in contexts:  
        self.context.update(context)  

注意，我们使用 *contexts 作为一个参数， * 代表可以传入任意数量的参数，所有的参数都将打包在一个元组里面，元组名称为 contexts。这称之为参数解包，比如我们可以通过如下方式进行调用：

t = Templite(template_text)  
t = Templite(template_text, context1)  
t = Templite(template_text, context1, context2)  

内容参数作为一个元组传入，我们通过对元组进行遍历，对其依次进行处理，在构造器中我们声明了一个 self. context 的字典， python 中对重名情况直接使用最近的定义。

同样，为了更有效的编译函数，我们将 context 中的变量也本地化了，我们同样还需要对模板中的变量进行整理，于是我们定义如下两个元素：

self.all_vars = set()  
self.loop_vars = set()  

之后我们会讲到如何去运用这些变量。首先，我们需要用 CodeBuilder 类去产生我们编译函数的定义：

code = CodeBuilder()  
code.add_line("def render_function(context, do_dots):")  
code.indent()  
vars_code = code.add_section()  
code.add_line("result = []")  
code.add_line("append_result = result.append")  
code.add_line(


    
"extend_result = result.extend")  
code.add_line("to_str = str")  

这里，我们构造一个 CodeBuilder 类，添加函数名称为 render_function，以及函数的两个参数：数据字典 context 和实现点号属性获取的函数 do_dots

这里的数据字典包括传入 Templite 例化的数据字典和用于渲染的数据字典。是整个可以获取的数据的一个集合。

而作为代码生成工具的 CodeBuilder 并不关心自己内部是什么代码，这样的设计使 CodeBuilder 更为简洁和易于实现。

我们还创建了一个名称为 vars_code 的代码段，后面我们会把我们的变量放到这个段里面，该代码段为我们预留了一个后面添加代码的空间。

另外的四行分别添加了结果列表 result 的定义，局部函数的定义，正如之前说过的，这都是为了提升运行效率而添加的变量。

接下来，我们定义一个用于缓冲输出的内部函数：

buffered = []  
def flush_output():  
    """ Force 'buffered' to the code builder."""  
    if len(buffered) == 1:  
        code.add_line("append_result(%s)" % buffered[0])  
    


    
elif len(buffered) > 1:  
        code.add_line("extend_result([%s])" % ", ".join(buffered))  
    del buffered[:]  

因为我们需要添加很多 code 到 CodeBuilder,所以我们选择将这种重复的添加合并到一个扩展函数，这是另外的一种优化，为了实现这种优化，我们添加一个缓冲函数。

buffered 函数保存我们将要写入的 code，而在我们处理模板的时候，我们会往 buffered列表里添加字符串，直到遇到其他要处理的点，我们再将缓冲的字符写入生成函数，要处理的点包括代码段，或者循环判断语句的开始等标志。

flush_output 函数是一个闭包，里面的变量包括 buffered 和 code。这样我们以后调用的时候就不需要指定写入那个 code，从那个变量读取数据了。

在函数里，如果只是一个字符串，那么调用 appendresult 函数，如果是字符串列表，则调用 extendresult 函数。

拥有这个函数之后，后面需要添加代码的时候只需要往 buffered 里面添加就可以了,最后调用一次 flush_ouput 即可完成代码到 CodeBuilder 中的添加。

比如我们有一行代码需要添加，即可采用下面的形式：

buffered.append("'hello'")  

后面会添加如下代码到 CodeBuilder

    
append_result('hello')  

也就是将字符串 hello 添加到模板的渲染。太多层的抽象实际很难保持一致性。编译器使用 buffered.append("'hello'"), 这将生成append_result('hello')`` 到编译结果中。

让我们再回到 Templite 类，在我们进行解析的时候，我们需要判断模板 
能够正确的嵌套，这就需要一个 ops_stack 来保存字符串堆栈：

ops_stack = []  

比如在遇到 {% if ... %} 标签的时候，我们就需要将'if'进行压栈，当遇到 {% endif %} 的时候，需要将之前的的'if'出栈，如果解析完模板的时候，栈内还有数据，就说明模板没有正确的使用。

现在开始做解析模块。首先通过使用正则表达式将模板文本进行分组。正则表达式是比较烦人的: 正则表达式主要通过简单的符号完成对字符串的模式匹配。因为正则表达式的执行是通过 C 完成的，因此有很高的效率，但是最初接触时比较复杂难懂，比如：

tokens = re.split(r"(?s)({{.*?}}|{%.*?%}|{#.*?#})", text)  

看起来是不是相当复杂？我们来简单解释一下：

re.split 函数主要通过正则表达式完成对字符串的分组，而我们的正则表达式内部也含有分组信息（ ()），因此函数将返回对字符串分组后的结果，这里的正则主要匹配语法标签，所以最终字符串将在还有语法标签的地方被分割，并且相应的语法标签也会被返回。

正则表达式里的 (?s)  表示即使在一个新行也需要有一个点号（？），后面的分组有三种不同的选项： {{.*? 会匹配一个标签， {%.*?%} 会匹配一个语句表达式， {#.*?#} 会匹配一个注释。这几个选项里面，我们用 .*? 来匹配任意数目的任意字符，不过用了非贪婪匹配，因此它将只匹配最少数目的字符。

re.split 的输出结果是一个字符串列表，如果模板是如下的字符：

Topics for {{name}}: {% for t in topics %}{{t}}, {% endfor %}
  

将会返回如下的结果

[  
    '
Topics for '
,               # literal  
    '{{name}}',                     # expression  
    ': ',                           # literal  
    '{% for t in topics %}',        # tag  
    '',                             # literal (empty)  
    '{{t}}',                        # expression  
    ', ',                           # literal  



    
    '{% endfor %}',                 # tag  
    '
'                          # literal  
]  

一旦将模板进行了分组，我们就可以对结果进行遍历，对每种不同的类型进行不同的处理。

比如对各种符号的编译可以采用如下的形式：

for token in tokens:  

在遍历的时候，我们需要判断每个标志的类型，实际我们只需要判断前两个字符。而对于注释的标志处理最为简单，我们只需要简单的跳过即可：

if token.startwith('{#'):  
    # Comment: ignore it and move on.  
    continue  

对于 {{ ... }} 这样的表达式，需要将两边的括号删除，删减表达式两边的空格，最后将表达式传入到 _expr_code:

elif token.startwith("{{"):  
    # An expression to evalute.  
    expr = self._expr_code


    
(token[2:-2].strip())  
    buffered.append("to_str(%s)" % expr)  

_expr_code 方法会将模板中的表达式编译成 Python 语句，后面会具体降到这个方法的实现。再之后通过 to_str 函数将编译后的表达式转换为字符串添加到我们的结果中。

后面一个条件判断最为复杂： {% ... %} 语法标签的处理。它们将会被编译成 Python 中的代码段。在操作之前，首先需要将之前的结果保存，之后需要从标签中抽取必要的关键词进行处理：

elif token.startwith("{%"):  
    # Action tag: split into words and parse futher  
    flush_output()  
    words = token[2:-2].strip().split()  

目前支持的语法标签主要包含三种结构： if, for 和 end. 我们来看看对于 if 的处理：

if words[0] == 'if':  
    # An if statement: evalute the expression to determine if.  
    if len(words) != 2:  
        self._syntax_error("Don't understand if", token)  
    ops_stack.append('if')  
    code.add_line("if %s:" % self._expr_code(words[1]))  
    code.indent()  

elif word[0] == 'for':  
    # A loop: iterate over expression result.  
    if len(words) != 4 or words[2] != 'in':  
        self._syntax_error("Don't understand for", token)  
    ops_stack.append('for')  
    self._veriable(words[1], self.loop_vars)  



    
    code.add_line(  
            "for c_%s in %s:" % (  
                words[1],  
                self._expr_code(words[3]))  
        )  
    code.indent()  

elif word[0].startwith('end'):  
    #Endsomting. pop the ops stack.  
    if len(words) != 1:  
        self._syntax_error("Don't understand end", token)  
    end_what = words[0][3:]  
    if not ops_stack:  
        self._syntax_error("Too many engs", token)  
    start_what = ops_stack.pop()  
    if start_what ~= end_what:  



    
        self._syntax_error("Mismatched end tag", end_what)  
    code.dedent()  

else:  
    self._syntax_error("Don't understand tag", word[0])  

else:  
    #literal content, if not empty, output it  



    
    if token:  
        buffered.append(repr(token))  

append_result(abc)      # Error! abc isn't defined  

append_result('abc')  

append_result('"Don't you like my hat?" he asked.')  

if ops_stack:  
    self._syntax_error("Unmatched action tag", ops_stack[-1])  
flush_output()  

Welcome, {{user_name}}!
  
Products:
  
  
{% for product in product_list %}  
    
{{ product.name }}:  
        {{ product.price|format_price }}
  
{% endfor %}  
  

for var_name in self.all_vars - self.loop_vars:  
    vars_code.add_line("c_%s = context[%r]" % (var_name, var_name))  

code.add_line("return ''.join(result)")  
code.dedent()  

self._render_function = code.get_globals()['render_function']  

{{ user_name }}  

{{ user.name.localized|upper|escape }}  

def _expr_code(self, expr):  
    """Generate a Python expression for 'expr'."""  

if "|" in expr:  
    pipes = expr.split('|')  
    code = self._expr_code(pipes[0])  
    for func in pipes[1:]:  
        


    
self._variable(func, self.all_vars)  
        code = "c_%s(%s)" % (func, code)  

elif "." in expr:  
    dots = expr.split('.')  
    code = self._expr_code(dots[0])  
    args = ", ".join(repr(d) for d in dots[1:])  



    
    code = "do_dots(%s, %s)" % (code, args)  

else:  
    self._variable(expr, self.all_vars)  
    code 


    
= "c_%s" % expr  
return code  

def _syntax_error(self, msg, thing):  
    """Raise a syntax error using 'msg', and showing 'thing'. """  
    raise TempliteSyntaxError("%s: %r" % (msg, thing))  

def _variable(self, name, vars_set):  
    """Track that `name` is used as a variable.  
    Adds the name to `vars_set`, a set of variable names.  
    Raises an syntax error if `name` is not a valid name.  



    
    """  
    if not re.match(r"[_a-zA-Z][_a-zA-Z0-9]*$", name):  
        self._syntax_error("Not a valid name", name)  
    vars_set.add(name)  

def render(self, context=None):  
    """Render this template by applying it to `context`.  
    `context` is a dictionary of values to use in this rendering.  
    """  
    # Make the complete context we'll use.  
    render_context = dict(self.context)  



    
    if context:  
        render_context.update(context)  
    return self._render_function(render_context, self._do_dots)  

def _do_dots(self, value, *dots):  
    """Evalute dotted expressions at runtime"""  
    for dot in dots:  
        try:  



    
            value = getattr(value, dot)  
        except AttributeError:  
            value = value[dot]  
        if callable(value):  
            value = value()  
    return value