哪个是在Python中连接字符串的首选方法？

时间：2012-08-29 01:46:03

标签： python string python-3.x concat

由于Python的string无法更改，我想知道如何更有效地连接字符串？

我可以这样写：

s += stringfromelsewhere

或者像这样：

s = []
s.append(somestring)

later

s = ''.join(s)

在写这个问题时，我发现了一篇很好的文章谈论这个话题。

http://www.skymind.com/~ocrow/python_string/

但它在Python 2.x.中，所以问题是在Python 3中做了哪些改变？

12 个答案:

答案 0 :(得分：366)

将字符串附加到字符串变量的最佳方法是使用+或+=。这是因为它可读且快速。它们也同样快，你选择的是品味问题，后者是最常见的问题。以下是timeit模块的时间安排：

a = a + b:
0.11338996887207031
a += b:
0.11040496826171875

然而，那些建议拥有列表并附加到这些列表然后加入这些列表的人这样做是因为将字符串附加到列表可能与扩展字符串相比非常快。在某些情况下，这可能是真的。例如，这里是一个 百万个附加一个字符的字符串，首先是一个字符串，然后是一个列表：

a += b:
0.10780501365661621
a.append(b):
0.1123361587524414

好的，事实证明，即使结果字符串长达一百万个字符，追加仍然更快。

现在让我们尝试将一千个字符长的字符串附加十万次：

a += b:
0.41823482513427734
a.append(b):
0.010656118392944336

因此，结束字符串最终长约100MB。这很慢，附加到列表要快得多。该时间不包括最终a.join()。那需要多长时间？ 

a.join(a):
0.43739795684814453

Oups。即使在这种情况下，附加/加入也会变慢。

那么这个推荐来自哪里？ Python 2？

a += b:
0.165287017822
a.append(b):
0.0132720470428
a.join(a):
0.114929914474

好吧，如果你使用非常长的字符串（你通常不使用，你会在内存中使用100MB的字符串，那么追加/加入略微更快

但真正的关键是Python 2.3。在哪里我甚至不会告诉你时间，因为它太慢而还没有完成。这些测试突然耗时分钟。除了追加/连接之外，它与后来的Pythons一样快。

烨。在石器时代，Python中的字符串连接非常慢。但是在2.4上它不再是（或者至少是Python 2.4.7），所以使用append / join的建议在2008年过时了，当时Python 2.3停止更新，你应该已经停止使用它了。 ： - ）

（更新：当我更仔细地进行测试时，使用+和+=对Python 2.3上的两个字符串来说更快。建议使用{{1} <必须是一个误解）

然而，这是CPython。其他实现可能有其他问题。这也是为什么过早优化是万恶之源的另一个原因。除非你先测量它，否则不要使用“更快”的技术。

因此，进行字符串连接的“最佳”版本是使用+或+ = 。如果这对你来说变得很慢，这是不太可能的，那就去做别的事了。

那么为什么我在代码中使用了大量的append / join？因为有时它实际上更清晰。特别是当你应该连接在一起时，应该用空格或逗号或换行符分隔。

答案 1 :(得分：40)

如果要连接很多值，那么两者都没有。附加清单很昂贵。您可以使用StringIO。特别是如果你在很多操作中进行构建。

from cStringIO import StringIO
# python3:  from io import StringIO

buf = StringIO()

buf.write('foo')
buf.write('foo')
buf.write('foo')

buf.getvalue()
# 'foofoofoo'

如果您已经从其他操作返回了完整列表，那么只需使用''.join(aList)

来自python FAQ：What is the most efficient way to concatenate many strings together?

  

str和bytes对象是不可变的，因此连接很多   由于每个连接创建一个新的，因此字符串在一起是低效的   宾语。在一般情况下，总运行时间成本是二次方的   总字符串长度。

     

为了积累许多str对象，推荐的习惯用法是放置它们   到列表中并在最后调用str.join（）：

chunks = []
for s in my_strings:
    chunks.append(s)
result = ''.join(chunks)
     

（另一个合理有效的习惯用法是使用io.StringIO）

     

要累积许多字节对象，推荐的习惯用语是扩展a   使用就地连接的bytearray对象（+ =运算符）：

result = bytearray()
for b in my_bytes_objects:
    result += b

编辑：我很傻，并且将结果粘贴回来，使得看起来像是附加到列表比cStringIO更快。我还添加了对bytearray / str concat的测试，以及使用带有更大字符串的更大列表的第二轮测试。 （python 2.7.3）

大型字符串列表的ipython测试示例 

try:
    from cStringIO import StringIO
except:
    from io import StringIO

source = ['foo']*1000

%%timeit buf = StringIO()
for i in source:
    buf.write(i)
final = buf.getvalue()
# 1000 loops, best of 3: 1.27 ms per loop

%%timeit out = []
for i in source:
    out.append(i)
final = ''.join(out)
# 1000 loops, best of 3: 9.89 ms per loop

%%timeit out = bytearray()
for i in source:
    out += i
# 10000 loops, best of 3: 98.5 µs per loop

%%timeit out = ""
for i in source:
    out += i
# 10000 loops, best of 3: 161 µs per loop

## Repeat the tests with a larger list, containing
## strings that are bigger than the small string caching 
## done by the Python
source = ['foo']*1000

# cStringIO
# 10 loops, best of 3: 19.2 ms per loop

# list append and join
# 100 loops, best of 3: 144 ms per loop

# bytearray() +=
# 100 loops, best of 3: 3.8 ms per loop

# str() +=
# 100 loops, best of 3: 5.11 ms per loop

答案 2 :(得分：13)

在Python＆gt; = 3.6中，新的f-string是连接字符串的有效方法。

>>> name = 'some_name'
>>> number = 123
>>>
>>> f'Name is {name} and the number is {number}.'
'Name is some_name and the number is 123.'

答案 3 :(得分：7)

推荐的方法仍然是使用追加和加入。

答案 4 :(得分：7)

如果要连接的字符串是文字，请使用String literal concatenation 

re.compile(
        "[A-Za-z_]"       # letter or underscore
        "[A-Za-z0-9_]*"   # letter, digit or underscore
    )

如果您想要对字符串的一部分进行评论（如上所述），或者您希望对文字的一部分使用raw strings或三引号但不是全部，则此功能非常有用。

由于这在语法层发生，因此它使用零连接运算符。

答案 5 :(得分：6)

通过＆＃39; +＆＃39;使用就地字符串连接在稳定性和交叉实现方面是最糟糕的连接方法，因为它不支持所有值。 PEP8标准不鼓励这样做，并鼓励使用format（），join（）和append（）进行长期使用。

答案 6 :(得分：5)

虽然有点过时，Code Like a Pythonista: Idiomatic Python建议join()超过+ in this section。与PythonSpeedPerformanceTips一节中的string concatenation一样，并附带以下免责声明：

  

本节的准确性在以后有争议   Python的版本。在CPython 2.5中，字符串连接是公平的   快，虽然这可能不适用于其他Python   实现。请参阅ConcatenationTestCode以进行讨论。

答案 7 :(得分：4)

你写这个功能

def str_join(*args):
    return ''.join(map(str, args))

然后你可以随时随地打电话

str_join('Pine')  # Returns : Pine
str_join('Pine', 'apple')  # Returns : Pineapple
str_join('Pine', 'apple', 3)  # Returns : Pineapple3

答案 8 :(得分：3)

正如@jdi所提到的，Python文档建议使用str.join或io.StringIO进行字符串连接。并说，即使Python 2.4以来有了优化，开发人员也应该期待+=的二次时间。正如this的回答所说：

  

如果Python检测到left参数没有其他引用，它将调用realloc来尝试通过调整字符串的大小来避免复制。这不是您应该依靠的东西，因为它是实现细节，并且因为如果realloc最终需要频繁移动字符串，那么性能无论如何都会降级为O（n ^ 2）。

我将展示一个真实的代码示例，该示例天真地依靠+=这种优化，但是并没有应用。下面的代码将可迭代的短字符串转换为更大的块，以用于批量API。

def test_concat_chunk(seq, split_by):
    result = ['']
    for item in seq:
        if len(result[-1]) + len(item) > split_by: 
            result.append('')
        result[-1] += item
    return result

由于二次时间的复杂性，该代码可能在文学上运行数小时。以下是具有建议的数据结构的替代方案：

import io

def test_stringio_chunk(seq, split_by):
    def chunk():
        buf = io.StringIO()
        size = 0
        for item in seq:
            if size + len(item) <= split_by:
                size += buf.write(item)
            else:
                yield buf.getvalue()
                buf = io.StringIO()
                size = buf.write(item)
        if size:
            yield buf.getvalue()

    return list(chunk())

def test_join_chunk(seq, split_by):
    def chunk():
        buf = []
        size = 0
        for item in seq:
            if size + len(item) <= split_by:
                buf.append(item)
                size += len(item)
            else:
                yield ''.join(buf)                
                buf.clear()
                buf.append(item)
                size = len(item)
        if size:
            yield ''.join(buf)

    return list(chunk())

还有一个微基准测试

： 
import timeit
import random
import string
import matplotlib.pyplot as plt

line = ''.join(random.choices(
    string.ascii_uppercase + string.digits, k=512)) + '\n'
x = []
y_concat = []
y_stringio = []
y_join = []
n = 5
for i in range(1, 11):
    x.append(i)
    seq = [line] * (20 * 2 ** 20 // len(line))
    chunk_size = i * 2 ** 20
    y_concat.append(
        timeit.timeit(lambda: test_concat_chunk(seq, chunk_size), number=n) / n)
    y_stringio.append(
        timeit.timeit(lambda: test_stringio_chunk(seq, chunk_size), number=n) / n)
    y_join.append(
        timeit.timeit(lambda: test_join_chunk(seq, chunk_size), number=n) / n)
plt.plot(x, y_concat)
plt.plot(x, y_stringio)
plt.plot(x, y_join)
plt.legend(['concat', 'stringio', 'join'], loc='upper left')
plt.show()

micro-benchmark

答案 9 :(得分：2)

我的用例略有不同。我不得不构建一个查询，其中超过20个字段是动态的。 我遵循这种使用格式方法的方法

query = "insert into {0}({1},{2},{3}) values({4}, {5}, {6})"
query.format('users','name','age','dna','suzan',1010,'nda')

这对我来说相对简单，而不是使用+或其他方式

答案 10 :(得分：2)

您可以用不同的方式来做。

str1 = "Hello"
str2 = "World"
str_list = ['Hello', 'World']
str_dict = {'str1': 'Hello', 'str2': 'World'}

# Concatenating With the + Operator
print(str1 + ' ' + str2)  # Hello World

# String Formatting with the % Operator
print("%s %s" % (str1, str2))  # Hello World

# String Formatting with the { } Operators with str.format()
print("{}{}".format(str1, str2))  # Hello World
print("{0}{1}".format(str1, str2))  # Hello World
print("{str1} {str2}".format(str1=str_dict['str1'], str2=str_dict['str2']))  # Hello World
print("{str1} {str2}".format(**str_dict))  # Hello World

# Going From a List to a String in Python With .join()
print(' '.join(str_list))  # Hello World

# Python f'strings --> 3.6 onwards
print(f"{str1} {str2}")  # Hello World

我通过以下文章创建了这个小总结。

答案 11 :(得分：1)

您也可以使用此功能（效率更高）。 （https://softwareengineering.stackexchange.com/questions/304445/why-is-s-better-than-for-concatenation）

s += "%s" %(stringfromelsewhere)
相关问题
最新问题