Pregunta Diferencia entre los métodos de agregar y extender lista en Python


Cuál es la diferencia entre los métodos de la lista append() y extend()?


2682
2017-10-31 05:55


origen


Respuestas:


append: Añade un objeto al final.

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

te dio: [1, 2, 3, [4, 5]]


extend: Extiende la lista añadiendo elementos de iterable.

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

te dio: [1, 2, 3, 4, 5]


4073
2017-10-31 06:02



append agrega un elemento a una lista, y extend concatena la primera lista con otra lista (u otra iterable, no necesariamente una lista).

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

De Sumérgete en Python.


525
2017-10-31 05:57



¿Cuál es la diferencia entre los métodos de lista anexar y extender?

  • append agrega su argumento como un elemento único al final de una lista. La longitud de la lista aumentará en uno.
  • extend itera sobre su argumento agregando cada elemento a la lista, ampliando la lista. La longitud de la lista aumentará por cuantos elementos haya en el argumento iterable.

append

los list.append método agrega un objeto al final de la lista.

my_list.append(object) 

Cualquiera que sea el objeto, ya sea un número, una cadena, otra lista u otra cosa, se agrega al final de my_list como una sola entrada en la lista.

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

Así que ten en cuenta que una lista es un objeto. Si agrega otra lista a una lista, la primera lista será un solo objeto al final de la lista (que puede no ser lo que desea):

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

los list.extend el método amplía una lista al agregar elementos de un iterable:

my_list.extend(iterable)

Entonces, con extender, cada elemento de la iterable se agrega a la lista. Por ejemplo:

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

Tenga en cuenta que una cadena es iterable, por lo que si amplía una lista con una cadena, agregará cada carácter mientras itera sobre la cadena (que puede no ser la que desea):

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

Sobrecarga del operador, __add__, (+) y __iadd__ (+=)

Ambos + y += los operadores están definidos para list. Son semánticamente similares a extenderse.

my_list + another_list crea una tercera lista en la memoria, por lo que puede devolver el resultado, pero requiere que la segunda iterable sea una lista.

my_list += another_list modifica la lista en el lugar ( es el operador in situ y las listas son objetos mutables, como hemos visto), por lo que no crea una nueva lista. También funciona como extender, ya que el segundo iterable puede ser cualquier tipo de iterable.

No te confundas my_list = my_list + another_list no es equivalente a += - te da una nueva lista asignada a mi_lista.

Complejidad del tiempo

Append tiene complejidad de tiempo constante, O (1)

Extender tiene complejidad de tiempo, O (k).

Iterando a través de las múltiples llamadas a append se agrega a la complejidad, por lo que es equivalente a la de extender, y como la iteración de extend se implementa en C, siempre será más rápido si tiene la intención de agregar elementos sucesivos de un iterable en una lista.

Actuación

Puede preguntarse qué es más eficaz, ya que se puede usar append para lograr el mismo resultado que extender. Las siguientes funciones hacen lo mismo:

def append(alist, iterable):
    for item in iterable:
        alist.append(item)

def extend(alist, iterable):
    alist.extend(iterable)

Así que vamos a cronometrarlos:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883

Dirigiendo un comentario sobre los tiempos

Un comentarista dijo:

La respuesta perfecta, simplemente extraño el momento de comparar solo agregando un elemento

Haz la cosa semánticamente correcta. Si desea agregar todos los elementos en un iterable, use extend. Si solo está agregando un elemento, use append.

Ok, entonces vamos a crear un experimento para ver cómo funciona esto a tiempo:

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

Y vemos que salir de nuestro camino para crear un iterable solo para usar extender es una pérdida de tiempo (menor):

>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295

Aprendemos de esto que no se gana nada con el uso extend cuando solo tenemos uno elemento para agregar.

Además, estos tiempos no son tan importantes. Solo les estoy mostrando para señalar que, en Python, hacer lo que es semánticamente correcto es hacer las cosas Derecha Camino.

Es concebible que pueda probar los tiempos en dos operaciones comparables y obtener un resultado ambiguo o inverso. Solo concéntrese en hacer lo semánticamente correcto.

Conclusión

Vemos eso extend es semánticamente más claro, y puede funcionar mucho más rápido que append, cuando tiene la intención de agregar cada elemento en una lista iterable. 

Si solo tiene un elemento único (no en iterable) para agregar a la lista, use append.


265
2018-01-23 22:44



append Aade un solo elemento. extend Anexa una lista de elementos.

Tenga en cuenta que si pasa una lista para agregar, aún agrega un elemento:

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

92
2017-10-31 05:57



Los siguientes dos fragmentos son semánticamente equivalentes:

for item in iterator:
    a_list.append(item)

y

a_list.extend(iterator)

Este último puede ser más rápido ya que el ciclo se implementa en C.


42
2017-08-20 21:11



Puede usar "+" para devolver extender, en lugar de extender en su lugar.

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]

similar += para el comportamiento en el lugar, pero con ligeras diferencias con append & extend. Una de las mayores diferencias de += de append y extend es cuando se usa en ámbitos funcionales, consulte esta publicación en el blog.


29
2017-08-26 11:21



El método append () agrega un solo elemento al final de la lista.

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

El método extend () toma un argumento, una lista, y agrega cada uno de los elementos del argumento a la lista original. (Las listas se implementan como clases. "Crear" una lista es realmente instanciar una clase. Como tal, una lista tiene métodos que operan en ella).

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

De Sumérgete en Python.


29
2017-10-31 13:12