如何在 Python 中将一个字符串附加到另一个字符串？

Question

我想要一种在 Python 中将一个字符串附加到另一个字符串的有效方法，除了以下内容。

var1 = "foo"
var2 = "bar"
var3 = var1 + var2

有什么好的内置方法可以使用吗？

Answer 1

使用 add 函数附加字符串：

str1 = "Hello"
str2 = " World"
str3 = str1.__add__(str2)
print(str3)

输出：

Hello World

Answer 2

Python 3.6 为我们提供了 f-strings，这是一种享受：

var1 = "foo"
var2 = "bar"
var3 = f"{var1}{var2}"
print(var3)                       # prints foobar

花括号内几乎可以做任何事情

print(f"1 + 1 == {1 + 1}")        # prints 1 + 1 == 2

Answer 3

如果你需要做很多追加操作来构建一个大字符串，你可以使用StringIO或cStringIO。界面就像一个文件。即：您 write 将文本附加到它。

如果您只是附加两个字符串，那么只需使用 +。

Answer 4

基本上没有区别。唯一一致的趋势是每个版本的 Python 似乎都变得越来越慢...... :(

---

列表

%%timeit
x = []
for i in range(100000000):  # xrange on Python 2.7
    x.append('a')
x = ''.join(x)

Python 2.7

1 次循环，3 次取胜：7.34 秒/次

Python 3.4

1 次循环，3 次取胜：7.99 秒/次

Python 3.5

1 次循环，3 次取胜：8.48 秒/次

Python 3.6

1 次循环，3 次取胜：9.93 秒/次

---

字符串

%%timeit
x = ''
for i in range(100000000):  # xrange on Python 2.7
    x += 'a'

Python 2.7：

1 个循环，3 次取胜：7.41 秒每个循环

Python 3.4

1 次循环，3 次取胜：9.08 秒/次

Python 3.5

1 次循环，3 次取胜：8.82 秒/次

Python 3.6

1 次循环，3 次取胜：每次循环 9.24 秒

Answer 5

如果您只有一个对字符串的引用，并且您将另一个字符串连接到末尾，CPython 现在会处理这种特殊情况并尝试就地扩展字符串。

最终结果是操作摊销O(n)。

例如

s = ""
for i in range(n):
    s+=str(i)

以前是O(n^2)，现在是O(n)。

来自源（bytesobject.c）：

void
PyBytes_ConcatAndDel(register PyObject **pv, register PyObject *w)
{
    PyBytes_Concat(pv, w);
    Py_XDECREF(w);
}


/* The following function breaks the notion that strings are immutable:
   it changes the size of a string.  We get away with this only if there
   is only one module referencing the object.  You can also think of it
   as creating a new string object and destroying the old one, only
   more efficiently.  In any case, don't use this if the string may
   already be known to some other part of the code...
   Note that if there's not enough memory to resize the string, the original
   string object at *pv is deallocated, *pv is set to NULL, an "out of
   memory" exception is set, and -1 is returned.  Else (on success) 0 is
   returned, and the value in *pv may or may not be the same as on input.
   As always, an extra byte is allocated for a trailing \0 byte (newsize
   does *not* include that), and a trailing \0 byte is stored.
*/

int
_PyBytes_Resize(PyObject **pv, Py_ssize_t newsize)
{
    register PyObject *v;
    register PyBytesObject *sv;
    v = *pv;
    if (!PyBytes_Check(v) || Py_REFCNT(v) != 1 || newsize < 0) {
        *pv = 0;
        Py_DECREF(v);
        PyErr_BadInternalCall();
        return -1;
    }
    /* XXX UNREF/NEWREF interface should be more symmetrical */
    _Py_DEC_REFTOTAL;
    _Py_ForgetReference(v);
    *pv = (PyObject *)
        PyObject_REALLOC((char *)v, PyBytesObject_SIZE + newsize);
    if (*pv == NULL) {
        PyObject_Del(v);
        PyErr_NoMemory();
        return -1;
    }
    _Py_NewReference(*pv);
    sv = (PyBytesObject *) *pv;
    Py_SIZE(sv) = newsize;
    sv->ob_sval[newsize] = '\0';
    sv->ob_shash = -1;          /* invalidate cached hash value */
    return 0;
}

凭经验验证很容易。

$ python -m timeit -s"s=''" "for i in xrange(10):s+='a'" 1000000 次循环，3 次中的最佳：每个循环 1.85 微秒 $ python -m timeit -s"s=''" "for i in xrange(100):s+='a'" 10000 次循环，3 次中的最佳：每个循环 16.8 微秒 $ python -m timeit -s"s=''" "for i in xrange(1000):s+='a'" 10000 个循环，3 个中最好的：每个循环 158 微秒 $ python -m timeit -s"s=''" "for i in xrange(10000):s+='a'" 1000 个循环，3 个循环中的最佳：每个循环 1.71 毫秒 $ python -m timeit -s"s=''" "for i in xrange(100000):s+='a'" 10 个循环，3 个循环中的最佳：每个循环 14.6 毫秒 $ python -m timeit -s"s=''" "for i in xrange(1000000):s+='a'" 10 个循环，3 个循环中的最佳：每个循环 173 毫秒

重要的是但请注意，此优化不是 Python 规范的一部分。据我所知，它仅在 cPython 实现中。例如，对 pypy 或 jython 的相同经验测试可能会显示较旧的 O(n**2) 性能。

$ pypy -m timeit -s"s=''" "for i in xrange(10):s+='a'" 10000 个循环，最好的 3 个：每个循环 90.8 微秒 $ pypy -m timeit -s"s=''" "for i in xrange(100):s+='a'" 1000 个循环，最好的 3 个：每个循环 896 微秒 $ pypy -m timeit -s"s=''" "for i in xrange(1000):s+='a'" 100 个循环，3 个循环中的最佳：每个循环 9.03 毫秒 $ pypy -m timeit -s"s=''" "for i in xrange(10000):s+='a'" 10 个循环，3 个循环中的最佳：每个循环 89.5 毫秒

到目前为止一切都很好，但是，

$ pypy -m timeit -s"s=''" "for i in xrange(100000):s+='a'" 10 个循环，3 个循环中的最佳：每个循环 12.8 秒

哎哟比二次方还要糟糕。所以 pypy 对短字符串表现良好，但对大字符串表现不佳。

Answer 6

这真的取决于您的应用程序。如果您要遍历数百个单词并希望将它们全部附加到一个列表中，.join() 会更好。但如果你要写一个长句子，你最好使用+=。

Answer 7

a='foo'
b='baaz'

a.__add__(b)

out: 'foobaaz'

Answer 8

不要。

也就是说，在大多数情况下，最好一次性生成整个字符串，而不是附加到现有字符串。

例如，不要这样做：obj1.name + ":" + str(obj1.count)

改为：使用"%s:%d" % (obj1.name, obj1.count)

这样会更容易阅读，效率更高。

Answer 9

不要过早优化。如果您没有理由相信字符串连接会导致速度瓶颈，那么请坚持使用+ 和+=：

s  = 'foo'
s += 'bar'
s += 'baz'

也就是说，如果您的目标是 Java 的 StringBuilder，规范的 Python 习惯用法是将项目添加到列表中，然后使用 str.join 将它们全部连接到最后：

l = []
l.append('foo')
l.append('bar')
l.append('baz')

s = ''.join(l)

Answer 10

str1 = "Hello"
str2 = "World"
newstr = " ".join((str1, str2))

用空格作为分隔符将 str1 和 str2 连接起来。你也可以"".join(str1, str2, ...)。 str.join() 采用可迭代对象，因此您必须将字符串放入列表或元组中。

这与内置方法的效率差不多。