python - 有没有办法在 Python 2 中使用带有正则表达式的内存 View ？

Question

在 Python 3 中，re模块可以与 memoryview 一起使用:

~$ python3
Python 3.2.3 (default, Feb 20 2013, 14:44:27)
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> x = b"abc"
>>> import re
>>> re.search(b"b", memoryview(x))
<_sre.SRE_Match object at 0x7f14b5fb8988>

然而，在 Python 2 中，情况似乎并非如此:

~$ python
Python 2.7.3 (default, Mar 13 2014, 11:03:55)
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> x = "abc"
>>> import re
>>> re.search(b"b", memoryview(x))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.7/re.py", line 142, in search
    return _compile(pattern, flags).search(string)
TypeError: expected string or buffer

我可以将字符串转换为 buffer，但查看 buffer documentation ，它没有具体说明 buffer 与 memoryview 相比如何工作。

进行经验比较表明，在 Python 2 中使用 buffer 对象并不能提供在 Python 3 中使用 memoryview 的性能优势:

playground$ cat speed-test.py
import timeit
import sys

print(timeit.timeit("regex.search(mv[10:])", setup='''
import re
regex = re.compile(b"ABC")
PYTHON_3 = sys.version_info >= (3, )
if PYTHON_3:
    mv = memoryview(b"Can you count to three or sing 'ABC?'" * 1024)
else:
    mv = buffer(b"Can you count to three or sing 'ABC?'" * 1024)
'''))
playground$ python2.7 speed-test.py
2.33041596413
playground$ python2.7 speed-test.py
2.3322429657
playground$ python3.2 speed-test.py
0.381270170211792
playground$ python3.2 speed-test.py
0.3775448799133301
playground$

如果将 regex.search 参数从 mv[10:] 更改为 mv，则 Python 2 的性能与 Python 大致相同3，但在我编写的代码中，有很多重复的字符串切片。

有没有办法在 Python 2 中规避这个问题，同时仍然具有 memoryview 的零拷贝性能优势？

Answer 1

我理解 buffer object 的方式在 Python 2 中，你应该在没有切片的情况下使用它:

>>> s = b"Can you count to three or sing 'ABC?'"
>>> str(buffer(s, 10))
"unt to three or sing 'ABC?'"

因此，您无需对生成的缓冲区进行切片，而是直接使用缓冲区函数来执行切片，从而可以快速访问您感兴趣的子字符串:

import timeit
import sys
import re

r = re.compile(b'ABC')
s = b"Can you count to three or sing 'ABC?'" * 1024

PYTHON_3 = sys.version_info >= (3, )
if len(sys.argv) > 1: # standard slicing
    print(timeit.timeit("r.search(s[10:])", setup='from __main__ import r, s'))
elif PYTHON_3: # memoryview in Python 3
    print(timeit.timeit("r.search(s[10:])", setup='from __main__ import r, s; s = memoryview(s)'))
else: # buffer in Python 2
    print(timeit.timeit("r.search(buffer(s, 10))", setup='from __main__ import r, s'))

我在 Python 2 和 3 中得到了非常相似的结果，这表明像 re 模块那样使用 buffer 与较新的 memoryview(这似乎是一个延迟评估的缓冲区):

$ python2 .\speed-test.py
0.681979371561
$ python3 .\speed-test.py
0.5693422508853488

并作为与标准字符串切片的比较:

$ python2 .\speed-test.py standard-slicing
7.92006735956
$ python3 .\speed-test.py standard-slicing
7.817641705304309

---

如果你想支持切片访问(这样你就可以在任何地方使用相同的语法)，你可以很容易地创建一个类型，当你切片时动态创建一个新的缓冲区:

class slicingbuffer:
    def __init__ (self, source):
        self.source = source
    def __getitem__ (self, index):
        if not isinstance(index, slice):
            return buffer(self.source, index, 1)
        elif index.stop is None:
            return buffer(self.source, index.start)
        else:
            end = max(index.stop - index.start, 0)
            return buffer(self.source, index.start, end)

如果您只将它与 re 模块一起使用，它可能可以作为 memoryview 的直接替代品。但是，我的测试表明这已经给您带来了很大的开销。所以你可能想做相反的事情，将 Python 3 的 memoryview 对象包装在一个包装器中，为你提供与 buffer 相同的接口(interface):

def memoryviewbuffer (source, start, end = -1):
    return source[start:end]

PYTHON_3 = sys.version_info >= (3, )
if PYTHON_3:
    b = memoryviewbuffer
    s = memoryview(s)
else:
    b = buffer

print(timeit.timeit("r.search(b(s, 10))", setup='from __main__ import r, s, b'))