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

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

+3119
источник поделиться
29 ответов

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]

+4937
источник

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']
+605
источник
другие ответы

Связанные вопросы


Похожие вопросы

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

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

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

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

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

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

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

Расширение имеет временную сложность, 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

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

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

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

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

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

Заключение

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

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

+435
источник

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

>>> a = [1, 2]
>>> a
[1, 2]
>>> a.extend('hey')
>>> a
[1, 2, 'h', 'e', 'y']
+250
источник

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

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

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
+115
источник

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

for item in iterator:
    a_list.append(item)

и

a_list.extend(iterator)

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

+54
источник

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

+39
источник

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

enter image description here

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

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

enter image description here

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

enter image description here

enter image description here

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

+36
источник

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 length is 4
print(x)
[20, 21, 22, 23]
+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]
+19
источник

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

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]
+15
источник

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

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

+12
источник

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

Например

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

С append получаем:

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

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

result = [123, 456, 678, 111, 222]
+12
источник

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

+4
источник

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

>>>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'}
+4
источник

Метод "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']]
+4
источник

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

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

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

+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'},
                }
+3
источник

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]
+1
источник

Это помогло мне понять, что действительно происходит, когда вы используете append и extend:

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]
0
источник

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

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

list1 = [1,2,3,4,5]
list2 = [6,7,8]

list1.append(list2)
print(list1)
#[1,2,3,4,5,[6,7,8]]

list1.extend(list2)
print(list1)
#[1,2,3,4,5,6,7,8]
0
источник

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

например:-

my_list = ['stack', 'over'] 
my_list.append('flow') 
print my_list 

Выход:

['stack', 'over', 'flow']

Примечание. - Если вы добавите другой список в список, первый список будет одним объектом в конце списка.

например:-

my_list = ['stack', 'over', 'flow'] 
another_list = [1,2,3,4] ,
my_list.append(another_list) 
print my_list 

Выход:-

['stack', 'over', 'over', [1,2,3,4]]

extend(): - перебирает свой аргумент и добавляет каждый элемент в список и расширяет список. Длина списка увеличивается на количество элементов в его аргументе.

например:-

my_list = ['stack', 'over'] 
another_list = [6, 0, 4, 1] 
my_list.extend(another_list) 
print my_list 

Выход:

['stack', 'over', 6, 0, 4, 1]

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

например:-

my_list = ['stack', 'overflow', 6, 0, 4, 1] 
my_list.extend('hello') 
print my_list 
0
источник

append: добавляет 'list' или 'single element' в конец существующего списка

a = [1,2]
b = [3]
a.append(b)
print(a)     # prints [1,2,[3]]
a.append(4)
print(a)     # prints [1,2,[3],4] 

extend: добавляет "элементы списка" (переданные в качестве аргумента) в существующий список.

a = [1,2]
b = [3]
a.extend(b)
print(a)     # prints [1,2,3]
a.extend(4)  # typeError as int cannot be used as argument with extend
0
источник

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,
-1
источник

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

с помощью extend (['object1', 'object2', 'object3']) вы расширяете список, чтобы в нем были все 3 объекта. с помощью append ('object') вы добавляете 1 объект в список. например, допустим, у вас есть L = [1,2,3,4]

L.extend([5,6]) даст вам: [1, 2, 3, 4, 5, 6].
L.append([5,6]) даст вам: [1, 2, 3, 4, [5, 6]].

-1
источник

Посмотрите другие вопросы по меткам или Задайте вопрос