500 lines or less 是一系列非常經(jīng)典而相對短小的python文章，每一章代碼不超過500行，卻實(shí)現(xiàn)了一些強(qiáng)大的功能，由業(yè)內(nèi)大牛執(zhí)筆，有很大的學(xué)習(xí)價值。適合新手了解基本概念，也適合用來python進(jìn)階。
本篇原文
源碼
其他的一些開源的翻譯文章

翻譯上篇

寫引擎

既然我們已經(jīng)懂得了這個引擎要做什么，讓我們來實(shí)現(xiàn)它。

The Templite class

模板引擎的核心是Templite類。（它是一個模板，但是它是精簡版的）
這個類具有一個小的接口。你可以利用模板中的文本構(gòu)建一個Templite對象，然后你可以使用它的render方法來渲染一個特定的上下文（數(shù)據(jù)的字典）到模板中。

# Make a Templite object.
templite = Templite('''
    <h1>Hello {{name|upper}}!</h1>
    {% for topic in topics %}
        <p>You are interested in {{topic}}.</p>
    {% endfor %}
    ''',
    {'upper': str.upper},
)

# Later, use it to render some data.
text = templite.render({
    'name': "Ned",
    'topics': ['Python', 'Geometry', 'Juggling'],
})

我們將模板中的文本在對象創(chuàng)建時傳遞給它，這樣我們就能只做一次編譯步驟，然后多次調(diào)用render函數(shù)來重用編譯結(jié)果。
構(gòu)造函數(shù)也接受一個字典來作為初始的上下文。這些數(shù)據(jù)被存儲在Templite對象里，并且之后當(dāng)模板被渲染時可以獲取。這個位置適合于一些我們希望能隨時獲取的函數(shù)和常量，比如之前例子中的upper函數(shù)。
在我們討論Templite的實(shí)現(xiàn)之前，我們需要先定義一個助手：CodeBuilder。

CodeBuilder

我們的模板引擎的主要工作是解析模板并產(chǎn)生必要的python代碼。為了幫助產(chǎn)生python代碼，我們創(chuàng)建了一個CodeBuiler類，當(dāng)我們構(gòu)建python代碼時它為我們處理簿記。它增加代碼行，管理縮進(jìn)，最終給我們編譯好的python代碼。
一個CodeBuilder對象對一整塊python代碼負(fù)責(zé)。對于我們的模板引擎，python塊始終是一個完整的函數(shù)定義。但是CodeBuilder類并不假設(shè)它只是一個函數(shù)，這讓CodeBuilder更通用，并且與余下的模板引擎代碼的耦合度低。
正如我們所看到的，我們也使用嵌套的CodeBuilders 來讓把代碼放在函數(shù)的開始變得可能，即使我們可能直到完成才知道它到底做了什么。
一個CodeBuilder對象保存一個字符串列表，該列表將被組合到最終的python代碼。它唯一需要的其它狀態(tài)是當(dāng)前的縮進(jìn)級別：

class CodeBuilder(object):
    """Build source code conveniently."""

    def __init__(self, indent=0):
        self.code = []
        self.indent_level = indent

CodeBuilder并沒有做太多。add_line添加了一行新代碼，它會自動縮進(jìn)到當(dāng)前縮進(jìn)級別，并提供一個換行符。

    def add_line(self, line):
        """Add a line of source to the code.

        Indentation and newline will be added for you, don't provide them.

        """
        self.code.extend([" " * self.indent_level, line, "\n"])

indent和dedent提高和降低當(dāng)前的縮進(jìn)級別：

    INDENT_STEP = 4      # PEP8 says so!

    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列表主要是一列字符串，但是也保存了對CodeBuilder片段的引用。

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

__str__產(chǎn)生單個字符串，只是簡單地把self.code中的所有字符串組合在一起。注意，因?yàn)?code>self.code中包含其他CodeBuilder片段，這可能會遞歸調(diào)用其它的CodeBuilder對象的__str__方法。

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

get_globals產(chǎn)生執(zhí)行代碼的最終值。它字符串化對象，執(zhí)行它并得到它的定義，然后返回最終的值：

    def get_globals(self):
        """Execute the code, and return a dict of globals it defines."""
        # A check that the caller really finished all the blocks they started.
        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函數(shù)執(zhí)行一串包含python代碼的字符串，它的第二個參數(shù)是一個字典，用來收集字符串代碼中定義的全局變量。舉例來說，如果我們這樣做：

python_source = """\
SEVENTEEN = 17

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

然后global_namespace['SEVENTEEN']就是17，global_namespace['three']就是一個名為three的函數(shù)。
盡管我們只用CodeBuilder來生成一個函數(shù)，但是并沒有什么用來限制它。這使得這個類易于實(shí)現(xiàn)和理解。
CodeBuilder讓我們創(chuàng)建python源代碼塊，而且一點(diǎn)也沒有關(guān)于我們的模板引擎的特定知識。我們可以在python中定義三個不同的函數(shù)，然后get_globals返回三個函數(shù)的字典。這樣，我們的模板引擎只需要定義一個函數(shù)。但是更好的軟件設(shè)計方法是保留實(shí)現(xiàn)細(xì)節(jié)在模板引擎代碼中，而不是在CodeBuilder類中。
即使我們真正用它來定義單個函數(shù)，擁有一個返回字典的get_globals函數(shù)使代碼更加模塊化，因?yàn)樗⒉恍枰牢覀兯x的函數(shù)名稱。不論我們在python源中如何定義函數(shù)名，我們都可以通過get_globals返回的字典來獲取它。
現(xiàn)在我們可以實(shí)現(xiàn)Templite類了，以及看看CodeBuilder是怎樣使用的。

Templite類的實(shí)現(xiàn)

我們的大部分代碼都在Templite類中。正如我們之前討論的，它同時具有編譯階段和渲染階段。

編譯

編譯一個模板為python函數(shù)的所有工作在Templite構(gòu)造器里發(fā)生。首先上下文被保存：

    def __init__(self, text, *contexts):
        """Construct a Templite with the given `text`.

        `contexts` are dictionaries of values to use for future renderings.
        These are good for filters and global values.

        """
        self.context = {}
        for context in contexts:
            self.context.update(context)

注意我們使用了*contexts作為參數(shù)。星號表示任意數(shù)量的位置參數(shù)將被打包成一個元組作為contexts傳遞進(jìn)來。這叫做參數(shù)解包，意味著調(diào)用者可以提供多個不同的上下文字典?，F(xiàn)在，如下調(diào)用都是有效的：

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

上下文參數(shù)在存在的情況下被作為一個元組提供給構(gòu)造器。我們可以遍歷這個元組，輪流處理它們每一個。我們簡單的創(chuàng)建了一個所有上下文字典組合而成的字典，叫做self.context。如果有重復(fù)的字典值，后面的會覆蓋前面的。
為了使用編譯出來的函數(shù)運(yùn)行得盡可能的快，我們將上下文中的變量提取到python本地變量中。我們將通過保存一個遇到過的變量名的集合來獲取它們，但是我們也需要跟蹤模板中定義的變量名，如循環(huán)變量：

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

稍后我們將看到這些是如何被用來幫助構(gòu)建函數(shù)的序幕的。首先，我們用了之前寫的CodeBuilder類來開始構(gòu)建我們的編譯函數(shù)：

        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")

在這里，我們構(gòu)建了我們的CodeBuilder對象，然后向里面加入語句。我們的python函數(shù)將被稱為render_function，它接受兩個參數(shù)：一個是上下文數(shù)據(jù)字典，一個是實(shí)現(xiàn)點(diǎn)屬性訪問的do_dots函數(shù)。
這里的上下文是兩個上下文數(shù)據(jù)的組合：被傳遞給Templite構(gòu)造器的上下文和被傳給渲染函數(shù)的上下文。這是我們在Templite構(gòu)造器中創(chuàng)建的模板可獲得的一套完整的數(shù)據(jù)。
請注意，CodeBuilder很簡單：它不知道函數(shù)的定義，只擁有代碼行。這保持CodeBuilder在實(shí)現(xiàn)和使用上的簡便性。這里，我們可以讀取我們生成的代碼而不需要在精神上插入太多的專門的CodeBuilder。
我們創(chuàng)建了一個片段叫vars_code。之后我們將在該片段中寫上變量提取的語句。vars_code對象使我們保留了一個函數(shù)中的位置，它將在我們得到需要的信息后被填補(bǔ)。
隨后是添加四條固定語句，定義了一個結(jié)果列表，添加了列表方法和內(nèi)置str方法的快捷方式。正如我們之前討論的，這個奇怪的步驟為我們的渲染函數(shù)擠出來一點(diǎn)點(diǎn)的性能提升。
同時擁有append和extend方法的快捷方式使我們面對一行或者多行的添加時，可以選擇最有效率的一個。
接下來我們定義一個內(nèi)部函數(shù)來幫助我們緩沖輸出字符串：

        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[:]

當(dāng)我們創(chuàng)建一堆需要加入編譯出的函數(shù)的輸出塊時，我們需要把它們變成加入result列表的函數(shù)調(diào)用。我們將反復(fù)的append調(diào)用組合為一個extend調(diào)用。這是另一個微優(yōu)化。要做到這一點(diǎn)，我們緩沖這些輸出塊。
緩沖列表保存還未被寫入函數(shù)源代碼的字符串。當(dāng)我們的模板編譯運(yùn)行時，我們將向buffered添加字符串，然后當(dāng)我們遇到控制流節(jié)點(diǎn)（如if語句，循環(huán)的開始或末端）時，將它們刷新到函數(shù)源代碼。
flus_output函數(shù)是一個閉包，閉包是對于一個引用本身之外變量的函數(shù)的花哨稱呼。在這里，flus_output引用了buffered和code。這簡化了我們的函數(shù)調(diào)用：我們不必告訴flush_output刷新哪個緩沖區(qū)或者刷新到哪，它隱式地知道這些。
如果只有只有一個字符串被緩沖，那么append_result將被調(diào)用；如果多于一個，extend_result被使用。然后緩沖隊列被清空來緩沖下一批的字符串。
余下的編譯代碼將是添加語句到緩沖隊列。然后最終調(diào)用flush_output來將它們寫入CodeBuilder。
有了這個函數(shù)，我們可以在編譯器中擁有這樣一條代碼：

buffered.append("'hello'")

這意味著我們編譯出來的python函數(shù)將有這樣一句：

append_result('hello')

即hello字符串將被添加到模板的渲染輸出中。這里，我們有幾個層級的抽象，很容易搞混。
編譯器使用了buffered.append("'hello'")來創(chuàng)建一個append_result('hello')語句在編譯出的python函數(shù)中，而這個函數(shù)語句運(yùn)行后添加了hello字符串到最終的模板結(jié)果中。

回到我們的Templite類中。當(dāng)我們解析控制流結(jié)構(gòu)時，我們希望檢查它們是否是合理地嵌套了。ops_stack列表是一個字符串堆棧：

        ops_stack = []

例如當(dāng)我們碰到一個{% if .. %}標(biāo)簽，我們將'if'壓入堆棧。當(dāng)我們碰到一個{% endif %}標(biāo)簽時，我們再將之前的'if'彈出堆棧。如果棧頂沒有'if'則報告錯誤。

現(xiàn)在真正的解析開始。我們使用正則表達(dá)式將模板文本分割多個標(biāo)志。正則表達(dá)式可能是令人畏懼的：它們是非常緊湊的符號，用來做復(fù)雜的模式匹配。它們也非常高效，因?yàn)槟Ｊ狡ヅ涞膹?fù)雜部分是正則表達(dá)式引擎中用C實(shí)現(xiàn)的，而不是你自己的python代碼。這是我們的正則表達(dá)式：

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

這看上去很復(fù)雜，來讓我們分解它。
re.split函數(shù)將使用正則分割一個字符串。我們的模式在括號里，匹配的符號將被用來分割字符串，分割出的字符串將組成列表返回。我們的模式代表了我們的標(biāo)簽語法，我們將它括起來使字符串會在標(biāo)簽處被分割，然后標(biāo)簽也會被返回。
re.split的返回值是一個字符串列表。例如，這是模板文本：

<p>Topics for {{name}}: {% for t in topics %}{{t}}, {% endfor %}</p>

它將被分割成如下的片段：

[
    '<p>Topics for ',               # literal
    '{{name}}',                     # expression
    ': ',                           # literal
    '{% for t in topics %}',        # tag
    '',                             # literal (empty)
    '{{t}}',                        # expression
    ', ',                           # literal
    '{% endfor %}',                 # tag
    '</p>'                          # literal
]

一旦文本被分割成這樣的標(biāo)記，我們就可以循環(huán)依次處理它們。根據(jù)類型來分割它們，我們就可以分別處理每個類型。
編譯代碼是一個關(guān)于這些標(biāo)記的循環(huán)：

        for token in tokens:

每個標(biāo)記都被檢查，看它是四種情況中的哪一個。只看頭兩個字符就夠了。第一種情況是注釋，只需要忽略它然后繼續(xù)處理下一個標(biāo)記就行了：

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

對于{{...}}表達(dá)式，我們截斷前后的大括號，用空格分割，然后整個傳遞給_expr_code函數(shù)：

            elif token.startswith('{{'):
                # An expression to evaluate.
                expr = self._expr_code(token[2:-2].strip())
                buffered.append("to_str(%s)" % expr)

_expr_code方法將編譯模板表達(dá)式為python語句。留后再看。我們使用了to_str函數(shù)來強(qiáng)制返回的表達(dá)式的值為字符串，然后將它加到我們的結(jié)果列表中。
第三種情況是{% ... %}標(biāo)簽。要將它們變?yōu)閜ython的控制結(jié)構(gòu)。首先我們刷新我們的輸出語句緩沖隊列，然后我們從標(biāo)簽中提取單詞列表：

            elif token.startswith('{%'):
                # Action tag: split into words and parse further.
                flush_output()
                words = token[2:-2].strip().split()

現(xiàn)在我們有三個子情況，取決于標(biāo)簽的第一個詞：if,for或者end。if情況至少展示了簡單的錯誤處理和代碼生成：

                if words[0] == 'if':
                    # An if statement: evaluate 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()

if標(biāo)簽只能有一個表達(dá)式，所以words列表只應(yīng)該有兩個元素。如果不是，我們利用_syntax_error輔助方法來拋出一個語法異常。我們將'if'壓入ops_stack棧中，來讓我們檢查相應(yīng)的endif標(biāo)簽。'if'標(biāo)簽的表達(dá)式部分通過_expr_code編譯為python表達(dá)式，然后被用作python中if語句的條件表達(dá)式。
第二個標(biāo)簽的類型是for，它將被編譯為一個python的for語句：

                elif words[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._variable(words[1], self.loop_vars)
                    code.add_line(
                        "for c_%s in %s:" % (
                            words[1],
                            self._expr_code(words[3])
                        )
                    )
                    code.indent()

我們做了一個語法檢查并且將for壓入棧中。_variable方法檢查了變量的語法，并且將它加入我們提供的集合。這就是我們在編譯過程中收集所有變量的名稱的方法。之后我們需要編寫我們的函數(shù)的序幕，那時我們將解包所有從上下文得到的變量名。為了能正確地完成該操作，我們需要知道所有我們碰到過的變量名，self.all_vars和所有循環(huán)中定義的變量名，self.loop_vars。
然后我們添加一行for語句到我們的函數(shù)源碼中。所有的模板變量都加上c_前綴被轉(zhuǎn)換為python變量，所以我們知道它們不會與其它命名沖突。我們使用_expr_code函數(shù)來編譯模板中的迭代表達(dá)式到python中的迭代表達(dá)式。

最后一種標(biāo)簽就是end了，不論是{% endif %}還是{% endfor %}。效果對于我們編譯出的函數(shù)源碼是一樣的：只是簡單地在之前的if或for語句末尾加上取消縮進(jìn)：

                elif words[0].startswith('end'):
                    # Endsomething.  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 ends", token)
                    start_what = ops_stack.pop()
                    if start_what != end_what:
                        self._syntax_error("Mismatched end tag", end_what)
                    code.dedent()

注意這里真正需要的工作只是最后一行：取消函數(shù)源碼的縮進(jìn)。余下的語句都是錯誤檢查來保證模板被正確地組織了。這在程序翻譯代碼中很常見。
說道錯誤處理，如果標(biāo)簽不是一個if、for或者end，那么我們也不知道它是什么，所以拋出一個語法異常：

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

我們對三個特殊語法（{{...}}, {#...#}, 以及{%...%}）的處理已經(jīng)完成了。剩下的就是文字內(nèi)容。我們添加文字內(nèi)容到緩沖輸出隊列，記得使用內(nèi)置的repr函數(shù)來產(chǎn)生一個python字符串字面量：

            else:
                # Literal content.  If it isn't empty, output it.
                if token:
                    buffered.append(repr(token))

否則，可能會在我們編譯出的函數(shù)中出現(xiàn)下面的語句：

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

我們需要值被這樣引用：

append_result('abc')

repr函數(shù)提供了對字符串的引用，并且會在需要的地方提供反斜杠：

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

注意我們一開始用if token:檢查了該標(biāo)記是否是空的，因?yàn)樘砑右粋€空字符串到輸出中是沒有意義的。因?yàn)槲覀兊恼齽t表達(dá)式是按標(biāo)簽語法分割的，鄰近的標(biāo)簽會造成一個空標(biāo)記在它倆之間。這里的檢查是一種避免無用的append_result("")語句出現(xiàn)在編譯出的函數(shù)中的簡易方法。
這樣就完成了模板中所有標(biāo)記的循環(huán)。當(dāng)循環(huán)結(jié)束，模板中的所有地方都被處理了。我們還有一個檢查要做，那就是如果ops_stack不為空，我們一定漏掉了一個結(jié)束標(biāo)簽。然后我們刷新緩沖隊列輸出到函數(shù)源碼。

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

        flush_output()

在函數(shù)的一開始我們已經(jīng)創(chuàng)建了一個片段。它的角色是從上下文中解包模板變量到python本地變量。既然我們已經(jīng)處理完了這個模板，我們也知道所有變量的名稱，我們就可以在函數(shù)序幕中寫語句。
我們必須做一點(diǎn)小工作來知道我們需要定義什么名稱?？次覀兊氖纠０澹?/p>

<p>Welcome, {{user_name}}!</p>
<p>Products:</p>
<ul>
{% for product in product_list %}
    <li>{{ product.name }}:
        {{ product.price|format_price }}</li>
{% endfor %}
</ul>

這里有兩個被用到的變量，user_name和product。all_vars集合將擁有他們的名稱，因?yàn)樗鼈兌急挥迷?code>{{...}}表達(dá)式中。但是只有user_name需要在序幕中從上下文提取，因?yàn)?code>product是在循環(huán)中定義的。
模板中所有的變量都在集合all_vars中，模板中定義的變量都在loop_vars中。所有loop_vars中的變量名稱都已經(jīng)在代碼中被定義了，因?yàn)樗鼈冊谘h(huán)中被使用了。所以我們需要解包任何屬于all_vars而不屬于loop_vars的名稱：

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

每個名稱都變成函數(shù)序幕的一行代碼，將上下文變量解包成合法的本地變量。
我們快要完成將模板變?yōu)閜ython函數(shù)的編譯。我們的函數(shù)一直在將字符串加入result中，所以最后一行是簡單地將它們組合在一起并返回：

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

既然我們已經(jīng)完成了編譯出的python函數(shù)的源碼的書寫，我們需要的就是從CodeBuilder對象得到函數(shù)本身。get_globals方法執(zhí)行我們組裝好的python代碼。記住我們的代碼是一個函數(shù)定義(以def render_function(..):開始)，所以執(zhí)行這個代碼會定義render_function，但是并不執(zhí)行render_function的主體。
get_globals的結(jié)果是代碼中定義的值的字典。我們從中獲取render_function的值，然后將它保存為Templite對象的一個屬性：

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

現(xiàn)在self._render_function就是一個可調(diào)用的python函數(shù)了。我們會在渲染階段使用它。

編譯表達(dá)式

我們還沒有看到編譯過程的一個重要部分：_expr_code方法，它將模板表達(dá)式編譯為python表達(dá)式。我們的模板表達(dá)式可能簡單的只是一個名字：

{{user_name}}

也可能是一個復(fù)雜的序列包含屬性訪問和過濾器：

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

我們的_expr_code方法將處理所有的可能情況。正如所有語言中的表達(dá)式，我們的也是遞歸構(gòu)建的：大的表達(dá)式由小的表達(dá)式組成。一個完整的表達(dá)式由管道符分隔，其中第一部分是由逗號分隔的，諸如此類。所以我們的函數(shù)自然地采取遞歸的形式：

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

第一種情況是考慮我們的表達(dá)式中有管道分隔符。如果有，我們要分割它為一個管道片段列表。第一部分將被遞歸地傳入_expr_code來將它轉(zhuǎn)換為一個python表達(dá)式。

        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)

余下的每一個管道片段都是一個函數(shù)名。值被傳遞給這些函數(shù)來產(chǎn)生最終的值。每一個函數(shù)名都是一個變量，要加入到all_vars中所以我們能在序幕中正確地提取它。
如果沒有管道，可能會有點(diǎn)操作符。如果有的話，按點(diǎn)分割。將第一部分遞歸地傳遞給_expr_code來將它轉(zhuǎn)換為一個python表達(dá)式，之后以點(diǎn)分割的名稱都被依次處理。

        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)

要理解點(diǎn)操作是如何被編譯的，記住模板中的x.y意味著x['y']或者x.y，誰能工作用誰，如果結(jié)果是可調(diào)用的，就調(diào)用它。這種不確定性意味著我們不得不在運(yùn)行時嘗試所有的可能，而不是在編譯時確定。所以我們編譯x.y.z為一個函數(shù)調(diào)用，do_dots(x, 'y', 'z')。點(diǎn)函數(shù)將嘗試不同的訪問方法并返回成功的值。
do_dots函數(shù)將在運(yùn)行時傳入我們編譯好的python函數(shù)。我們將看到它的實(shí)現(xiàn)。
_expr_code函數(shù)最后的語句是處理沒有管道和點(diǎn)操作符的情況。這時，表達(dá)式僅僅是一個名稱。我們將它記錄在all_vars中，并且通過帶前綴的python命名獲取它：

        else:
            self._variable(expr, self.all_vars)
            code = "c_%s" % expr
        return code

輔助函數(shù)

在編譯過程中，我們使用了一些輔助函數(shù)。比如_syntax_error方法僅僅組合出漂亮的錯誤信息并拋出異常：

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

_variable方法幫助我們驗(yàn)證變量名是否有效，然后將它們加入在編譯過程中我們收集的姓名集合。我么是用正則來檢查名稱是否是一個有效的python標(biāo)識符，然后將它加入集合：

    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)

就這樣，編譯部分的代碼都完成了。

渲染

剩下的就是編寫渲染代碼了。因?yàn)槲覀儗⒛０寰幾g為python函數(shù)，所以渲染部分沒有太多工作要做。它準(zhǔn)備好上下文，然后調(diào)用編譯好的python代碼：

    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)

想起來，我們在構(gòu)建Templite對象時，我們從一個數(shù)據(jù)上下文開始。這里我們復(fù)制它，然后將它和渲染函數(shù)被傳入的數(shù)據(jù)混合。復(fù)制是為了讓連續(xù)的多個渲染函數(shù)調(diào)用不會看到相互的數(shù)據(jù)，然后將它們混合是為了讓我們只有一個字典來進(jìn)行數(shù)據(jù)查找。這就是我們?nèi)绾螐奶峁┑亩鄠€上下文（模板被創(chuàng)建時和渲染時）中構(gòu)建出一個統(tǒng)一的數(shù)據(jù)上下文。

要注意的是，我們傳遞給render的數(shù)據(jù)可能會覆蓋傳遞給Templite構(gòu)造器的。這往往不會發(fā)生，因?yàn)閭鬟f給構(gòu)造器的上下文包含的是全局定義的過濾器和常量，而傳給render的上下文包含的是那一次渲染的特有數(shù)據(jù)。
然后我們簡要地調(diào)用我們的render_function。第一個參數(shù)是完整的上下文數(shù)據(jù)，第二個是將被實(shí)現(xiàn)的點(diǎn)語義函數(shù)。我們每次使用同樣的實(shí)現(xiàn)：我們的_do_dots方法。

    def _do_dots(self, value, *dots):
        """Evaluate 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

在編譯期間，一個模板表達(dá)式如x.y.z被轉(zhuǎn)換為do_dots(x, 'y', 'z')。這個函數(shù)循環(huán)每個點(diǎn)后的名稱，對每一個它先嘗試是否是一個屬性，不是的話再看它是否是一個字典的鍵。這給予了我們的單個模板語法一定的自由度來同時表示x.y和x['y']。在每一步，我們都嘗試調(diào)用它。一旦我們完成了循環(huán)，value的值就是我們想要的值。

這里我們再次使用了python的參數(shù)解包（*dots）以至于_do_dots能夠處理任意多的點(diǎn)操作。這增加了我們的函數(shù)的適用性，能為所有模板中的點(diǎn)表達(dá)式工作。

注意的是當(dāng)調(diào)用self._render_function時，我們傳遞了一個函數(shù)來評定點(diǎn)表達(dá)式，但是我們總是傳遞同一個。我們能夠使它成為被編譯的模板的一部分，但是這些行是關(guān)于模板的工作方式，而不是特定模板的部分細(xì)節(jié)。所以像這樣分開實(shí)現(xiàn)讓人感覺結(jié)構(gòu)更清晰。

測試

和模板引擎一起提供的是一系列測試覆蓋了所有行為和邊緣情況。我實(shí)際上有點(diǎn)超出500行的限制：模板引擎有252行，測試有275行。這是一個典型的測試完備的代碼：你的測試代碼比你的產(chǎn)品代碼還多。

可以完善的地方

完備特性的模板引擎比我們在這里實(shí)現(xiàn)的要復(fù)雜得多。為了保證代碼量小，我們遺留了許多有趣的問題：

• 模板繼承和包含
• 自定義標(biāo)簽
• 自動換碼
• 參數(shù)過濾器
• 復(fù)雜條件邏輯如else和elif
• 不止一個循環(huán)變量的循環(huán)
• 空白的控制
  即便如此，我們的簡單模板引擎也足夠有用了。實(shí)際上，它被用來為coverage.py生成它的HTML報告。

總結(jié)

在252行中，我們得到了一個簡單但是有一定功能的模板引擎。真實(shí)的模板引擎具有更多的特性，但是這個代碼勾畫出整個過程的基本思路：將模板編譯成一個python函數(shù)，然后執(zhí)行這個函數(shù)來生成最終的文本結(jié)果。