Разница между методами добавления и расширения списка в Python

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

2768
задан 31 окт. '08 в 8:55
источник поделиться
25 ответов

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]

4195
ответ дан 31 окт. '08 в 9:02
источник

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.

535
ответ дан 31 окт. '08 в 8:57
источник

В чем разница между приложением списка и расширением?

  • 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 изменяет список на месте (это оператор на месте, а списки - изменяемые объекты, как мы видели), поэтому он не создает новый список. Он также работает так же, как и расширение, поскольку второй итерабельный может быть любым итерабельным.

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

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

Append имеет постоянную временную сложность, O (1).

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

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

Представление

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

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 выполнение семантически правильной вещи делает вещи Right Way ™.

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

Вывод

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

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

285
ответ дан 24 янв. '15 в 1:44
источник

И в этом контексте также хорошо помнить, что строки также являются итерабельными.

>>> a = [1, 2]
>>> a
[1, 2]
>>> a.extend('hey')
>>> a
[1, 2, 'h', 'e', 'y']
250
ответ дан 04 нояб. '08 в 18:19
источник

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

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

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
97
ответ дан 31 окт. '08 в 8:57
источник

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

for item in iterator:
    a_list.append(item)

и

a_list.extend(iterator)

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

46
ответ дан 21 авг. '12 в 0:11
источник

Метод 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.

32
ответ дан 31 окт. '13 в 16:12
источник

Вы можете использовать "+" для возврата, вместо того, чтобы расширяться на месте.

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 - это когда оно используется в области функций, см. этот пост в блоге.

31
ответ дан 26 авг. '13 в 14:21
источник

Добавить и продлить

enter image description here

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

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

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

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

Чтобы вы получили вложенный список

Вместо этого вы можете расширить один элемент следующим образом:

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

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

>>> 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]

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

enter image description here

enter image description here

21
ответ дан 18 окт. '17 в 10:33
источник

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 length is 4
print(x)
[20, 21, 22, 23]
18
ответ дан 12 мая '13 в 22:51
источник

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]
17
ответ дан 12 мая '13 в 21:21
источник

Это эквивалент 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]]
15
ответ дан 08 июля '14 в 15:42
источник

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(): где extend() используется для объединения двух списков или вставки нескольких элементов в один список.

Пример 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]
12
ответ дан 13 июня '16 в 13:17
источник

Интересный момент, который намекнул, но не объяснил, заключается в том, что расширение выполняется быстрее, чем append. Для любого цикла, который добавляет внутри, следует считать замененным list.extend(обработанные_элементы).

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

10
ответ дан 05 авг. '14 в 19:58
источник

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

Например

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

С append получаем:

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

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

result = [123, 456, 678, 111, 222]
10
ответ дан 16 окт. '14 в 9:49
источник

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

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


Имея это знание, теперь давайте понять

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

append:

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

extend:

  • Принимает любое значение iterable в качестве аргумента и делает список более крупным.
  • Результирующий список всегда представляет собой один размерный список (т.е. Не вложенность), и он может содержать в нем гетерогенные элементы (например, символы, целые числа, float) в результате применения 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
ответ дан 30 дек. '17 в 21:38
источник
list1 = [1,2,3,4,5]

list2 = ["a","b","c","d","e"]

Append:

print list.append(list2)

: [1,2,3,4,5, [ "a", "b", "c", "d", "e" ]]

extend:

print list1.extend(list2)

: [1,2,3,4,5, "a", "b", "c", "d", "e" ]

4
ответ дан 18 сент. '14 в 22:19
источник

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

TypeError: объект "Info" не является итерируемым

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

4
ответ дан 11 февр. '17 в 4:59
источник

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

>>>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
ответ дан 17 авг. '15 в 15:02
источник

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

Например,

простираться

    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']]
3
ответ дан 31 авг. '16 в 20:55
источник

Чтобы различать их интуитивно

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
ответ дан 04 дек. '17 в 13:17
источник

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

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]
1
ответ дан 20 июля '18 в 20:04
источник

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

 >>> a
[1, 2, 3]
a.extend([4]) # it is equivalent to a[len(a):] = [4] or a.append(4)
 >>>a
[1, 2, 3, 4]
 >>> a = [1
 >>> a
[1, 2, 3]
 >>> a[len(a)] = [4]
 >>> a
[1, 2, 3, 4]
0
ответ дан 31 авг. '16 в 21:14
источник

Добавление и расширение являются одним из механизмов расширяемости в python.

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

my_list = [1,2,3,4]

Чтобы добавить новый элемент в список, мы можем использовать метод append следующим образом.

my_list.append(5)

Расположение по умолчанию, в которое будет добавлен новый элемент, всегда находится в позиции (длина + 1).

Вставка: метод вставки использовался для преодоления ограничений добавления. С вставкой мы можем явно определить точное положение, в которое мы хотим вставить новый элемент.

Дескриптор метода вставки (индекс, объект). Он принимает два аргумента, сначала являющийся индексом, который мы хотим вставить в наш элемент, и вторым элементом.

Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']

Расширение: это очень полезно, когда мы хотим объединить два или более списков в один список. Без расширения, если мы хотим присоединиться к двум спискам, результирующий объект будет содержать список списков.

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

Если мы попытаемся получить доступ к элементу в pos 2, мы получим список ([3]) вместо элемента. Чтобы присоединиться к двум спискам, нам нужно будет использовать append.

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

Чтобы присоединиться к нескольким спискам

a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]
0
ответ дан 17 июля '18 в 10:19
источник

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

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

Это может быть немного запутанным для объектов str.

  1. Если вы передадите строку в качестве аргумента: append добавит в конце один строковый элемент, но extend добавит столько элементов "single" 'str', сколько длины этой строки.
  2. Если вы передадите список строк в качестве аргумента: append все равно добавит в конце один элемент "списка", а extend добавит столько элементов списка, сколько длина переданного списка.
def append_o(a_list, element):
    a_list.append(element)
    print('append:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()

def extend_o(a_list, element):
    a_list.extend(element)
    print('extend:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()
append_o(['ab'],'cd')

extend_o(['ab'],'cd')
append_o(['ab'],['cd', 'ef'])
extend_o(['ab'],['cd', 'ef'])
append_o(['ab'],['cd'])
extend_o(['ab'],['cd'])

производит:

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,
-1
ответ дан 31 марта '18 в 21:46
источник

Другие вопросы по меткам или Задайте вопрос