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

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

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

22 ответов

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]

3758
ответ дан kender 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.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.

492
ответ дан Harley Holcombe 31 окт. '08 в 8:57
источник поделиться

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

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

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

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

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

Заключение

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

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

208
ответ дан Aaron Hall 24 янв. '15 в 1:44
источник поделиться

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

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

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

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

for item in iterator:
    a_list.append(item)

и

a_list.extend(iterator)

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

37
ответ дан Erik 21 авг. '12 в 0:11
источник поделиться

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

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

29
ответ дан denfromufa 26 авг. '13 в 14:21
источник поделиться

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

27
ответ дан CodyChan 31 окт. '13 в 16:12
источник поделиться

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) - по существу объединяет 2 списка.

x = [20]
#the parameter passed to extend(list) method is treated as a list.
#eventually it is 2 list being concatenated. 
x.extend([21,22,23])
#here the resultant list length is 4
print x 
[20,21,22,23]
15
ответ дан Chaitanya 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]
14
ответ дан octoback 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]]
11
ответ дан skdev75 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]
10
ответ дан The Gr8 Adakron 13 июня '16 в 13:17
источник поделиться

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

Например

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

С append получаем:

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

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

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

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

введите описание изображения здесь

С помощью 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]

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

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

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

введите описание изображения здесь

добавить 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, чтобы добавить не больше элементов в список, а один элемент, который является вложенным списком, как вы можете четко видеть на выходе кода.

введите описание изображения здесь

введите описание изображения здесь

9
ответ дан Giovanni Gianni 18 окт. '17 в 10:33
источник поделиться

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

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

8
ответ дан bconstanzo 05 авг. '14 в 19:58
источник поделиться
Append a dictionary to another one:
>>>def asd():
    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

>>>asd()
appended one: {1: 'a', 2: 'b', 3: 'c', 4: 'a', 5: 'v'}
5
ответ дан Sanyal 17 авг. '15 в 15:02
источник поделиться
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
ответ дан Neeraj Sharma 18 сент. '14 в 22:19
источник поделиться

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

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

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

3
ответ дан Crabime 11 февр. '17 в 4:59
источник поделиться

Метод "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
ответ дан Viraj Kaulkar 31 авг. '16 в 20:55
источник поделиться
Английский словарь

определяет слова append и extend как:

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


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

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

append:

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

extend:

  • принимает любой итеративный аргумент и делает список более крупным
  • результирующий список всегда является одномерным списком (т.е. нет вложенности), и он может содержать в нем гетерогенные элементы (например, символы, целые числа, 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)
2
ответ дан kmario23 30 дек. '17 в 21:38
источник поделиться

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]
1
ответ дан tes 31 авг. '16 в 21:14
источник поделиться

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

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
In [16]: l1.append(l2)
In [17]: l1
Out[17]: ['a', 'b', 'c', ['d', 'e', 'f']]

Это, как l1, воспроизводит тело внутри ее тела.

#reset l1 = ['a', 'b', 'c']
In [36]: l1.extend(l2)
In [37]: l1
Out[37]: ['a', 'b', 'c', 'd', 'e', 'f']

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

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

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Subtract': {'pop', 'remove'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Entire': {'clear', 'copy'},
                }
1
ответ дан Yumi Tada 04 дек. '17 в 13:17
источник поделиться

Другие вопросы по меткам