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

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

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

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

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]

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

for item in iterator:
    a_list.append(item)

и

a_list.extend(iterator)

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

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

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

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() принимает один аргумент, список, и добавляет каждый из элементов аргумента в исходный список. (Списки реализованы как классы. «Создание» списка на самом деле создает экземпляр класса. Таким образом, список имеет методы, которые работают с ним.)

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

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

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

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

Например

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

С append получаем:

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

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

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

What is the difference between the list methods append and extend?

• 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 усложняются, делая его эквивалентным расширению, а поскольку итерация расширения реализована на C, это всегда будет быстрее, если вы намереваетесь добавлять последовательные элементы из итерируемого объекта в список.

Представление

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

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

Обращение к комментарию по расписанию

Комментатор сказал:

Perfect answer, I just miss the timing of comparing adding only one element

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

добавить (): в основном используется в Python для добавления одного элемента.

Example 1:

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

Example 2:

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

продлевать(): где extend () используется для объединения двух списков или вставки нескольких элементов в один список.

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

Example 2:

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

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]

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

TypeError: 'Info' object is not iterable

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

Добавить против расширения

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

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

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

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

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

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

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

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,

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

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

my_list = [1,2,3,4]

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

my_list.append(5)

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

Insert: метод вставки использовался для преодоления ограничений добавления. С помощью 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]