易读性/认知负荷偏好

对我来说，主要的收获是我只需要记住和阅读复杂的正则表达式API语法的一种形式——<compiled_pattern>.method(xxx)形式而不是那个和re.func(<pattern>， xxx)形式。

re.compile(<pattern>)是一个额外的样板文件，true。

但是考虑到正则表达式，额外的编译步骤不太可能是认知负荷的主要原因。事实上，对于复杂的模式，您甚至可以通过将声明与随后对其调用的任何regex方法分开来获得清晰性。

我倾向于首先在Regex101这样的网站中调优复杂的模式，甚至在单独的最小测试脚本中调优，然后将它们带入我的代码中，因此将声明与其使用分离也适合我的工作流程。

对我来说，re.compile的最大好处是能够将正则表达式的定义与其使用分开。

即使是一个简单的表达式，如0|[1-9][0-9]*(以10为基数，不带前导零的整数)，也可能非常复杂，以至于您宁愿不重新输入它，检查是否有任何拼写错误，然后在开始调试时重新检查是否有拼写错误。另外，使用像num或num_b10这样的变量名比0|[1-9][0-9]*更好。

当然可以存储字符串并将它们传递给re.match;然而，这就不那么容易读了:

num = "..."
# then, much later:
m = re.match(num, input)

与编译:

num = re.compile("...")
# then, much later:
m = num.match(input)

虽然它很接近，但当重复使用时，第二句的最后一行感觉更自然、更简单。

使用第二个版本时，正则表达式在使用之前会进行编译。如果你要多次执行它，最好先编译它。如果不是每次编译都匹配一次性的是好的。

我有很多运行一个编译过的正则表达式和实时编译的经验，并没有注意到任何可感知的差异。显然，这只是传闻，当然也不是反对编译的有力论据，但我发现两者之间的差异可以忽略不计。

编辑: 在快速浏览了实际的Python 2.5库代码后，我发现无论何时使用正则表达式(包括调用re.match())， Python都会在内部编译和缓存正则表达式，因此实际上只在正则表达式被编译时进行更改，并且不应该节省太多时间——只节省检查缓存所需的时间(对内部dict类型的键查找)。

来自re.py模块(评论是我的):

def match(pattern, string, flags=0):
    return _compile(pattern, flags).match(string)

def _compile(*key):

    # Does cache check at top of function
    cachekey = (type(key[0]),) + key
    p = _cache.get(cachekey)
    if p is not None: return p

    # ...
    # Does actual compilation on cache miss
    # ...

    # Caches compiled regex
    if len(_cache) >= _MAXCACHE:
        _cache.clear()
    _cache[cachekey] = p
    return p

我仍然经常预编译正则表达式，但只是为了将它们绑定到一个漂亮的、可重用的名称，而不是为了任何预期的性能提升。

尽管这两种方法在速度方面是可以比较的，但是您应该知道，如果您正在处理数百万次迭代，那么仍然存在一些可以忽略不计的时间差。

以下速度测试:

import re
import time

SIZE = 100_000_000

start = time.time()
foo = re.compile('foo')
[foo.search('bar') for _ in range(SIZE)]
print('compiled:  ', time.time() - start)

start = time.time()
[re.search('foo', 'bar') for _ in range(SIZE)]
print('uncompiled:', time.time() - start)

给出了以下结果:

compiled:   14.647532224655151
uncompiled: 61.483458042144775

编译后的方法在我的PC上(使用Python 3.7.0)始终快大约4倍。

如文档中所述:

如果在循环中访问正则表达式，预编译它将节省一些函数调用。在循环之外，由于内部缓存，没有太大区别。

这个答案可能姗姗来迟，但却是一个有趣的发现。如果你打算多次使用regex，使用compile真的可以节省你的时间(这在文档中也有提到)。下面你可以看到，当直接调用match方法时，使用编译后的正则表达式是最快的。将一个编译好的正则表达式传递给re.match会使它更慢，而将re.match与patter字符串传递在中间的某个地方。

>>> ipr = r'\D+((([0-2][0-5]?[0-5]?)\.){3}([0-2][0-5]?[0-5]?))\D+'
>>> average(*timeit.repeat("re.match(ipr, 'abcd100.10.255.255 ')", globals={'ipr': ipr, 're': re}))
1.5077415757028423
>>> ipr = re.compile(ipr)
>>> average(*timeit.repeat("re.match(ipr, 'abcd100.10.255.255 ')", globals={'ipr': ipr, 're': re}))
1.8324008992184038
>>> average(*timeit.repeat("ipr.match('abcd100.10.255.255 ')", globals={'ipr': ipr, 're': re}))
0.9187896518778871