使用 ord 搜索字符串比使用 'in' 方法慢

Posted 2023-03-06

【中文标题】使用 ord 搜索字符串比使用 \'in\' 方法慢

【英文标题】：String searching with ord is slower than with 'in' method使用 ord 搜索字符串比使用 'in' 方法慢

【发布时间】：2014-03-26 01:06:09

【问题描述】：

我有两个版本的一些简单文本解析器（它验证登录正确性）：

rgx = re.compile(r"^[a-zA-Z][a-zA-Z0-9.-]0,18[a-zA-Z0-9]$")
def rchecker(login):
    return bool(rgx.match(login))

max_len = 20
def occhecker(login):
    length_counter = max_len
    for c in login:
        o = ord(c)
        if length_counter == max_len:
            if not (o > 96 and o < 123) and \
               not (o > 64 and o < 91): return False
        if length_counter == 0: return False

        # not a digit
        # not a uppercase letter
        # not a downcase letter
        # not a minus or dot
        if not (o > 47 and o < 58) and \
           not (o > 96 and o < 123) and \
           not (o > 64 and o < 91) and \
           o != 45 and o != 46: return False
        length_counter -= 1

    if length_counter < max_len:
        o = ord(c)
        if not (o > 47 and o < 58) and \
           not (o > 96 and o < 123) and \
           not (o > 64 and o < 91): return False
        else: return True
    else: return False


correct_end = string.ascii_letters + string.digits
correct_symbols = correct_end + "-."
def cchecker(login):
    length_counter = max_len

    for c in login:
        if length_counter == max_len and c not in string.ascii_letters:
            return False
        if length_counter == 0:
            return False
        if c not in correct_symbols:
            return False
        length_counter -= 1

    if length_counter < max_len and c in correct_end:
        return True
    else:
        return False

有三种方法可以完成所有相同的工作：检查登录规则。我认为正则表达式规则很清楚。 我对这些方法进行了 280000 次登录的 cProfile 基准测试，得到了我无法理解的结果。

使用正则表达式

     560001 function calls in 1.202 seconds

 Ordered by: standard name

 ncalls  tottime  percall  cumtime  percall filename:lineno(function)
 280000    0.680    0.000    1.202    0.000 logineffcheck.py:10(rchecker)
      1    0.000    0.000    0.000    0.000 method 'disable' of '_lsprof.Profiler' objects
 280000    0.522    0.000    0.522    0.000 method 'match' of '_sre.SRE_Pattern' objects

按顺序

    3450737 function calls in 8.599 seconds

 Ordered by: standard name

 ncalls  tottime  percall  cumtime  percall filename:lineno(function)
 280000    5.802    0.000    8.599    0.000 logineffcheck.py:14(occhecker)
      1    0.000    0.000    0.000    0.000 method 'disable' of '_lsprof.Profiler' objects
3170736    2.797    0.000    2.797    0.000 ord

在方法中

    280001 function calls in 1.709 seconds

 Ordered by: standard name

 ncalls  tottime  percall  cumtime  percall filename:lineno(function)
 280000    1.709    0.000    1.709    0.000 logineffcheck.py:52(cchecker)
      1    0.000    0.000    0.000    0.000 method 'disable' of '_lsprof.Profiler' objects

我创建了 100k 个正确格式的登录，60k 个西里尔字母的登录，60k 个登录的长度为 24 而不是 20，60k 的登录长度为 0。所以，有 280k。如何解释正则表达式比使用 ord 的简单循环要快得多？

【参考方案1】：

简单的答案是正则表达式很快（其他方法涉及大量纯 python 代码，但正则表达式模块是优化的 C）。此外，编译正则表达式时会执行许多繁琐的工作，而这不计入性能计数器中。

要进一步挖掘，请使用dis 模块（它向您展示了 python 操作码）：

>>> dis.dis(rchecker)
  4           0 LOAD_GLOBAL              0 (bool)
              3 LOAD_GLOBAL              1 (rgx)
              6 LOAD_ATTR                2 (match)
              9 LOAD_FAST                0 (login)
             12 CALL_FUNCTION            1
             15 CALL_FUNCTION            1
             18 RETURN_VALUE



>>> dis.dis(occhecker)
  8           0 LOAD_GLOBAL              0 (max_len)
              3 STORE_FAST               1 (length_counter)

  9           6 SETUP_LOOP             224 (to 233)
              9 LOAD_FAST                0 (login)
             12 GET_ITER
        >>   13 FOR_ITER               216 (to 232)
             16 STORE_FAST               2 (c)

   ....  OUTPUT TRUNCATED, BUT THERE ARE MANY OPCODES ....

 32     >>  343 LOAD_GLOBAL              2 (False)
            346 RETURN_VALUE
        >>  347 LOAD_CONST               0 (None)
            350 RETURN_VALUE

【讨论】：

感谢 dis 模块。但最奇怪的地方在于，使用 ord 的函数实在是太慢了。

我没有深入研究操作，但我怀疑有很多函数调用ord（这就是为什么它更慢）