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

avatar
Claudiu
31 октября 2008 в 05:55
3089391
20
3113

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

Источник

Ответы (20)

avatar
kender
31 октября 2008 в 06:02
5540

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]

Rohan
29 мая 2017 в 22:10
145

В чем разница между extend и простым использованием оператора сложения - в приведенном выше примере x = x + [4, 5]?

Aaron Hall♦
17 июля 2017 в 17:14
352

На самом деле существует большая разница - x + [4, 5] дает вам новый список, назначенный x - x.extend() изменяет исходный список. Я уточняю в своем ответе ниже.

Astitva Srivastava
13 декабря 2018 в 14:54
4

@AaronHall @Rohan, но он такой же, как x += [4,5].

Anthony
15 марта 2019 в 14:53
2

Ключевое слово при использовании append - Объект . Если вы попытаетесь использовать extend и передадите словарь , он добавит ключ , а не весь хеш в конец массива.

mcagriardic
22 июля 2020 в 16:20
0

@Rohan, временная сложность x = x + [4, 5] будет O (len (x) + len ([4,5])), где as extend имеет временную сложность O (len ([4, 5 ]))

avatar
vivek
17 июля 2018 в 07:19
0

Добавление и расширение - это один из механизмов расширяемости в Python.

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

my_list = [1,2,3,4]

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

my_list.append(5)

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

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

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

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

Если мы попытаемся получить доступ к элементу на позиции 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]
avatar
ilias iliadis
31 марта 2018 в 18:46
0

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

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

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

  1. Если вы передадите строку в качестве аргумента: append добавит в конец одиночный строковый элемент, но extend добавит столько "одиночных" элементов '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,
avatar
kmario23
30 декабря 2017 в 18:38
9

Английский словарь определяет слова 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
list.append(object)
avatar
AbstProcDo
4 декабря 2017 в 10:17
4

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

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'},
                }
avatar
Giovanni G. PY
18 октября 2017 в 07:33
83

Добавление и расширение

enter image description here

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

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

Как add, так и extension могут добавить один элемент в конец списка, хотя добавление проще.

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

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

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

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

Добавление дополнительных элементов ... с разными результатами

Если вы используете добавление более чем для одного элемента, вы должны передать список элементов в качестве аргументов, и вы получите ВЛОЖЕННЫЙ список!

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

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

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

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

enter image description here

enter image description here

avatar
Crabime
11 февраля 2017 в 01:59
5

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

TypeError: объект "Информация" не повторяется

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

avatar
tessie
31 августа 2016 в 18:14
2

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]
avatar
The Gr8 Adakron
13 июня 2016 в 10:17
16

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]
avatar
Aaron Hall
23 января 2015 в 22:44
571

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

  • 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. Они семантически похожи на extension.

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

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

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

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

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

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

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

По поводу «амортизированного» - из источника реализации объекта списка:

    /* This over-allocates proportional to the list size, making room
     * for additional growth.  The over-allocation is mild, but is
     * enough to give linear-time amortized behavior over a long
     * sequence of appends() in the presence of a poorly-performing
     * system realloc().

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

Производительность

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

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

И мы видим, что изо всех сил создавать итерацию только для использования extension - это (незначительная) трата времени:

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

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

Кроме того, эти тайминги не так важны. Я просто показываю им, что в Python выполнение семантически правильных действий означает выполнение действий Правильно Way ™.

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

Заключение

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

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

ilias iliadis
31 марта 2018 в 18:06
1

@Aaron Hall Один небольшой комментарий по алгоритму определения времени. «extend_one» может возвращать «немного неправильное» время, потому что также задействовано создание списка. Вероятно, лучше создать элементы как переменные (ex1 = 0 и ex2 = [0]) и передать эти переменные, если вы хотите быть более строгими.

Jean-Francois T.
23 апреля 2018 в 03:54
20

Действительно прекрасный ответ. Как насчет производительности l1 += l2 против l1.extend(l2)?

ShadowRanger
17 августа 2018 в 19:10
9

@ Jean-FrancoisT .: l1 += l2 и l1.extend(l2) в конечном итоге выполняют один и тот же код (функция list_extend в listobject.c). Единственные различия: 1. += переназначает l1 (самому себе для list s, но переназначение поддерживает неизменяемые типы, которые не являются одним и тем же объектом после), что делает его незаконным, если l1 на самом деле является атрибут неизменяемого объекта; например, t = ([],), t[0] += lst завершится ошибкой, а t[0].extend(lst) будет работать. 2. l1 += l2 использует выделенные байт-коды, а l1.extend(l2) использует диспетчеризацию обобщенного метода; это делает += быстрее, чем extend.

ShadowRanger
17 августа 2018 в 19:20
3

Тот факт, что += должен переназначить l1, означает, что в некоторых случаях более медленная отправка extend частично или полностью компенсируется отсутствием повторного присвоения левой стороне. Например, если list является атрибутом объекта, self.l1 += l2 и self.l1.extend(l2) имеют одинаковую производительность в моей установке Python 3.6 просто потому, что реальная операция больше похожа на self.l1 = self.l1.__iadd__(l2), что означает, что она должна выполняться умеренно дорого. STORE_ATTR, что self.l1.extend(l2) не обязательно.

ShadowRanger
17 августа 2018 в 19:32
2

Простое сравнение в локальных тестах: для локальной переменной (так что += просто использует STORE_FAST, что очень дешево), где добавляемым значением является существующий list с одним элементом в нем, с повторением операции 1000 раз += потребовалось в среднем около 33 нс, тогда как extend заняло 78 нс, разница в 45 нс. Если l1 является глобальным (требуется более дорогой STORE_GLOBAL), разница уменьшается до 17 нс. Если l1 на самом деле local.l1 (требуется еще более дорогой STORE_ATTR), значимой разницы между += и extend нет (тайминги примерно идентичны; extend иногда выигрывает).

tparker
22 декабря 2018 в 22:38
0

Не могли бы вы пояснить разницу в поведении между my_list = my_list + another_list и my_list += another_list? В чем практическая разница между изменением существующего списка и созданием нового списка с идентичным содержимым и повторной привязкой имени?

Tony Suffolk 66
26 июня 2020 в 03:29
0

@tparker - если у вас есть другое имя (foo), привязанное к my_list (скажем, вы находитесь внутри функции), то при использовании + = не выполняется повторная привязка my_list к новому объекту, и поэтому foo и my_list остаются одним и тем же списком. выполнение явного + и присваивания (то есть без использования + =) означает, что RHS является новым списком, а имя my_list является rebound, что означает, что my_list и foo больше не привязаны к одному и тому же объекту.

Daniel
13 апреля 2021 в 17:33
0

@Aaron Hall, вы сказали, что append для array a занимает время O (1), но как насчет создания нового массива размером sizeof(a)+1 с желаемыми значениями? (первые элементы как в и последний новый элемент). Я действительно спрашиваю, потому что не знаю, как это работает в Python

Aaron Hall♦
14 апреля 2021 в 00:14
1

@Daniel Я добавил некоторую информацию в этот раздел, которая должна привести вас к более актуальной информации, если вам интересно.

avatar
Shiv
16 октября 2014 в 06:49
13

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

Например,

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

С append получаем:

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

На extend мы получаем:

result = [123, 456, 678, 111, 222]
avatar
bconstanzo
5 августа 2014 в 16:58
13

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

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

avatar
skdev75
8 июля 2014 в 12:42
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]]
avatar
CodyChan
31 октября 2013 в 13:12
47

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

aneroid
25 сентября 2014 в 09:28
0

Вы не можете расширить только с помощью 6, поскольку он не повторяется. И второй вывод в вашем примере неверен. 'abc' добавляется как отдельный элемент, поскольку вы передали его в extend как список с одним элементом ['abc']: [1, 2, 3, 4, 5, 'abc']. Чтобы ваш пример вывода был правильным, измените строку abc на: x.extend('abc'). И удалите x.extend(6) или измените его на x.extend([6]).

avatar
denfromufa
26 августа 2013 в 11:21
39

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

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

franklin
19 июля 2015 в 03:59
0

Влияет ли использование символа «+» для возврата на временную сложность?

denfromufa
21 июля 2015 в 14:50
5

@franklin, подробности см. в этом ответе: coderhelper.com/a/28119966/2230844

pppery
13 июля 2018 в 03:20
2

Я не понимаю, как это отвечает на вопрос

avatar
Chaitanya
12 мая 2013 в 19:51
23

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]
avatar
kiriloff
12 мая 2013 в 18:21
21

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]
pppery
13 июля 2018 в 03:20
2

Этот ответ не контрастирует с расширением с добавлением и, следовательно, не отвечает на вопрос

avatar
Erik
20 августа 2012 в 21:11
66

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

for item in iterator:
    a_list.append(item)

и

a_list.extend(iterator)

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

Alex L
27 декабря 2012 в 08:29
21

На моей машине расширение происходит примерно в 4 раза быстрее, чем добавление в цикл (16 мкс против 4 мкс для 100 циклов нулей)

Mad Physicist
23 октября 2015 в 13:43
6

extend(), вероятно, выделяется заранее, а append(), скорее всего, нет.

Soren Bjornstad
28 июля 2019 в 03:43
0

@MadPhysicist: Для полноты картины могут быть моменты, когда extend() не может выполнить предварительное выделение разумно, поскольку некоторые итерации не реализуют __len__(), но, как и вы, я был бы удивлен, если это не так ' не пытаюсь. Некоторый прирост производительности также достигается за счет выполнения итерационной части на чистом C вместо Python, как указано в ответе Аарона.

avatar
Harley Holcombe
31 октября 2008 в 05:57
688

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', ['new', 2]]

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

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2], 'two', 'elements']
avatar
Greg Hewgill
31 октября 2008 в 05:57
128

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

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

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