From: candide on 22 Apr 2010 03:10 Suppose a and b are lists. What is more efficient in order to extend the list a by appending all the items in the list b ? I imagine a.extend(b)to be more efficient for only appendinding the items from b while a+=b creates a copy of a before appending, right ? From: Alf P. Steinbach on 22 Apr 2010 03:16 * candide:> Suppose a and b are lists. > > What is more efficient in order to extend the list a by appending all > the items in the list b ? > > > I imagine a.extend(b)to be more efficient for only appendinding the > items from b while a+=b creates a copy of a before appending, right ? No. But in general, if you're concerned about efficiency, *measure*. And keep in mind that measurement results may only be applicable to a given Python implementation, for given data, in a given environment... In most cases you'll do better by focusing on algorithmic efficiency rather than low level operational efficiency. Also keep in mind that when or if operational efficiency becomes an issue, then for Python the answer is in general to use functionality (modules) implemented in other languages. Python is not designed with operational efficiency as a goal. It's designed as an easy language. Cheers & hth., - Alf From: Stefan Behnel on 22 Apr 2010 03:24 candide, 22.04.2010 09:10:> Suppose a and b are lists. > > What is more efficient in order to extend the list a by appending all > the items in the list b ? > > I imagine a.extend(b)to be more efficient for only appendinding the > items from b while a+=b creates a copy of a before appending, right ? Wrong. Try it out yourself: \$ python2.6 -m timeit -s "l=range(1000)" "a=l[:]; a+=l" 100000 loops, best of 3: 9.16 usec per loop \$ python2.6 -m timeit -s "l=range(1000)" "a=l[:]; a.extend(l)" 100000 loops, best of 3: 9.24 usec per loop \$ python2.6 -m timeit -s "l=range(10000)" "a=l[:]; a.extend(l)" 10000 loops, best of 3: 96 usec per loop \$ python2.6 -m timeit -s "l=range(10000)" "a=l[:]; a+=l" 10000 loops, best of 3: 96.7 usec per loop \$ python2.6 -m timeit -s "l=range(10000)" "a=l[:]; a+=l; a+=l" 10000 loops, best of 3: 151 usec per loop \$ python2.6 -m timeit -s "l=range(10000)" \ "a=l[:]; a.extend(l); a.extend(l)" 1000 loops, best of 3: 164 usec per loop Stefan From: candide on 22 Apr 2010 03:31 Alf P. Steinbach a �crit :> * candide: >> Suppose a and b are lists. >> >> What is more efficient in order to extend the list a by appending all >> the items in the list b ? >> >> >> I imagine a.extend(b)to be more efficient for only appendinding the >> items from b while a+=b creates a copy of a before appending, right ? > > No. > > But in general, if you're concerned about efficiency, *measure*. > But my question refers to memory management rather than to time execution. Imagine foo is a big size list and bar is a small one. It would be a waste of memory to copy list foo somewhere in memory before appending the items in bar. From: Peter Otten on 22 Apr 2010 03:28 candide wrote: > Suppose a and b are lists. > > What is more efficient in order to extend the list a by appending all > the items in the list b ? > > > I imagine a.extend(b)to be more efficient for only appendinding the > items from b while a+=b creates a copy of a before appending, right ? No. Both append items to the original list a: >>> a = original_a = [1,2,3] >>> a.extend([4,5,6]) >>> a is original_a # you knew that True>>> a += [7,8,9] # could rebind a >>> a is original_a # but effectively doesn't for lists True (Strictly speaking a += [...] rebinds a to the same value, like a = a) It is mostly a matter of personal preference which form you use. I prefer the extend() method because I think it's clearer; you don't run the risk of mistaking it for an arithmetic operation. Peter PS: an example where += does rebind:>>> a = original_a = (1,2,3) >>> a += (4,5,6) >>> a is original_a False