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


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


2631


источник


Ответы:


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]


3980



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


517



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

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

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

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

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

Вывод

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

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


248



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

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

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

92



The following two snippets are semantically equivalent:

for item in iterator:
    a_list.append(item)

and

a_list.extend(iterator)

The latter may be faster as the loop is implemented in C.


42



You can use "+" for returning extend, instead of extending in place.

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]

Similarly += for in place behavior, but with slight differences from append & extend. One of the biggest differences of += from append and extend is when it is used in function scopes, see this blog post.


30



The append() method adds a single item to the end of the list.

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

The extend() method takes one argument, a list, and appends each of the items of the argument to the original list. (Lists are implemented as classes. “Creating” a list is really instantiating a class. As such, a list has methods that operate on it.)

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

From Dive Into Python.


29



append(object) - Updates the list by adding an object to the list.

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) - Essentially concatenates two lists.

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]

16



extend() can be used with an iterator argument. Here is an example. You wish to make a list out of a list of lists this way:

From

list2d = [[1,2,3],[4,5,6], [7], [8,9]]

you want

>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

You may use itertools.chain.from_iterable() to do so. This method's output is an iterator. Its implementation is equivalent to

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

Back to our example, we can do

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

and get the wanted list.

Here is how equivalently extend() can be used with an iterator argument:

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

15



This is the equivalent of append and extend using the + operator:

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

13



Append vs Extend

enter image description here

With append you can append a single element that will extend the list:

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

If you want to extend more than one element you should use extend, because you can only append one elment or one list of element:

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

So that you get a nested list

Instead with extend you can extend a single element like this

>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]

Or, differently from append, extend more elements in one time without nesting the list into the original one (that's the reason of the name extend)

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

Adding one element with both methods

enter image description here

append 1 element

>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]

extend one element

>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3,4]

Adding more elements... with different results

If you use append for more than one element, you have to pass a list of elements as arguments and you will obtain a NESTED list!

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

With extend, instead, you pass a list as argument, but you will obtain a list with the new element that are not nested in the old one.

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z
[1,2,3,4]

So, with more elements, you will use extend to get a list with more items. You will use append, to append not more elements to the list, but one element that is a nested list as you can clearly see in the output of the code.

enter image description here

enter image description here


13