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

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

вопрос задан 31.10.2008
Claudiu
122117 репутация

23 ответов


  • 4189 рейтинг

    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]

    ответ дан kender, с репутацией 56075, 31.10.2008
  • 535 рейтинг

    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', 2]]
    
    >>> li.insert(2, "new")
    >>> li
    ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']
    
    >>> li.extend(["two", "elements"])
    >>> li
    ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
     

    От погружения в Python .

    ответ дан Harley Holcombe, с репутацией 105065, 31.10.2008
  • 285 рейтинг

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

    • 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 on end of 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.

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

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

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

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

    Спектакль

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

     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 выполнение семантически правильной вещи делает вещи Right Way ™.

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

    Заключение

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

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

    ответ дан Aaron Hall, с репутацией 153756, 23.01.2015
  • 97 рейтинг

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

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

     >>> a = [1, 2, 3]
    >>> a.append([4, 5, 6])
    >>> a
    [1, 2, 3, [4, 5, 6]]
     
    ответ дан Greg Hewgill, с репутацией 645957, 31.10.2008
  • 46 рейтинг

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

     for item in iterator:
        a_list.append(item)
     

    а также

     a_list.extend(iterator)
     

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

    ответ дан Erik, с репутацией 1239, 20.08.2012
  • 32 рейтинг

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

    ответ дан CodyChan, с репутацией 1059, 31.10.2013
  • 31 рейтинг

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

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

    ответ дан denfromufa, с репутацией 3159, 26.08.2013
  • 21 рейтинг

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

    введите описание изображения здесь

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

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

    введите описание изображения здесь

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

    введите описание изображения здесь

    введите описание изображения здесь

    ответ дан Giovanni Gianni, с репутацией 5350, 18.10.2017
  • 18 рейтинг

    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]
     
    ответ дан Chaitanya, с репутацией 984, 12.05.2013
  • 17 рейтинг

    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]
     
    ответ дан octoback, с репутацией 13234, 12.05.2013
  • 15 рейтинг

    Это эквивалент 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]]
     
    ответ дан skdev75, с репутацией 349, 8.07.2014
  • 12 рейтинг

    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]
     
    ответ дан The Gr8 Adakron, с репутацией 518, 13.06.2016
  • 10 рейтинг

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

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

    ответ дан bconstanzo, с репутацией 330, 5.08.2014
  • 10 рейтинг

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

    Например

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

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

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

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

     result = [123, 456, 678, 111, 222]
     
    ответ дан Shiv, с репутацией 127, 16.10.2014
  • 5 рейтинг

    Английский словарь определяет слова 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)
     
    ответ дан kmario23, с репутацией 13275, 30.12.2017
  • 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'}
     
    ответ дан Sanyal, с репутацией 550, 17.08.2015
  • 4 рейтинг

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

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

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

    ответ дан Crabime, с репутацией 306, 11.02.2017
  • 3 рейтинг

    Метод «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']]
     
    ответ дан Viraj Kaulkar, с репутацией 88, 31.08.2016
  • 2 рейтинг

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

     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'},
                    }
     
    ответ дан JawSaw, с репутацией 3060, 4.12.2017
  • 1 рейтинг

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

     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]
     
    ответ дан missnomer, с репутацией 29, 20.07.2018
  • 0 рейтинг

    Добавление и расширение являются одним из механизмов расширяемости в 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]
     
    ответ дан vivek, с репутацией 74, 17.07.2018
  • 0 рейтинг

    extend(L) расширяет список, добавляя все элементы в данном списке L.

      >>> a
    [1, 2, 3]
    a.extend([4]) # it is equivalent to a[len(a):] = [4] or a.append(4)
     >>>a
    [1, 2, 3, 4]
     >>> a = [1
     >>> a
    [1, 2, 3]
     >>> a[len(a)] = [4]
     >>> a
    [1, 2, 3, 4]
     
    ответ дан tessie, с репутацией 352, 31.08.2016
  • -1 рейтинг

    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,
     
    ответ дан ilias iliadis, с репутацией 111, 31.03.2018