有什么理由不使用'+'连接两个字符串？

Question

Python中常见的反模式是+在循环中连接一系列字符串.这很糟糕,因为Python解释器必须为每次迭代创建一个新的字符串对象,并最终获得二次时间.(在某些情况下,CPython的最新版本显然可以优化它,但是其他实现不能,因此不鼓励程序员依赖它.)''.join是正确的方法.

不过,我听人说(这里包括对堆栈溢出),你应该永远不会使用+字符串连接,而是始终使用''.join或格式字符串.我不明白为什么如果你只是连接两个字符串就是这种情况.如果我的理解是正确的,它不应该花费二次时间,我认为a + b比任何一个''.join((a, b))或更清晰,更可读'%s%s' % (a, b).

+用于连接两个字符串是一种好习惯吗？还是有一个我不知道的问题？

Answer 1

连接两个字符串没有错+.实际上它比阅读更容易''.join([a, b]).

你是对的,虽然连接超过2个字符串+是一个O(n ^ 2)操作(与O(n)相比join),因此效率低下.然而,这与使用循环无关.甚至a + b + c + ...是O(n ^ 2),原因是每个连接产生一个新的字符串.

CPython2.4及更高版本试图减轻这种情况,但是join当连接超过2个字符串时仍然建议使用它.

Answer 2

Plus运算符是连接两个 Python字符串的完美解决方案.但是如果你继续添加两个以上的字符串(n> 25),你可能想要想别的东西.

''.join([a, b, c]) 技巧是性能优化.

Answer 3

假设一个人永远不应该使用+进行字符串连接,而是总是使用'​​'.join可能是一个神话.确实,使用+创建不可变的字符串对象的不必要的临时副本,但另一个不引用的事实是,join在循环中调用通常会增加开销function call.让我们举个例子.

创建两个列表,一个来自链接的SO问题,另一个是更大的捏造

>>> myl1 = ['A','B','C','D','E','F']
>>> myl2=[chr(random.randint(65,90)) for i in range(0,10000)]

让我们创建两个函数,UseJoin并UsePlus使用相应的join和+功能性.

>>> def UsePlus():
    return [myl[i] + myl[i + 1] for i in range(0,len(myl), 2)]

>>> def UseJoin():
    [''.join((myl[i],myl[i + 1])) for i in range(0,len(myl), 2)]

让我们用第一个列表运行timeit

>>> myl=myl1
>>> t1=timeit.Timer("UsePlus()","from __main__ import UsePlus")
>>> t2=timeit.Timer("UseJoin()","from __main__ import UseJoin")
>>> print "%.2f usec/pass" % (1000000 * t1.timeit(number=100000)/100000)
2.48 usec/pass
>>> print "%.2f usec/pass" % (1000000 * t2.timeit(number=100000)/100000)
2.61 usec/pass
>>> 

它们的运行时几乎相同.

让我们使用cProfile

>>> myl=myl2
>>> cProfile.run("UsePlus()")
         5 function calls in 0.001 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.001    0.001    0.001    0.001 <pyshell#1376>:1(UsePlus)
        1    0.000    0.000    0.001    0.001 <string>:1(<module>)
        1    0.000    0.000    0.000    0.000 {len}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
        1    0.000    0.000    0.000    0.000 {range}


>>> cProfile.run("UseJoin()")
         5005 function calls in 0.029 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.015    0.015    0.029    0.029 <pyshell#1388>:1(UseJoin)
        1    0.000    0.000    0.029    0.029 <string>:1(<module>)
        1    0.000    0.000    0.000    0.000 {len}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
     5000    0.014    0.000    0.014    0.000 {method 'join' of 'str' objects}
        1    0.000    0.000    0.000    0.000 {range}

并且看起来使用Join会导致不必要的函数调用,从而增加开销.

现在回到这个问题.在所有情况下,是否应该阻止使用+over join？

我相信不,应该考虑事情

1. 问题中字符串的长度
2. 否连接操作.

在开发过程中,预先成熟的优化是邪恶的.

Answer 4

与多人合作时,有时很难确切知道发生了什么.使用格式字符串而不是连接可以避免一个特定的烦恼发生在我们身上很多次:

比如说,一个函数需要一个参数,你写它期望得到一个字符串:

In [1]: def foo(zeta):
   ...:     print 'bar: ' + zeta

In [2]: foo('bang')
bar: bang

因此,在整个代码中可能经常使用此函数.你的同事可能确切知道它的作用,但不一定完全在内部加速,并且可能不知道该函数需要一个字符串.所以他们最终可能会这样:

In [3]: foo(23)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)

/home/izkata/<ipython console> in <module>()

/home/izkata/<ipython console> in foo(zeta)

TypeError: cannot concatenate 'str' and 'int' objects

如果您只使用格式字符串,则没有问题:

In [1]: def foo(zeta):
   ...:     print 'bar: %s' % zeta
   ...:     
   ...:     

In [2]: foo('bang')
bar: bang

In [3]: foo(23)
bar: 23

对于定义的所有类型的对象也是如此__str__,它们也可以传入:

In [1]: from datetime import date

In [2]: zeta = date(2012, 4, 15)

In [3]: print 'bar: ' + zeta
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)

/home/izkata/<ipython console> in <module>()

TypeError: cannot concatenate 'str' and 'datetime.date' objects

In [4]: print 'bar: %s' % zeta
bar: 2012-04-15

所以,是的:如果你可以使用格式字符串做到这一点,并好好利用一下Python有提供.