1

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

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}

用 in 方法

    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 的简单循环要快得多？

4

1 回答 1

0

简单的答案是正则表达式很快（其他方法涉及大量纯 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
于 2014-03-26T01:14:08.243 回答