为什么编译的python正则表达式更慢？

时间：2017-11-24 16:48:38

标签： python regex python-3.x

在another SO question中，比较了正则表达式和Python的in运算符的性能。但是，接受的答案使用re.match，它只匹配字符串的开头，因此与in的行为完全不同。另外，我希望看到每次都不重新编译RE的性能提升。

令人惊讶的是，我发现预编译的版本似乎较慢。

任何想法为什么？

我知道这里还有很多其他问题让人想知道类似的问题。他们中的大多数执行他们的方式只是因为他们没有正确地重用已编译的正则表达式。如果这也是我的问题，请解释。

from timeit import timeit
import re

pattern = 'sed'
text = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod' \
       'tempor incididunt ut labore et dolore magna aliqua.'

compiled_pattern = re.compile(pattern)

def find():
    assert text.find(pattern) > -1

def re_search():
    assert re.search(pattern, text)

def re_compiled():
    assert re.search(compiled_pattern, text)

def in_find():
    assert pattern in text

print('str.find     ', timeit(find))
print('re.search    ', timeit(re_search))
print('re (compiled)', timeit(re_compiled))
print('in           ', timeit(in_find))

输出：

str.find      0.36285957560356435
re.search     1.047689160564772
re (compiled) 1.575113873320307
in            0.1907925627077569

1 个答案:

答案 0 :(得分：9)

简短回答

如果您直接致电compiled_pattern.search(text)，则根本不会致电_compile，它会比re.search(pattern, text)快，并且比re.search(compiled_pattern, text)快得多。

这种性能差异是由于缓存中的KeyError和编译模式的缓慢哈希计算所致。

re个函数和SRE_Pattern方法

每当调用re作为第一个参数pattern的{​​{1}}函数（例如re.search(pattern, string)或re.findall(pattern, string)）时，Python会尝试首先编译pattern使用_compile然后在编译的模式上调用相应的方法。对于example：

def search(pattern, string, flags=0):
    """Scan through string looking for a match to the pattern, returning
    a match object, or None if no match was found."""
    return _compile(pattern, flags).search(string)

请注意pattern可以是字符串或已编译的模式（SRE_Pattern实例）。

_compile

这是_compile的紧凑版本。我只是删除了调试和标志检查：

_cache = {}
_pattern_type = type(sre_compile.compile("", 0))
_MAXCACHE = 512

def _compile(pattern, flags):
    try:
        p, loc = _cache[type(pattern), pattern, flags]
        if loc is None or loc == _locale.setlocale(_locale.LC_CTYPE):
            return p
    except KeyError:
        pass
    if isinstance(pattern, _pattern_type):
        return pattern
    if not sre_compile.isstring(pattern):
        raise TypeError("first argument must be string or compiled pattern")
    p = sre_compile.compile(pattern, flags)
    if len(_cache) >= _MAXCACHE:
        _cache.clear()
    loc = None
    _cache[type(pattern), pattern, flags] = p, loc
    return p
带字符串模式的

_compile

当使用字符串模式调用_compile时，编译的模式将保存在_cache dict中。下次调用相同的函数时（例如在许多timeit运行期间），_compile只是检查_cache是否已经看到此字符串并返回相应的编译模式。

在Spyder中使用ipdb调试器，在执行期间很容易深入re.py。

import re

pattern = 'sed'
text = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod' \
       'tempor incididunt ut labore et dolore magna aliqua.'

compiled_pattern = re.compile(pattern)

re.search(pattern, text)
re.search(pattern, text)

在第二个re.search(pattern, text)处有一个断点，可以看出该对：

{(<class 'str'>, 'sed', 0): (re.compile('sed'), None)}

保存在_cache中。编译的模式直接返回。

带编译模式的

_compile

慢哈希

如果使用已编译的模式调用_compile会发生什么？

首先，_compile检查模式是否在_cache中。为此，它需要计算其哈希值。对于编译模式而言，此计算要慢于字符串：

In [1]: import re

In [2]: pattern = "(?:a(?:b(?:b\\é|sorbed)|ccessing|gar|l(?:armists|ternation)|ngels|pparelled|u(?:daciousness's|gust|t(?:horitarianism's|obiographi
   ...: es)))|b(?:aden|e(?:nevolently|velled)|lackheads|ooze(?:'s|s))|c(?:a(?:esura|sts)|entenarians|h(?:eeriness's|lorination)|laudius|o(?:n(?:form
   ...: ist|vertor)|uriers)|reeks)|d(?:aze's|er(?:elicts|matologists)|i(?:nette|s(?:ciplinary|dain's))|u(?:chess's|shanbe))|e(?:lectrifying|x(?:ampl
   ...: ing|perts))|farmhands|g(?:r(?:eased|over)|uyed)|h(?:eft|oneycomb|u(?:g's|skies))|i(?:mperturbably|nterpreting)|j(?:a(?:guars|nitors)|odhpurs
   ...: 's)|kindnesses|m(?:itterrand's|onopoly's|umbled)|n(?:aivet\\é's|udity's)|p(?:a(?:n(?:els|icky|tomimed)|tios)|erpetuating|ointer|resentation|
   ...: yrite)|r(?:agtime|e(?:gret|stless))|s(?:aturated|c(?:apulae|urvy's|ylla's)|inne(?:rs|d)|m(?:irch's|udge's)|o(?:lecism's|utheast)|p(?:inals|o
   ...: onerism's)|tevedore|ung|weetest)|t(?:ailpipe's|easpoon|h(?:ermionic|ighbone)|i(?:biae|entsin)|osca's)|u(?:n(?:accented|earned)|pstaging)|v(?
   ...: :alerie's|onda)|w(?:hirl|ildfowl's|olfram)|zimmerman's)"

In [3]: compiled_pattern = re.compile(pattern)

In [4]: % timeit hash(pattern)
126 ns ± 0.358 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [5]: % timeit hash(compiled_pattern)
7.67 µs ± 21 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

hash(compiled_pattern)比hash(pattern)慢60倍。

KeyError

当pattern未知时，_cache[type(pattern), pattern, flags]会因KeyError而失败。

处理并忽略KeyError。只有这样_compile才能检查模式是否已编译。如果是，则返回，而不是写入缓存。

这意味着下次使用相同的编译模式调用_compile时，它将再次计算无用的慢速哈希值，但仍会因KeyError而失败。

错误处理很昂贵，我认为这是re.search(compiled_pattern, text)慢于re.search(pattern, text)的主要原因。

这种奇怪的行为可能是加速使用字符串模式调用的一种选择，但如果使用已编译的模式调用_compile，则编写警告可能是个好主意。

相关问题
最新问题