python中的快速字符串修改

Question

这部分是一个理论问题：

我有一个字符串（比如 UTF-8），我需要修改它，使每个字符（不是字节）变成 2 个字符，例如：

"Nissim" becomes "N-i-s-s-i-m-"


"01234" becomes "0a1b2c3d4e" 

等等。 我怀疑循环中的幼稚连接会太昂贵（这是瓶颈，这应该一直发生）。

我要么使用一个数组（预先分配），要么尝试制作我自己的 C 模块来处理这个问题。

有人对这种事情有更好的想法吗？

（请注意，问题始终与多字节编码有关，对于 UTF-8 也必须解决），

哦，它的 Python 2.5，所以这里没有闪亮的 Python 3 东西可用。

谢谢

Answer 1

@gnosis，当心所有好心的回应者说你应该衡量时间：是的，你应该（因为程序员的直觉往往不符合性能），但是衡量一个单一的这种情况，就像目前为止提供的所有timeit 示例一样，忽略了一个关键的考虑因素——big-O。

您的直觉是正确的：一般而言（在极少数特殊情况下，最近的 Python 版本可以稍微优化一些东西，但不会延伸很远），通过循环构建字符串+= 的碎片（或reduce 等）必须是O(N**2)，因为许多中间对象分配和这些对象内容的不可避免的重复复制；加入、正则表达式和上述答案中未提及的第三个选项（cStringIO.StringIO 实例的write 方法）是O(N) 解决方案，因此除非您碰巧知道 确保您要操作的字符串的长度有适度的上限。

那么，如果有的话，您正在处理的字符串的长度上限是多少？如果您能给我们一个想法，可以在代表性感兴趣的长度范围内运行基准测试（例如，“通常少于 100 个字符，但在某些情况下可能只有几千个字符" 将是这个性能评估的一个很好的规范：IOW，它不需要非常精确，只是表明你的问题空间）。

我还注意到，似乎没有人遵循您规范中的一个关键和困难点：字符串是 Python 2.5 多字节、UTF-8 编码、strs，并且插入必须仅在每个“完整字符”之后发生, not 在每个 byte 之后。每个人似乎都在“在 str 上循环”，它给出了每个字节，而不是您明确指定的每个 字符。

在多字节编码字节str 中“循环字符”确实没有好的、快速的方法；最好的办法是.decode('utf-8')，给出一个 unicode 对象——处理 unicode 对象（循环 do 正确地遍历字符！），然后在最后返回.encode。到目前为止，通常最好的方法是在整个代码的核心中仅使用 not 编码 strs 的 unicode 对象；仅在 I/O 上对字节字符串进行编码和解码（如果必须，因为您需要与仅支持字节字符串而不支持正确 Unicode 的子系统进行通信）。

因此，我强烈建议您考虑这种“最佳方法”并相应地重组您的代码：unicode 无处不在，除非在必要时才可以对其进行编码/解码的边界。对于“处理”部分，你会更喜欢 unicode 对象，而不是拖着笨拙的多字节编码字符串！-)

编辑：忘记评论您提到的一种可能的方法——array.array。这确实是 O(N) if 你只是 追加 到你正在构建的新数组的末尾（一些追加会使数组增长到超过以前分配的容量，因此需要重新分配和复制数据，但是，就像列表一样，中等指数的过度分配策略允许 append 被 摊销 O(1)，因此 N 追加为 O(N))。

但是，通过中间重复的insert 操作来构建一个数组（同样，就像一个列表）是O(N**2)，因为每个 O(N) 插入必须移动所有 O(N)以下项目（假设先前存在的项目的数量和新插入的项目的数量相互成比例，这似乎是您的具体要求的情况）。

所以，array.array('u') 加上重复的appends（not inserts!-）是可以解决您的问题的第四种 O(N) 方法（在除了我已经提到的三个之外：join、re 和 cStringIO) -- 那些 一旦你明确了感兴趣的长度范围，就值得进行基准测试，因为我上面提到过。

Answer 2

尝试使用re module 构建结果。它将在引擎盖下进行令人讨厌的连接，因此性能应该没问题。示例：

 import re
 re.sub(r'(.)', r'\1-', u'Nissim')

 count = 1
 def repl(m):
     global count
     s = m.group(1) + unicode(count)
     count += 1
     return s
 re.sub(r'(.)', repl, u'Nissim')

Answer 3

这可能是一个 python 有效的解决方案：

s1="Nissim"
s2="------"
s3=''.join([''.join(list(x)) for x in zip(s1,s2)])

Answer 4

你有没有测试过它有多慢或者你需要多快，我认为这样的东西就足够快了

s = u"\u0960\u0961"
ss = ''.join(sum(map(list,zip(s,"anurag")),[]))

所以尝试最简单，如果还不够，请尝试改进它，C 模块应该是最后的选择

编辑：这也是最快的

import timeit

s1="Nissim"
s2="------"

timeit.f1=lambda s1,s2:''.join(sum(map(list,zip(s1,s2)),[]))
timeit.f2=lambda s1,s2:''.join([''.join(list(x)) for x in zip(s1,s2)])
timeit.f3=lambda s1,s2:''.join(i+j for i, j in zip(s1, s2))

N=100000

print "anurag",timeit.Timer("timeit.f1('Nissim', '------')","import timeit").timeit(N)
print "dweeves",timeit.Timer("timeit.f2('Nissim', '------')","import timeit").timeit(N)
print "SilentGhost",timeit.Timer("timeit.f3('Nissim', '------')","import timeit").timeit(N)

输出是

anurag 1.95547590546
dweeves 2.36131184271
SilentGhost 3.10855625505

Answer 5

这是我的时间安排。注意，是py3.1

>>> s1
'Nissim'
>>> s2 = '-' * len(s1)
>>> timeit.timeit("''.join(i+j for i, j in zip(s1, s2))", "from __main__ import s1, s2")
3.5249209707199043
>>> timeit.timeit("''.join(sum(map(list,zip(s1,s2)),[]))", "from __main__ import s1, s2")
5.903614027402
>>> timeit.timeit("''.join([''.join(list(x)) for x in zip(s1,s2)])", "from __main__ import s1, s2")
6.04072124013328
>>> timeit.timeit("''.join(i+'-' for i in s1)", "from __main__ import s1, s2")
2.484378367653335
>>> timeit.timeit("reduce(lambda x, y : x+y+'-', s1, '')", "from __main__ import s1; from functools import reduce")
2.290644129319844

Answer 6

使用减少。

>>> str = "Nissim"
>>> reduce(lambda x, y : x+y+'-', str, '')
'N-i-s-s-i-m-'

数字也一样，只要你知道哪个字符映射到哪个字符。 [dict可以很方便]

>>> mapper = dict([(repr(i), chr(i+ord('a'))) for i in range(9)])
>>> str1 = '0123'
>>> reduce(lambda x, y : x+y+mapper[y], str1, '')
'0a1b2c3d'

Answer 7

string="™¡™©€"
unicode(string,"utf-8")
s2='-'*len(s1)
''.join(sum(map(list,zip(s1,s2)),[])).encode("utf-8")