1
上一篇文章谈的是正则表达式，内容基本来自于系统文档，这里要做一个例子，模版解析器。
先看一个简单的模版：
Hello {{name}}
我们的任务就是要把name替换成我们指定的名字，这里的{{}}作为标记符号。模板在很多地方都有用到过，主要就是查找替换操作，复杂一点的会带逻辑结构。
带逻辑结构的模版：
{if a>b}
这里的内容需要a大于b
{end if}
带循环结构的模版：
{for a in names}
{{a}}
{end for}
2
- 变量输出语句
{{}}
这个任务应该怎么弄，先从最简单的开始，首先要查找到内容，然后替换。
def translate(template,context)
上面我定义了一个函数，这个函数接受一个模版，然后从模版中解析相关的内容，去context中获取对应的值。
str ='{{name}}is {{age}} years old'
pattern = re.compile(r'{{(.*?)}}')
context = {'name':'dongge','age':18}
def lookup(m):
try:
key = m.group(1)
if key in context:
return "{}".format(context[key])
except Exception as e:
return ""
pattern.sub(lookup,test_str)
'donggeis 18 years old'
- 处理条件语句
pif = re.compile(r'{\s*?if\s+(?P<cond>.+?)\s*?}(?P<content>.*?){\s*?end\s+?if\s*?}',re.MULTILINE)
test_str = '{if 1>2}hhh{end if}'
m=pif.search(test_str)
m.groupdict()
#{'cond': '1>2', 'content': 'hhh'}
def calccond(cond,context):
try:
return eval(cond,context)
except Exception as e:
return False
cond = m.group('cond')
calccond(cond,None)
#False
- 处理循环语句
pfor = re.compile(r'{\s*?for\s+(?P<val>.+?)\s+in\s+(?P<vals>.+?)\s*?}(?P<content>.*?){\s*?end\s+?for\s*?}',re.MULTILINE)
test_str='{for a in names}\
hello\
{end for}'
m=pfor.search(test_str)
m.groupdict()
#{'content': 'hello', 'val': 'a', 'vals': 'names'}
def executefor(m,context):
content = m.group('content')
val = m.group('val')
vals = m.group('vals')
if vals in context:
vals = context[vals]
else:
vals = []
for v in vals:
context[val] = v
....
return ...
上面的代码给三个功能一个初略的实现，但是这里存在一些问题。输出功能属于简单语句，而条件和循环语句属于复合语句。
3
在实际模版处理中我们肯定是用正则表达式一起处理三种情况，那么这些表达式就是或的关系。
token_specification = [('exp',r'{{.*?}}'),
('ifstmt',r'{\s*?if\s+.+?\s*?}.*?{\s*?end\s+?if\s*?}'),
('forstmt',r'{\s*?for\s+.+?\s+in\s+.+?\s*?}.*?{\s*?end\s+?for\s*?}')]
tok_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_specification)
p_temp = re.compile(tok_regex)
上面的代码给出了三种情况下的正则表达式，用|连接这些表达式，这里还给三种情况下的表达式命名，这样方便后面区分到底是那种表达式被识别了。
import re
p_exp = re.compile(r'{{(?P<exp>.*?)}')
p_if = re.compile(r'{\s*?if\s+(?P<cond>.+?)\s*?}(?P<content>.*?){\s*?end\s+?if\s*?}')
p_for = re.compile(r'{\s*?for\s+(?P<name>.+?)\s+in\s+(?P<vals>.+?)\s*?}(?P<content>.*?){\s*?end\s+?for\s*?}')
def render_template(template,context):
def replace_fun(m):
kind = m.lastgroup
value = m.group(kind)
if kind == 'exp':
return handle_exp(value,context)
elif kind == 'ifstmt':
return handle_if(value,context)
elif kind == 'forstmt':
return handle_for(value,context)
return p_temp.sub(replace_fun,template)
主函数是render_template，在这个函数里面我定义了一个函数。之所以定义这个函数是因为，sub函数第一个参数是match object，但是我需要上下文信息来计算表达式的值。接下来就是对三种情况分别处理，对于表达式最简单，但是条件和循环语句属于复合语句，所以在这些函数里面会调用主函数。
def handle_exp(template,context):
m = p_exp.match(template)
exp = m.group('exp')
ret = eval(exp,context)
return "{}".format(ret)
def handle_if(template,context):
print(template)
m = p_if.match(template)
cond = m.group('cond')
content = m.group('content')
ret = eval(cond,context)
if isinstance(ret,bool) and ret:
return render_template(content,context)
return ''
def handle_for(template,context):
m = p_for.match(template)
name = m.group('name')
vals = m.group('vals')
content = m.group('content')
ret = eval(vals,context)
rstr = []
try:
for v in ret:
context[name] = v
rstr.append(render_template(content,context))
except Exception as e:
print(e)
return ''
return ''.join(rstr)
