Python使用re模块正则式的预编译及pickle方案

　　项目上线要求当中有言论和昵称的过滤需求, 客户端使用的是python脚本, python脚本中直接利用re模块来进行正则匹配, 一开始的做法是开启游戏后, 每帧编译2条正则式, 无奈运营需求里面100+条略为复杂的正则式, 一条编译起来在pc上都需要80ms, 造成客户端开启时候的卡顿.

　　解决方案当然是保存re模块编译的正则式结果, 之后开机直接加载就行, 然而需要注意的是re.compile()返回的_sre.SRE_Pattern对象虽然可以使用pickle保存下来, 但是这只是个假象, 实际上它只是保存了你需要编译的正则式内容, 之后实例化回来会重新调用re.compile去重新编译, 对于提高加载速度是毫无帮助的.

　　查看python re模块的源码可以发现, 实际上re.compile最终调用到的是sre_compile的compile, 而这个sre_compile可以明确的分为prev_compile和post_compile(名字是我起的), 以python2.7的re源代码为例, __version__是2.2.1, 我看了下python3.5的re, __version__是没有变化的. 下面是sre_compile.compile的代码

 def compile(p, flags=0):
     # internal: convert pattern list to internal format

     if isstring(p):
         import sre_parse
         pattern = p
         p = sre_parse.parse(p, flags)
     else:
         pattern = None

     code = _code(p, flags)

     # print code

     # XXX: <fl> get rid of this limitation!
     if p.pattern.groups > 100:
         raise AssertionError(
             "sorry, but this version only supports 100 named groups"
             )

     # map in either direction
     groupindex = p.pattern.groupdict
     indexgroup = [None] * p.pattern.groups
     for k, i in groupindex.items():
         indexgroup[i] = k

     return _sre.compile(
         pattern, flags | p.pattern.flags, code,
         p.pattern.groups-1,
         groupindex, indexgroup
         )

　　以#print code为分界, 上面的部分为prev_compile, 之后为post_compile, 前面的预处理产生的p和code最终会传到更底层的_sre.compile接口作为参数, p是由sre_parse.parse()调用产生, 生成的结果是list, 我认为是进行sre_compile的opcode, 通过opcode最终生成code, 而生成code的调用是最为耗时的, 最最重要的是, 这部分p和code都是python的list, 可以通过pickle保存到文件当中, 这样实际上就已经解决了re预编译正则式耗时的问题, 不过由于post_compile最终还会用到你的正则表达式, 所以, 正则式的内容还是必须保留, 并且有一个一一对应的关系, 即你生成的p, code, 需要对应你的pattern.

　　我们游戏最终的解决方案是把预编译结果生成为一个.py文件, 之后直接在脚本当中import进行post_compile, 下面是具体的代码

 import sys
 sys.path.append( "../../script/data" )

 def prev_compile( p, flags = 0 ):
     import sre_compile, sre_parse
     if sre_compile.isstring( p ):
         p = sre_parse.parse( p, flags )

     code = sre_compile._code( p, flags )
     return p, code

 def post_compile( pattern, p, code, flags = 0 ):
     import _sre
     if p.pattern.groups > 100:
         raise AssertionError( "sorry, but this version only supports 100 named groups" )

     groupindex = p.pattern.groupdict
     indexgroup = [None] * p.pattern.groups
     for k, i in groupindex.items():
         indexgroup[i] = k

     return _sre.compile(
         pattern, flags | p.pattern.flags, code,
         p.pattern.groups-1,
         groupindex, indexgroup
         )

 def precompile():
     import cPickle as pickle
     import FilterProp
     name_p = []
     name_code = []
     for s in FilterProp.NameFilter:
         s = s.decode( "utf-8" )
         p, code = prev_compile( s )
         name_p.append( p )
         name_code.append( code )

     word_p = []
     word_code = []
     for s in FilterProp.WordFilter:
         s = s.decode( "utf-8" )
         p, code = prev_compile( s )
         word_p.append( p )
         word_code.append( code )

     with file( "../../script/precompile.py", "w" ) as f:
         name_p_s = repr( pickle.dumps( name_p ) )
         name_code_s = repr( pickle.dumps( name_code ) )
         word_p_s = repr( pickle.dumps( word_p ) )
         word_code_s = repr( pickle.dumps( word_code ) )
         print >> f, "#-*- coding: utf-8 -*-"
         print >> f, "precompile = ["
         print >> f, name_p_s, ","
         print >> f, name_code_s, ","
         print >> f, word_p_s, ","
         print >> f, word_code_s
         print >> f, "]"

 if __name__ == "__main__":
     precompile()

FilterProp是具体的正则式配置, 包括了WordFilter和NameFilter, 上面的代码最终生成了一个precompile.py文件, 里面就包括了prev_compile生成的p, code, 之后客户端启动利用这部分结构, 调用post_compile生成_sre.SRE_Pattern对象, 极大的提升了效率, 对于需要预编译大量正则式的需求来说, 这个解决方案还是挺优雅的.

参考资料:

http://stackoverflow.com/questions/4037339/is-there-a-way-to-really-pickle-compiled-regular-expressions-in-python