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

Solución:

append: Agrega 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 agregando elementos del iterable.

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

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

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

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

• append agrega su argumento como un solo elemento al final de una lista. La longitud de la lista en sí aumentará en uno.
• extend itera sobre su argumento agregando cada elemento a la lista, extendiendo la lista. La longitud de la lista aumentará en la cantidad de elementos que haya en el argumento iterable.

append

los list.append El 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']

Por tanto, tenga 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 at the end of the list.

extend

los list.extend El método extiende una lista agregando elementos de un iterable:

my_list.extend(iterable)

Entonces, con extender, cada elemento del 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 extiende una lista con una cadena, agregará cada carácter a medida que itera sobre la cadena (que puede no ser lo 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 extender.

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

my_list += another_list modifica la lista en el lugar (se 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 se confunda – my_list = my_list + another_list no es equivalente a += – le da una lista nueva asignada a my_list.

Complejidad del tiempo

Append tiene una 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 suma a la complejidad, haciéndolo equivalente al de extender, y dado que la iteración de extender se implementa en C, siempre será más rápido si tiene la intención de agregar elementos sucesivos de un iterable a una lista.

Rendimiento

Quizás se pregunte qué es más eficaz, ya que append se puede usar para lograr el mismo resultado que extend. 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

Abordar un comentario sobre horarios

Un comentarista dijo:

Respuesta perfecta, solo extraño el momento de comparar agregando solo un elemento

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

Bien, creemos 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 hacer todo lo posible para crear un iterable solo para usar extend es una (menor) pérdida de tiempo:

>>> 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 tenemos solo uno elemento para agregar.

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

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

Conclusión

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

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

---

---

Utiliza Nuestro Buscador