use*_*652 572 python string append
我想要一种有效的方法在Python中将一个字符串附加到另一个字符串.
var1 = "foo"
var2 = "bar"
var3 = var1 + var2
有没有什么好的内置方法可供使用？
Joh*_*ooy 587
如果你只有一个字符串的引用,并且你将另一个字符串连接到结尾,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 loops, best of 3: 1.85 usec per loop $ python -m timeit -s"s=''" "for i in xrange(100):s+='a'" 10000 loops, best of 3: 16.8 usec per loop $ python -m timeit -s"s=''" "for i in xrange(1000):s+='a'" 10000 loops, best of 3: 158 usec per loop $ python -m timeit -s"s=''" "for i in xrange(10000):s+='a'" 1000 loops, best of 3: 1.71 msec per loop $ python -m timeit -s"s=''" "for i in xrange(100000):s+='a'" 10 loops, best of 3: 14.6 msec per loop $ python -m timeit -s"s=''" "for i in xrange(1000000):s+='a'" 10 loops, best of 3: 173 msec per loop
这一点很重要要注意的是这种优化是不是Python的规范的一部分.但是.据我所知,这只是在cPython实现中.例如,对于pypy或jython的相同经验测试可能会显示较旧的O(n**2)性能.
$ pypy -m timeit -s"s=''" "for i in xrange(10):s+='a'" 10000 loops, best of 3: 90.8 usec per loop $ pypy -m timeit -s"s=''" "for i in xrange(100):s+='a'" 1000 loops, best of 3: 896 usec per loop $ pypy -m timeit -s"s=''" "for i in xrange(1000):s+='a'" 100 loops, best of 3: 9.03 msec per loop $ pypy -m timeit -s"s=''" "for i in xrange(10000):s+='a'" 10 loops, best of 3: 89.5 msec per loop
到目前为止很好,但是,
$ pypy -m timeit -s"s=''" "for i in xrange(100000):s+='a'" 10 loops, best of 3: 12.8 sec per loop
哎哟比二次更糟糕.因此pypy正在做一些适用于短字符串的东西,但对于较大的字符串表现不佳.
Joh*_*ica 277
不要过早优化.如果你没有理由相信有致的字符串连接的速度瓶颈,那么就坚持+和+=:
s = 'foo'
s += 'bar'
s += 'baz'
也就是说,如果你的目标是像Java的StringBuilder那样,那么规范的Python习惯就是将项添加到列表中,然后用str.join它们将它们连接起来:
l = []
l.append('foo')
l.append('bar')
l.append('baz')
s = ''.join(l)
Win*_*ert 38
别.
也就是说,对于大多数情况,您最好一次性生成整个字符串,而不是附加到现有字符串.
例如,不要这样做: obj1.name + ":" + str(obj1.count)
相反:使用 "%s:%d" % (obj1.name, obj1.count)
这将更容易阅读和更有效.
Raf*_*ler 37
str1 = "Hello"
str2 = "World"
newstr = " ".join((str1, str2))
这将str1和str2与空格连接为分隔符.你也可以"".join(str1, str2, ...).str.join()采用可迭代的,所以你必须把字符串放在列表或元组中.
这与内置方法一样高效.
Python 3.6为我们提供了f字符串，这很令人高兴：
var1 = "foo"
var2 = "bar"
var3 = f"{var1}{var2}"
print(var3) # prints foobar
您可以在花括号内执行大多数操作
print(f"1 + 1 == {1 + 1}") # prints 1 + 1 == 2
使用add函数附加字符串：
str1 = "Hello"
str2 = " World"
str3 = str1.__add__(str2)
print(str3)
输出：
Hello World
基本上没有区别。唯一一致的趋势是，每个版本的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 s 最佳
Python 3.4
1个循环，每个循环最好3：7.99 s
Python 3.5
1次循环，每循环3：8.48 s 最佳
Python 3.6
1次循环，每循环3：9.93 s 最佳
%%timeit
x = ''
for i in range(100000000): # xrange on Python 2.7
x += 'a'
Python 2.7：
1次循环，每循环3：7.41 s最佳
Python 3.4
1个循环，每个循环最好3：9.08 s
Python 3.5
1次循环，每循环3：8.82 s 最佳
Python 3.6
1次循环，每循环3：9.24 s 最佳