it-swarm.com.ru

Разница между методами добавления и добавления в Python

В чем разница между методами списка append() и extend()?

2971
Claudiu

append : Добавляет объект в конце.

x = [1, 2, 3]
x.append([4, 5])
print (x)

дает вам: [1, 2, 3, [4, 5]]


extend : Расширяет список, добавляя элементы из итерируемого.

x = [1, 2, 3]
x.extend([4, 5])
print (x)

дает вам: [1, 2, 3, 4, 5]

4504
kender

append добавляет элемент в список, а extend объединяет первый список с другим списком (или другим итеративным, не обязательно списком).

>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']

>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']

>>> li.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', ['new', 2]]

>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']

СПогружение в Python.

562
Harley Holcombe

В чем разница между методами list, добавляющими и расширяющими?

  • append добавляет свой аргумент как отдельный элемент в конец списка. Длина самого списка увеличится на единицу.
  • extend перебирает свой аргумент, добавляя каждый элемент в список, расширяя список. Длина списка будет увеличиваться, сколько бы элементов ни было в итерируемом аргументе.

append

Метод list.append добавляет объект в конец списка.

my_list.append(object) 

Каким бы ни был объект, будь то число, строка, другой список или что-то еще, он добавляется в конец my_list как одна запись в списке. 

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

Так что имейте в виду, что список - это объект. Если вы добавите другой список в список, первый список будет одним объектом в конце списка (что может не соответствовать вашему желанию):

>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
                     #^^^^^^^^^--- single item at the end of the list.

extend

Метод list.extend расширяет список, добавляя элементы из итерируемого:

my_list.extend(iterable)

Таким образом, при расширении каждый элемент повторяемого элемента добавляется в список. Например:

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

Имейте в виду, что строка является итеративной, поэтому, если вы расширяете список строкой, вы добавляете каждый символ в процессе итерации по строке (что может быть не тем, что вы хотите):

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

Перегрузка оператора, __add__+) и __iadd__ (+=)

Операторы + и += определены для list. Они семантически похожи на расширение.

my_list + another_list создает третий список в памяти, поэтому вы можете вернуть его результат, но для этого требуется, чтобы второй итерируемый был список. 

my_list += another_list изменяет список на месте (это _ (isоператор на месте, а списки являются изменяемыми объектами, как мы видели), поэтому он не создает новый список. Он также работает как расширение, в том смысле, что Вторая итерация может быть любой итерацией.

Не запутайтесь - my_list = my_list + another_list не эквивалентен += - он дает вам новый список, назначенный my_list.

Сложность времени

Добавить имеет постоянная сложность времени , O (1). 

Расширение имеет временную сложность, O (k). 

Повторение нескольких вызовов append увеличивает сложность, делая ее эквивалентной расширению, и поскольку итерация расширения реализована в C, она всегда будет быстрее, если вы собираетесь добавлять последовательные элементы из итерируемого в список.

Спектакль

Вы можете задаться вопросом, что является более производительным, поскольку append можно использовать для достижения того же результата, что и extension. Следующие функции делают то же самое:

def append(alist, iterable):
    for item in iterable:
        alist.append(item)

def extend(alist, iterable):
    alist.extend(iterable)

Итак, давайте их время:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883

Обращаясь к комментарию по времени

Комментатор сказал:

Идеальный ответ, я просто не могу сравнить время добавления только одного элемента

Делайте семантически правильную вещь. Если вы хотите добавить все элементы в итерацию, используйте extend. Если вы просто добавляете один элемент, используйте append.

Итак, давайте создадим эксперимент, чтобы увидеть, как это работает во времени:

def append_one(a_list, element):
    a_list.append(element)

def extend_one(a_list, element):
    """creating a new list is semantically the most direct
    way to create an iterable to give to extend"""
    a_list.extend([element])

import timeit

И мы видим, что выход из нашего пути создания итерируемого простого использования расширения - это (незначительная) трата времени:

>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295

Из этого мы узнаем, что ничего не получится от использования extend, когда у нас есть только одинэлемент для добавления.

Кроме того, эти сроки не так важны. Я просто показываю им, чтобы подчеркнуть, что в Python делать семантически правильную вещь - это делать RightWay ™).

Вполне возможно, что вы можете протестировать время двух сопоставимых операций и получить неоднозначный или обратный результат. Просто сосредоточьтесь на том, чтобы делать семантически правильную вещь.

Заключение

Мы видим, что extend семантически понятнее, и что он может работать намного быстрее, чем append, когда вы собираетесь добавить каждый элемент в итерируемый список. 

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

347
Aaron Hall

append добавляет один элемент. extend добавляет список элементов.

Обратите внимание, что если вы передаете список для добавления, он все равно добавляет один элемент:

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
106
Greg Hewgill

Следующие два фрагмента семантически эквивалентны:

for item in iterator:
    a_list.append(item)

а также

a_list.extend(iterator)

Последнее может быть быстрее, поскольку цикл реализован на C.

51
Erik

Метод append () добавляет один элемент в конец списка.

x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']

Метод extend () принимает один аргумент - список и добавляет каждый элемент аргумента в исходный список. (Списки реализованы в виде классов. «Создание» списка действительно создает экземпляр класса. Таким образом, в списке есть методы, которые работают с ним.)

x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

СПогружение в Python.

36
CodyChan

Вы можете использовать «+» для возврата расширения, вместо расширения на месте.

l1=range(10)

l1+[11]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]

l2=range(10,1,-1)

l1+l2

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]

Аналогично += для поведения на месте, но с небольшими отличиями от append & extend. Одно из самых больших отличий += от append и extend заключается в том, когда он используется в областях функций, см. это сообщение в блоге .

35
denfromufa

Добавить против Расширить

 enter image description here

С помощью append вы можете добавить один элемент, который расширит список:

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

Если вы хотите расширить более одного элемента, вам следует использовать extension, потому что вы можете добавить только один элемент или один список элементов:

>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]

Так что вы получите вложенный список

Вместо этого вы можете расширить один элемент, как это

>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]

Или, в отличие от append, расширяйте больше элементов за один раз, не вкладывая список в исходный (это является причиной расширения имени)

>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]

Добавление одного элемента с обоими методами

 enter image description here

добавить 1 элемент 

>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]

расширить один элемент 

>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3,4]

Добавление большего количества элементов ... с разными результатами 

Если вы используете append для более чем одного элемента, вы должны передать список элементов в качестве аргументов, и вы получите список NESTED!

>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]

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

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z
[1,2,3,4]

Таким образом, с большим количеством элементов вы будете использовать extended, чтобы получить список с большим количеством элементов. Вы будете использовать append, чтобы добавлять не больше элементов в список, а один элемент, который является вложенным списком, как вы можете ясно видеть в выводе кода.

 enter image description here

 enter image description here

29
Giovanni Gianni

append(object) - Обновляет список, добавляя объект в список.

x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
print(x)
--> [20, [21, 22, 23]]

extend(list) - по существу объединяет два списка.

x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
print(x)
[20, 21, 22, 23]
20
Chaitanya

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

От

list2d = [[1,2,3],[4,5,6], [7], [8,9]]

ты хочешь

>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Вы можете использовать itertools.chain.from_iterable() для этого. Вывод этого метода является итератором. Его реализация эквивалентна

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Возвращаясь к нашему примеру, мы можем сделать

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

и получить список разыскиваемых.

Вот как можно эквивалентно использовать extend() с аргументом итератора:

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
19
octoback

Это эквивалент append и extend с использованием оператора +:

>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> x = x + [4,5,6] # Extend
>>> x
[1, 2, 3, 4, 5, 6]
>>> x = x + [[7,8]] # Append
>>> x
[1, 2, 3, 4, 5, 6, [7, 8]]
17
skdev75

append () : в основном используется в Python для добавления одного элемента.

Пример 1:

>> a = [1, 2, 3, 4]
>> a.append(5)
>> print(a)
>> a = [1, 2, 3, 4, 5]

Пример 2:

>> a = [1, 2, 3, 4]
>> a.append([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, [5, 6]]

extend () : где extension () используется для объединения двух списков или вставки нескольких элементов в один список.

Пример 1:

>> a = [1, 2, 3, 4]
>> b = [5, 6, 7, 8]
>> a.extend(b)
>> print(a)
>> a = [1, 2, 3, 4, 5, 6, 7, 8]

Пример 2:

>> a = [1, 2, 3, 4]
>> a.extend([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, 5, 6]
15
The Gr8 Adakron

Интересный момент, который был намекнут, но не объяснен, состоит в том, что расширение быстрее, чем добавление. Любой цикл, который имеет добавление внутри, должен рассматриваться как замененный list.extend (processing_elements).

Имейте в виду, что добавление новых элементов может привести к перераспределению всего списка в лучшее место в памяти. Если это делается несколько раз, потому что мы добавляем 1 элемент за раз, общая производительность страдает. В этом смысле list.extend аналогичен "" .join (stringlist).

12
bconstanzo

Добавить добавляет все данные сразу. Все данные будут добавлены во вновь созданный индекс. С другой стороны, extend, как следует из названия, расширяет текущий массив. 

Например

list1 = [123, 456, 678]
list2 = [111, 222]

С append мы получаем:

result = [123, 456, 678, [111, 222]]

Пока на extend мы получаем:

result = [123, 456, 678, 111, 222]
11
Shiv

Словарь английского языка определяет слова append и extend как:

добавить : добавить (что-то) в конец письменного документа. 
расширить : сделать больше. Увеличить или расширить


С этим знанием теперь давайте разберемся

1) Разница между append и extend

append:

  • Добавляет любой объект Python как есть в конец списка (то есть как Последний элемент в списке).
  • Результирующий список может быть вложенным и содержать гетерогенные элементы (то есть список, строка, кортеж, словарь, набор и т.д.)

extend:

  • Принимает любой итерируемый в качестве аргумента и делает список больше .
  • Результирующий список всегда является одномерным списком (то есть без вложенности), и он может содержать в себе неоднородные элементы (например, символы, целые числа, число с плавающей точкой) в результате применения list(iterable).

2) Сходство между append и extend

  • Оба принимают ровно один аргумент.
  • Оба изменяют список на месте .
  • В результате оба возвращают None.

Пример

lis = [1, 2, 3]

# 'extend' is equivalent to this
lis = lis + list(iterable)

# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object
lis.append(object)
5
kmario23

Метод "append" добавляет свой параметр как единственный элемент в список, в то время как "extension" получает список и добавляет его содержимое.

Например,

расширить

    letters = ['a', 'b']
    letters.extend(['c', 'd'])
    print(letters) # ['a', 'b', 'c', 'd']

добавить

    letters.append(['e', 'f'])
    print(letters) # ['a', 'b', 'c', 'd', ['e', 'f']]
4
Viraj Kaulkar

Добавить словарь к другому:

>>>def foo():
    dic = {1:'a', 2:'b', 3:'c', 4:'a'}
    newdic = {5:'v', 1:'aa'}
    for i in dic.keys():
        if not newdic.has_key(dic[i]):
            newdic[i] = dic[i]
    print "Appended one:", newdic

>>>foo()
Appended one: {1: 'a', 2: 'b', 3: 'c', 4: 'a', 5: 'v'}
4
Sanyal

Я надеюсь, что смогу сделать полезное дополнение к этому вопросу. Если в вашем списке хранится объект определенного типа, например Info, вот ситуация, когда метод extend не подходит: в цикле for и при каждом создании объекта Info и использовании extend для сохранения его в вашем списке произойдет сбой. Исключение как ниже:

TypeError: объект «Info» не повторяется

Но если вы используете метод append, результат будет в порядке. Потому что каждый раз, используя метод extend, он всегда будет обрабатывать его как список или любой другой тип коллекции, повторять его и размещать после предыдущего списка. Конкретный объект не может быть повторен, очевидно.

4
Crabime

Различать их интуитивно

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

Это как l1 воспроизводить тело внутри ее тела (вложенное).

# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']

Это похоже на то, что два раздельных человека женятся и создают дружную семью.

Кроме того, я делаю исчерпывающую таблицу всех методов списка для вашей справки.

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},
                }
2
JawSaw

добавить: добавляет «список» или «отдельный элемент» в конце существующего списка

a = [1,2]
b = [3]
a.append(b)
print(a)     # prints [1,2,[3]]
a.append(4)
print(a)     # prints [1,2,[3],4] 

расширение: добавляет «элементы списка» (переданные в качестве аргумента) в существующий список.

a = [1,2]
b = [3]
a.extend(b)
print(a)     # prints [1,2,3]
a.extend(4)  # typeError as int cannot be used as argument with extend
0
Abhinav1602

Добавить: Добавляет свой аргумент как отдельный элемент в конец списка.

например:-

my_list = ['stack', 'over'] 
my_list.append('flow') 
print my_list 

Результат:

['stack', 'over', 'flow']

Примечание. - Если вы добавите другой список в список, первый список будет одним объектом в конце списка.

например:-

my_list = ['stack', 'over', 'flow'] 
another_list = [1,2,3,4] ,
my_list.append(another_list) 
print my_list 

Результат:-

['stack', 'over', 'over', [1,2,3,4]]

extend(): - перебирает свой аргумент и добавляет каждый элемент в список и расширяет список. Длина списка увеличивается на количество элементов в его аргументе.

например:-

my_list = ['stack', 'over'] 
another_list = [6, 0, 4, 1] 
my_list.extend(another_list) 
print my_list 

Результат:

['stack', 'over', 6, 0, 4, 1]

Примечание. - Строка является итеративной, поэтому, если вы расширяете список строкой, вы добавляете каждый символ по мере итерации по строке.

например:-

my_list = ['stack', 'overflow', 6, 0, 4, 1] 
my_list.extend('hello') 
print my_list 
0
Karthik Sai

Это помогло мне понять, что действительно происходит, когда вы используете append и extend:

a = [[1,2,3],[4,5,6]]
print(a)
>>> [[1, 2, 3], [4, 5, 6]]
a.append([6,7,8])
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8]]
a.extend([0,1,2])
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2]
a=a+[8,9,10]
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2, 8, 9, 10]
0
missnomer

append () метод добавит передаваемый ему аргумент как отдельный элемент.

extend () будет перебирать передаваемые аргументы и расширять список, передавая итерированные каждый элемент, в основном он будет добавлять несколько элементов, не добавляя целый как один.

list1 = [1,2,3,4,5]
list2 = [6,7,8]

list1.append(list2)
print(list1)
#[1,2,3,4,5,[6,7,8]]

list1.extend(list2)
print(list1)
#[1,2,3,4,5,6,7,8]
0
PythonLover

extend (L) расширяет список, добавляя все элементы в данный список L.

>>> a
[1, 2, 3]
a.extend([4)  #is eqivalent of a[len(a):] = [4]
>>>a
[1, 2, 3, 4]
a =[1,2,3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
0
tessie