В чем разница между:
some_list1 = []
some_list1.append("something")
и
some_list2 = []
some_list2 += ["something"]
В Python в чем разница между ".append()" и "+ = []"?
Ответ 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")', = []').timeit()
0.20177424499999999
>>> timeit.Timer( += ["something"]', = []').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")', = []').timeit()
0.23079359499999999
>>> timeit.Timer( += ["something"]', = []').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")', = []; a = s.append').timeit()
0.15924410999923566
Ответ 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 и += имеют одинаковый результат; они добавляют элемент в список, не создавая новый список. Использование + добавляет два списка и создает новый список.
Ответ 3
>>> a=[]
>>> a.append([1,2])
>>> a
[[1, 2]]
>>> a=[]
>>> a+=[1,2]
>>> a
[1, 2]
Посмотрите, что append добавляет в список один элемент, что может быть чем угодно. +=[] объединяет списки.
Ответ 4
+ = - задание. Когда вы его используете, вы действительно говорите "some_list2 = some_list2 + ['something']. Задания включают в себя повторное связывание, поэтому:
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 __(), чтобы сделать короткое замыкание + = расширенное назначение и вызвать list.extend(). (Это немного странная бородавка: она обычно делает то, что вы имели в виду, но из-за путаных причин.)
В общем случае, если вы добавляете/расширяете существующий список и хотите сохранить ссылку на тот же список (вместо создания нового), лучше всего быть явным и придерживаться append()/extend().
Ответ 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])
Ответ 6
Разница в том, что concatenate будет сгладить результирующий список, тогда как append сохранит уровни неповрежденными:
Итак, например:
myList = [ ]
listA = [1,2,3]
listB = ["a","b","c"]
Используя append, вы получите список списков:
>> myList.append(listA)
>> myList.append(listB)
>> myList
[[1,2,3],['a',b','c']]
Используя concatenate, вы получите плоский список:
>> myList += listA + listB
>> myList
[1,2,3,"a","b","c"]
Ответ 7
Тестирование производительности здесь неверно:
- Вы не должны запускать профиль только один раз.
- Если вы сравниваете append vs. + = [] несколько раз, вы должны объявить append как локальную функцию.
- результаты времени разные для разных версий python: 64 и 32 бит
например.
timeit.Timer('для я в xrange (100): app (i)', = []; app = s.append '). timeit()
хорошие тесты можно найти здесь: http://markandclick.com/1/post/2012/01/python-list-append-vs.html
Ответ 8
В дополнение к аспектам, описанным в других ответах, append и + [] имеют очень разные типы поведения, когда вы пытаетесь создать список списков.
>>> 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'] в список1 как один элемент.
Ответ 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*, которое не работает для кортежей.
Ответ 10
давайте сначала возьмем пример
list1=[1,2,3,4]
list2=list1 (that means they points to same object)
if we do
list1=list1+[5] it will create a new object of list
print(list1) output [1,2,3,4,5]
print(list2) output [1,2,3,4]
but if we append then
list1.append(5) no new object of list created
print(list1) output [1,2,3,4,5]
print(list2) output [1,2,3,4,5]
extend(list) also do the same work as append it just append a list instead of a
single variable
Ответ 11
Метод append() добавляет один элемент в существующий список. Он не возвращает новый список, скорее он изменяет исходный список.
some_list1 = []
some_list1.append("something")
Так что здесь some_list1 будет изменен.
В то время как использование + для объединения элементов списков возвращает новый список.
some_list2 = []
some_list2 += ["something"]
Так что здесь some_list2 и ["что-то"] - это два списка, которые объединяются, и возвращается новый список, который назначен some_list2