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

2322
голосов

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

задан Claudiu 31 окт. '08 в 8:55
источник

22 ответов

3543
голосов

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]

ответ дан kender 31 окт. '08 в 9:02
источник
471
голос

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.

ответ дан Harley Holcombe 31 окт. '08 в 8:57
источник
250
голосов

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

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

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

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

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

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

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

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

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

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

for item in iterator:
    a_list.append(item)

и

a_list.extend(iterator)

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

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

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

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

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

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

ответ дан CodyChan 31 окт. '13 в 16:12
источник
14
голосов

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]
ответ дан Chaitanya 12 мая '13 в 22:51
источник
13
голосов

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

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

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]
ответ дан The Gr8 Adakron 13 июня '16 в 13:17
источник
8
голосов

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

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

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

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

Например

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

С append получаем:

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

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

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

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

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

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

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

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

ответ дан Jeeg_robot 18 окт. '17 в 10:33
источник
5
голосов
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'}
ответ дан Vicky 17 авг. '15 в 15:02
источник
4
голосов
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" ]

ответ дан Neeraj Sharma 18 сент. '14 в 22:19
источник
3
голосов

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

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

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

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

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

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,2,3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
ответ дан tes 31 авг. '16 в 21:14
источник
1
голос

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

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'},
                }
ответ дан Yumi Tada 04 дек. '17 в 13:17
источник
0
голосов
Английский словарь

определяет слова 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)
ответ дан kmario23 30 дек. '17 в 21:38
источник

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