python中最有效的字符串连接方法是什么？

Question

有没有在Python任何有效的质量字符串连接方法(如StringBuilder的 C#或StringBuffer的在Java中)？我在这里找到了以下方法:

• 使用简单连接 +
• 使用字符串列表和join方法
• 使用UserString来自MutableString模块
• 使用字符数组和array模块
• 使用cStringIO来自StringIO模块

但是,您的专家使用或建议了什么？为什么？

[ 这里的相关问题 ]

Answer 1

您可能对此感兴趣:Guido 的优化轶事.虽然值得记住的是,这是一篇旧文章,它早于存在的事情''.join(虽然我猜string.joinfields是或多或少相同)

基于此,如果您可以将问题塞入其中,则array模块可能是最快的.但是''.join可能足够快并且具有惯用性的好处,因此其他python程序员更容易理解.

最后,优化的黄金法则:不要优化,除非你知道你需要,并测量而不是猜测.

您可以使用该timeit模块测量不同的方法.这可以告诉你哪个是最快的,而不是互联网上的随机陌生人猜测.

Answer 2

''.join(sequenceofstrings) 通常效果最好 - 最简单,最快捷.

Answer 3

Python 3.6使用Literal String Interpolation改变了已知组件的字符串连接游戏.

鉴于mkoistinen的答案中的测试用例,有字符串

domain = 'some_really_long_example.com'
lang = 'en'
path = 'some/really/long/path/'

竞争者是

• f'http://{domain}/{lang}/{path}'- 0.151μs

• 'http://%s/%s/%s' % (domain, lang, path) - 0.321μs

• 'http://' + domain + '/' + lang + '/' + path - 0.356μs

• ''.join(('http://', domain, '/', lang, '/', path))- 0.249μs(注意构建一个恒定长度的元组比构建一个常量列表略快).

因此,目前最短和最漂亮的代码也是最快的.

在Python的alpha版本中,f''字符串的实现是最慢的 - 实际上生成的字节代码几乎等同于''.join()不必要的调用str.__format__,没有参数的情况只会self保持不变.这些低效率在3.6决赛前得到解决.

速度可以与Python 2的最快方法形成对比,这是+我计算机上的连接; 对于8位字符串,它需要0.203μs;如果字符串都是Unicode ,则需要0.259μs.

Answer 4

这取决于你在做什么.

在Python 2.5之后,使用+运算符的字符串连接非常快.如果您只是连接几个值,使用+运算符效果最佳:

>>> x = timeit.Timer(stmt="'a' + 'b'")
>>> x.timeit()
0.039999961853027344

>>> x = timeit.Timer(stmt="''.join(['a', 'b'])")
>>> x.timeit()
0.76200008392333984

但是,如果您将一个字符串放在循环中,最好使用列表连接方法:

>>> join_stmt = """
... joined_str = ''
... for i in xrange(100000):
...   joined_str += str(i)
... """
>>> x = timeit.Timer(join_stmt)
>>> x.timeit(100)
13.278000116348267

>>> list_stmt = """
... str_list = []
... for i in xrange(100000):
...   str_list.append(str(i))
... ''.join(str_list)
... """
>>> x = timeit.Timer(list_stmt)
>>> x.timeit(100)
12.401000022888184

...但请注意,在差异变得明显之前,您必须将相对较多的字符串组合在一起.

Answer 5

根据John Fouhy的回答,除非你必须这样做,否则不要优化,但如果你在这里问这个问题,可能正是因为你必须这样做.就我而言,我需要从字符串变量中快速组装一些URL.我注意到没有人(到目前为止)似乎正在考虑字符串格式方法,所以我想我会尝试这一点,并且主要是为了温和的兴趣,我以为我会在那里抛出字符串插值运算符以获得良好的测量值.说实话,我认为其中任何一个都不会直接与'+'操作或''.join()相叠加.但猜猜怎么了？在我的Python 2.7.5系统中,字符串插值运算符将它们全部规则化,而string.format()是表现最差的:

# concatenate_test.py

from __future__ import print_function
import timeit

domain = 'some_really_long_example.com'
lang = 'en'
path = 'some/really/long/path/'
iterations = 1000000

def meth_plus():
    '''Using + operator'''
    return 'http://' + domain + '/' + lang + '/' + path

def meth_join():
    '''Using ''.join()'''
    return ''.join(['http://', domain, '/', lang, '/', path])

def meth_form():
    '''Using string.format'''
    return 'http://{0}/{1}/{2}'.format(domain, lang, path)

def meth_intp():
    '''Using string interpolation'''
    return 'http://%s/%s/%s' % (domain, lang, path)

plus = timeit.Timer(stmt="meth_plus()", setup="from __main__ import meth_plus")
join = timeit.Timer(stmt="meth_join()", setup="from __main__ import meth_join")
form = timeit.Timer(stmt="meth_form()", setup="from __main__ import meth_form")
intp = timeit.Timer(stmt="meth_intp()", setup="from __main__ import meth_intp")

plus.val = plus.timeit(iterations)
join.val = join.timeit(iterations)
form.val = form.timeit(iterations)
intp.val = intp.timeit(iterations)

min_val = min([plus.val, join.val, form.val, intp.val])

print('plus %0.12f (%0.2f%% as fast)' % (plus.val, (100 * min_val / plus.val), ))
print('join %0.12f (%0.2f%% as fast)' % (join.val, (100 * min_val / join.val), ))
print('form %0.12f (%0.2f%% as fast)' % (form.val, (100 * min_val / form.val), ))
print('intp %0.12f (%0.2f%% as fast)' % (intp.val, (100 * min_val / intp.val), ))

结果:

# python2.7 concatenate_test.py
plus 0.360787868500 (90.81% as fast)
join 0.452811956406 (72.36% as fast)
form 0.502608060837 (65.19% as fast)
intp 0.327636957169 (100.00% as fast)

如果我使用较短的域和较短的路径,插值仍然会胜出.但是,使用更长的字符串,差异更明显.

现在我有一个不错的测试脚本,我也在Python 2.6,3.3和3.4下进行了测试,这是结果.在Python 2.6中,plus运算符是最快的!在Python 3上,加入胜出.注意:这些测试在我的系统上非常可重复.因此,'plus'在2.6上总是更快,'intp'在2.7上总是更快,'join'在Python 3.x上总是更快.

# python2.6 concatenate_test.py
plus 0.338213920593 (100.00% as fast)
join 0.427221059799 (79.17% as fast)
form 0.515371084213 (65.63% as fast)
intp 0.378169059753 (89.43% as fast)

# python3.3 concatenate_test.py
plus 0.409130576998 (89.20% as fast)
join 0.364938726001 (100.00% as fast)
form 0.621366866995 (58.73% as fast)
intp 0.419064424001 (87.08% as fast)

# python3.4 concatenate_test.py
plus 0.481188605998 (85.14% as fast)
join 0.409673971997 (100.00% as fast)
form 0.652010936996 (62.83% as fast)
intp 0.460400978001 (88.98% as fast)

# python3.5 concatenate_test.py
plus 0.417167026084 (93.47% as fast)
join 0.389929617057 (100.00% as fast)
form 0.595661019906 (65.46% as fast)
intp 0.404455224983 (96.41% as fast)

学过的知识:

• 有时,我的假设是错误的.
• 针对系统环境进行测试 你将在生产中运行.
• 字符串插值还没死!

TL;博士:

• 如果使用2.6,请使用+运算符.
• 如果您使用2.7,请使用'%'运算符.
• 如果你使用3.x使用''.join().

Answer 6

它在很大程度上取决于每次新连接后新字符串的相对大小。使用+运算符，每次连接都会生成一个新字符串。如果中间字符串相对较长，则+速度会越来越慢，因为正在存储新的中间字符串。

考虑这个案例：

from time import time
stri=''
a='aagsdfghfhdyjddtyjdhmfghmfgsdgsdfgsdfsdfsdfsdfsdfsdfddsksarigqeirnvgsdfsdgfsdfgfg'
l=[]
#case 1
t=time()
for i in range(1000):
    stri=stri+a+repr(i)
print time()-t

#case 2
t=time()
for i in xrange(1000):
    l.append(a+repr(i))
z=''.join(l)
print time()-t

#case 3
t=time()
for i in range(1000):
    stri=stri+repr(i)
print time()-t

#case 4
t=time()
for i in xrange(1000):
    l.append(repr(i))
z=''.join(l)
print time()-t

结果

1 0.00493192672729

2 0.000509023666382

3 0.00042200088501

4 0.000482797622681

在 1&2 的情况下，我们添加了一个大字符串，join() 的执行速度大约快了 10 倍。在第 3 和第 4 种情况下，我们添加一个小字符串，并且 '+' 执行速度稍快

Answer 7

对于 python 3.8.6/3.9，我不得不做一些肮脏的黑客攻击，因为 perfplot 给出了一些错误。这里假设x[0]是 aa并且x[1]是b：

对于大数据，该图几乎相同。对于小数据，

由 perfplot 获取，这是代码，大数据 == 范围（8），小数据 == 范围（4）。

import perfplot

from random import choice
from string import ascii_lowercase as letters

def generate_random(x):
    data = ''.join(choice(letters) for i in range(x))
    sata = ''.join(choice(letters) for i in range(x))
    return [data,sata]

def fstring_func(x):
    return [ord(i) for i in f'{x[0]}{x[1]}']

def format_func(x):
    return [ord(i) for i in "{}{}".format(x[0], x[1])]

def replace_func(x):
    return [ord(i) for i in "|~".replace('|', x[0]).replace('~', x[1])]

def join_func(x):
    return [ord(i) for i in "".join([x[0], x[1]])]

perfplot.show(
    setup=lambda n: generate_random(n),
    kernels=[
        fstring_func,
        format_func,
        replace_func,
        join_func,
    ],
    n_range=[int(k ** 2.5) for k in range(4)],
)

当有中等数据并且有 4 个字符串时，x[0], x[1], x[2],x[3]而不是 2 个字符串：

def generate_random(x):
    a =  ''.join(choice(letters) for i in range(x))
    b =  ''.join(choice(letters) for i in range(x))
    c =  ''.join(choice(letters) for i in range(x))
    d =  ''.join(choice(letters) for i in range(x))
    return [a,b,c,d]

最好坚持使用 fstrings。%s 的速度也类似于 .format()