В чем разница между ".append ()" и "+ = []" в Python?

Question

В чем разница между:

some_list1 = []
some_list1.append("something")

и

some_list2 = []
some_list2 += ["something"]

Answer 1

Для вашего случая единственная разница заключается в производительности: добавление в два раза быстрее.

Python 3.0 (r30:67507, Dec  3 2008, 20:14:27) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> timeit.Timer('s.append("something")', 's = []').timeit()
0.20177424499999999
>>> timeit.Timer('s += ["something"]', 's = []').timeit()
0.41192320500000079

Python 2.5.1 (r251:54863, Apr 18 2007, 08:51:08) [MSC v.1310 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> timeit.Timer('s.append("something")', 's = []').timeit()
0.23079359499999999
>>> timeit.Timer('s += ["something"]', 's = []').timeit()
0.44208112500000141

В общем случае append добавит один элемент в список, а += скопирует все элементы правого списка в левый список.

Обновление: перф анализ

Сравнивая байт-коды, мы можем предположить, что append версия тратит впустую циклы в LOAD_ATTR + CALL_FUNCTION, а + = версия - в BUILD_LIST. Видимо BUILD_LIST перевешивает LOAD_ATTR + CALL_FUNCTION.

>>> import dis
>>> dis.dis(compile("s = []; s.append('spam')", '', 'exec'))
  1           0 BUILD_LIST               0
              3 STORE_NAME               0 (s)
              6 LOAD_NAME                0 (s)
              9 LOAD_ATTR                1 (append)
             12 LOAD_CONST               0 ('spam')
             15 CALL_FUNCTION            1
             18 POP_TOP
             19 LOAD_CONST               1 (None)
             22 RETURN_VALUE
>>> dis.dis(compile("s = []; s += ['spam']", '', 'exec'))
  1           0 BUILD_LIST               0
              3 STORE_NAME               0 (s)
              6 LOAD_NAME                0 (s)
              9 LOAD_CONST               0 ('spam')
             12 BUILD_LIST               1
             15 INPLACE_ADD
             16 STORE_NAME               0 (s)
             19 LOAD_CONST               1 (None)
             22 RETURN_VALUE

Мы можем еще больше повысить производительность, удалив LOAD_ATTR накладных расходов:

>>> timeit.Timer('a("something")', 's = []; a = s.append').timeit()
0.15924410999923566

Answer 2

В приведенном вами примере нет разницы с точки зрения производительности между append и +=. Но есть разница между append и + (о чем изначально задавался вопрос).

>>> a = []
>>> id(a)
11814312
>>> a.append("hello")
>>> id(a)
11814312

>>> b = []
>>> id(b)
11828720
>>> c = b + ["hello"]
>>> id(c)
11833752
>>> b += ["hello"]
>>> id(b)
11828720

Как видите, append и += имеют одинаковый результат; они добавляют элемент в список, не создавая новый список. Использование + добавляет два списка и создает новый список.

Answer 3

>>> a=[]
>>> a.append([1,2])
>>> a
[[1, 2]]
>>> a=[]
>>> a+=[1,2]
>>> a
[1, 2]

Обратите внимание, что append добавляет в список один элемент, который может быть любым. +=[] присоединяется к спискам.

Answer 4

+ = это назначение. Когда вы используете его, вы на самом деле говорите: «some_list2 = some_list2 + [« что-то »]». Задания предполагают повторное связывание, поэтому:

l= []

def a1(x):
    l.append(x) # works

def a2(x):
    l= l+[x] # assign to l, makes l local
             # so attempt to read l for addition gives UnboundLocalError

def a3(x):
    l+= [x]  # fails for the same reason

Оператор + = также должен обычно создавать новый объект списка, как обычно делает list + list:

>>> l1= []
>>> l2= l1

>>> l1.append('x')
>>> l1 is l2
True

>>> l1= l1+['x']
>>> l1 is l2
False

Однако на самом деле:

>>> l2= l1
>>> l1+= ['x']
>>> l1 is l2
True

Это связано с тем, что списки Python реализуют __ iadd __ () для создания короткого замыкания расширенного присваивания + и вызова взамен списка. (Это немного странно: это обычно делает то, что вы имели в виду, но по непонятным причинам.)

В общем, если вы добавляете / расширяете существующий список и хотите сохранить ссылку на тот же список (вместо создания нового), лучше всего быть явным и придерживаться append () / методы extend ().

Answer 5

 some_list2 += ["something"]

на самом деле

 some_list2.extend(["something"])

для одного значения разницы нет. Документация гласит, что:

s.append(x) так же, как s[len(s):len(s)] = [x]
s.extend(x) так же, как s[len(s):len(s)] = x

Таким образом, очевидно, s.append(x) совпадает с s.extend([x])

Answer 6

Разница в том, что сцепление сгладит результирующий список, тогда как append сохранит уровни неизменными:

Так, например, с:

myList = [ ]
listA = [1,2,3]
listB = ["a","b","c"]

Используя append, вы получаете список списков:

>> myList.append(listA)
>> myList.append(listB)
>> myList
[[1,2,3],['a',b','c']]

Используя вместо этого конкатенацию, вы получите плоский список:

>> myList += listA + listB
>> myList
[1,2,3,"a","b","c"]

Answer 7

Тесты производительности здесь не верны:

1. Вы не должны запускать профиль только один раз.
2. Если вы сравниваете добавление с + = [] количество раз, вы должны объявить добавление как локальную функцию.
3. Временные результаты различны для разных версий Python: 64 и 32 бит

например.

timeit.Timer ('для i в xrange (100): app (i)', 's = []; app = s.append'). Timeit ()

хорошие тесты можно найти здесь: http://markandclick.com/1/post/2012/01/python-list-append-vs.html

Answer 8

В дополнение к аспектам, описанным в других ответах, добавление и + [] ведут себя очень по-разному при попытке создать список списков.

>>> list1=[[1,2],[3,4]]
>>> list2=[5,6]
>>> list3=list1+list2
>>> list3
[[1, 2], [3, 4], 5, 6]
>>> list1.append(list2)
>>> list1
[[1, 2], [3, 4], [5, 6]]

list1 + ['5', '6'] добавляет '5' и '6' в список 1 как отдельные элементы. list1.append (['5', '6']) добавляет список ['5', '6'] в список list1 как один элемент.

Answer 9

Поведение переплета, упомянутое в других ответах, имеет значение при определенных обстоятельствах:

>>> a = ([],[])
>>> a[0].append(1)
>>> a
([1], [])
>>> a[1] += [1]
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Это потому, что расширенное присваивание всегда повторяется, даже если объект был мутирован на месте. Здесь происходит повторная привязка a[1] = *mutated list*, которая не работает для кортежей.

Answer 10

Метод append () добавляет один элемент в существующий список. Он не возвращает новый список, скорее он изменяет исходный список.

some_list1 = []
some_list1.append("something")

Так что здесь some_list1 будет изменен.

Тогда как + для объединения элементов списков возвращает новый список.

some_list2 = []
some_list2 += ["something"]

Так что здесь some_list2 и ["что-то"] - это два списка, которые объединяются, и возвращается новый список, который назначен some_list2