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

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

23 Solutions collect form web for “Разница между методами добавления и расширения списка в Python”

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]

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 .

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

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

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

Вывод

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

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

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

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

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

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

 for item in iterator: a_list.append(item) 

а также

 a_list.extend(iterator) 

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

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

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

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

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

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

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

От погружения в Python .

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

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

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

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

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

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

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

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

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] 

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

Из

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

вы хотите

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

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

 def from_iterable(iterables): # chain.from_iterable(['ABC', 'DEF']) --> ABCDEF 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() может использоваться с аргументом iteratorа:

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

Это эквивалент 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]] 

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] 

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

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

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

Например

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

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

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

В то время как дальше мы получаем:

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

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

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

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

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

 >>>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'} 

Английский словарь определяет слова 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) 

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

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

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

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

 # 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'}, } 

Это помогло мне понять, что на самом деле происходит, когда вы используете 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] 

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] 

Добавление и расширение являются одним из механизмов расширяемости в 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] 

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, 
Interesting Posts

«WAN: отключено» при подключении маршрутизатора к кабельному модему

Где Firefox хранит закладки?

Ctrl + Backspace вставляет небольшой ящик вместо стирания

Почему слово Microsoft Office продолжает спрашивать, хочу ли я заменить файл normal.dot? Могу ли я это исправить?

Свяжите расширение файла с приложением в Snow Leopard

Windows 7 / Outlook 2010 отключил элементы управления в окнах форм

Использование антистатического браслета для ног против ноутбука

Какими вещами я должен работать ежедневно, еженедельно, ежемесячно на своей машине с Windows?

Как получить bash для автоматического обновления кеша местоположений программ?

Что пробуждает мой компьютер?

Сделать перезагрузку экрана GNU

Конденсация в несколько страниц PDF на листе, через командную строку

Как скопировать свойства одного пользователя Google Chrome на другой в OSX

Документация по настройкам реестра Windows 7

Как узнать, какую версию Linux я запускаю?

Давайте будем гением компьютера.