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

https://stackoverflow.com/questions/252703

05-07-2019
|

Вопрос

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

Решение

append : Добавляет объект в конец.

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

дает вам: [1, 2, 3, [4, 5]]

<Ч>

extension : Расширяет список, добавляя элементы из итерируемого.

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

Из погрузиться в Python .

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

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

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

Таким образом, при использовании 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.Они семантически похожи на extend.

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

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

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

Временная сложность

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

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

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

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

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

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

Обращение к комментарию о таймингах

Один из комментаторов сказал:

Идеальный ответ, я просто упускаю момент сравнения, добавляя только один элемент

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

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

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

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

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

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

Заключение

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

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

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

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

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

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

for item in iterator:
    a_list.append(item)

a_list.extend(iterator)

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

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

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

Метод extend () принимает один аргумент - список и добавляет каждый элемент аргумента в исходный список. (Списки реализованы в виде классов. & # 8220; Создание & # 8221; список действительно создает экземпляр класса. Таким образом, в списке есть методы, которые работают с ним.)

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

Из Dive Into Python .

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

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 & amp; <Код> продлить . Одно из самых больших отличий + = от append и extension заключается в том, когда оно используется в областях функций, см. это сообщение в блоге .

Добавить против Расширить

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

Итак, с большим количеством элементов вы будете использовать extends, чтобы получить список с большим количеством элементов. Вы будете использовать 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() может использоваться с аргументом итератора.Вот один из примеров.Вы хотите составить список из списка списков таким образом:

От

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]

Это эквивалентно append и extension с использованием оператора + :

>>> 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 () : где 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]

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

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

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

Например

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

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

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

В то время как на extension мы получаем:

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

Словарь английского языка дает определение этим словам 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
lis.append(object)

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

TypeError: объект 'Info' не повторяется

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

Различать их интуитивно

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

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]

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

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

Это может немного сбить с толку str Объекты.

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

Append и extension являются одним из механизмов расширяемости в Python.

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

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

Если мы попытаемся получить доступ к элементу в позиции 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]

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow