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

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

+3119
31 окт. '08 в 5:55
источник поделиться
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]

+4763
31 окт. '08 в 6:02
источник

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.

+590
31 окт. '08 в 5:57
источник

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


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

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

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

+406
23 янв. '15 в 22:44
источник

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

>>> a = [1, 2]
>>> a
[1, 2]
>>> a.extend('hey')
>>> a
[1, 2, 'h', 'e', 'y']
+250
04 нояб. '08 в 15:19
источник

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

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

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
+114
31 окт. '08 в 5:57
источник

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

for item in iterator:
    a_list.append(item)

и

a_list.extend(iterator)

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

+54
20 авг. '12 в 21:11
источник

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

+38
31 окт. '13 в 13:12
источник

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

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
26 авг. '13 в 11:21
источник

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

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]

Или, иначе, чем добавление, продлить больше элементов за один раз, не вложив список в исходный (что причина расширения имени)

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

Таким образом, с большим количеством элементов вы будете использовать расширение, чтобы получить список с большим количеством элементов. Вы будете использовать append, чтобы добавить не больше элементов в список, а один элемент, который является вложенным списком, как вы можете четко видеть на выходе кода.

enter image description here

enter image description here

+34
18 окт. '17 в 7:33
источник

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
12 мая '13 в 19:51
источник

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
12 мая '13 в 18: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]]
+18
08 июл. '14 в 12:42
источник

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
13 июн. '16 в 10:17
источник

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

Например

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

С append получаем:

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

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

result = [123, 456, 678, 111, 222]
+12
16 окт. '14 в 6:49
источник

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

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

+12
05 авг. '14 в 16:58
источник

Английский словарь определяет слова 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)
+5
30 дек. '17 в 18:38
источник

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

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

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

+4
11 февр. '17 в 1:59
источник
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
18 сент. '14 в 19:19
источник

Метод "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
31 авг. '16 в 17:55
источник

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

>>>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
17 авг. '15 в 12:02
источник

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

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'},
                }
+2
04 дек. '17 в 10:17
источник

Метод 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
21 окт. '18 в 20:34
источник

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]
0
31 авг. '16 в 18:14
источник

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

например:-

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
25 янв. '19 в 10:58
источник

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
17 мар. '19 в 13:11
источник

Это помогло мне понять, что действительно происходит, когда вы используете 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
20 июл. '18 в 17:04
источник

с помощью 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
28 янв. '19 в 20:52
источник

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
31 мар. '18 в 18:46
источник

Добавление и расширение являются одним из механизмов расширяемости в 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]
-2
17 июл. '18 в 7:19
источник

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