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

Question

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

Answer 1

append : Anexa el objeto al final.

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

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

---

extend : Extiende la lista agregando elementos de lo iterable.

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

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

Answer 2

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

De Sumérgete en Python .

Answer 3

  

¿Cuál es la diferencia entre los métodos de lista que se adjuntan y amplían?

• 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, extendiendo la lista. La longitud de la lista aumentará, sin embargo, hay muchos elementos en el argumento iterable.

append

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

my_list.append(object) 

Sea cual 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 único objeto al final de la lista (que puede que no sea 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

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

my_list.extend(iterable)

Entonces, con la extensión, cada elemento del iterable se anexa 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]

Ten en cuenta que una cadena es iterable, así que si extiendes una lista con una cadena, agregarás cada carácter a medida que recorres la cadena (que puede que no sea lo que quieres):

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

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

Los operadores + y + = se definen para la lista . Son semánticamente similares para ampliar.

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 en el lugar, y las listas son objetos mutables, como hemos visto), por lo que no crea una nueva lista. También funciona como extensión, 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 my_list.

Complejidad de tiempo

Append tiene complejidad de tiempo constante , O (1).

Extender tiene complejidad de tiempo, O (k).

Iterar a través de las múltiples llamadas a append se suma a la complejidad, haciéndola equivalente a la de extenderse, y dado que la iteración de extensión se implementa en C, siempre será más rápida si tiene la intención de agregar sucesivas elementos de un iterable en una lista.

Rendimiento

Es posible que se pregunte qué es más eficaz, ya que se puede usar el apéndice 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

Abordar un comentario sobre horarios

Un comentarista dijo:

  

Respuesta perfecta, simplemente pierdo el tiempo de comparación al agregar solo un elemento

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

Ok, entonces creamos 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 extend es una (pequeña) pérdida de tiempo:

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

De esto aprendemos que no se gana nada con el uso de extend cuando solo tenemos un elemento un para anexar.

Además, estos tiempos no son tan importantes. Solo les muestro para señalar que, en Python, hacer lo semánticamente correcto es hacer las cosas de la manera a la derecha y # 8482 ;.

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

Conclusión

Vemos que extend es semánticamente más claro, y que puede ejecutarse mucho más rápido que anexar , cuando intenta anexar cada elemento de una manera iterable a una lista.

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

Answer 4

append agrega un solo elemento. extend agrega una lista de elementos.

Tenga en cuenta que si pasa una lista para anexar, todavía agrega un elemento:

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

Answer 5

Los dos fragmentos de código siguientes 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 a medida que el bucle se implementa en C.

Answer 6

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 crear 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 Dive Into Python .

Answer 7

Puedes usar " + " para volver a 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]

De manera similar, + = para el comportamiento en el lugar, pero con pequeñas diferencias con anexar & amp; extender . Una de las mayores diferencias de + = de append y extend es cuando se usa en los ámbitos de funciones, consulte esta publicación del blog .

Answer 8

  

Anexar vs Extender

     

Con la adición, puede agregar un solo elemento que extenderá la lista:

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

Si desea extender más de un elemento, debe usar extender, porque solo puede agregar un elemento o una lista de elementos:

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

Para que obtengas una lista anidada

En lugar de extender, puedes extender un solo elemento como este

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

O, a diferencia de anexar, extienda más elementos de una vez sin anidar la lista en la original (esa es la razón de la extensión del nombre)

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

Añadiendo un elemento con ambos métodos

añadir 1 elemento

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

extender un elemento

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

  

Agregando más elementos ... con resultados diferentes

Si usas el apéndice para más de un elemento, debes pasar una lista de elementos como argumentos y obtendrás una lista NESTED.

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

Con extend, en cambio, pasa una lista como argumento, pero obtendrá una lista con el nuevo elemento que no está anidado en el anterior.

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

Entonces, con más elementos, usará extendido para obtener una lista con más elementos. Usará append, para agregar no más elementos a la lista, sino un elemento que sea una lista anidada, como se puede ver claramente en la salida del código.

Answer 9

append (objeto) : actualiza la lista agregando un objeto a la lista.

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) : concatena esencialmente dos listas.

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]

Answer 10

extend () se puede usar con un argumento de iterador. Aquí hay un ejemplo. Desea hacer una lista de una lista de listas de esta manera:

Desde

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

que quieras

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

Puede usar itertools.chain.from_iterable () para hacerlo. La salida de este método es un iterador. Su implementación es equivalente a

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

Volviendo a nuestro ejemplo, podemos hacerlo

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

y obtenga la lista deseada.

Aquí se explica cómo se puede usar extend () de manera equivalente con un argumento de iterador:

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

Answer 11

Esto es el equivalente de append y extend usando el operador + :

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

Answer 12

append() : Básicamente se usa en Python para agregar un elemento.

  

Ejemplo 1:

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

  

Ejemplo 2:

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

extend() : donde extend (), se utiliza para combinar dos listas o insertar varios elementos en una lista.

  

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

  

Ejemplo 2:

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

Answer 13

Un punto interesante que se ha sugerido, pero no se ha explicado, es que extender es más rápido que agregar. Para cualquier bucle que se haya agregado dentro debe considerarse como reemplazado por list.extend (procesado / elementos).

Tenga en cuenta que aprender nuevos elementos podría resultar en la realimentación de toda la lista a una mejor ubicación en la memoria. Si esto se hace varias veces porque estamos agregando 1 elemento a la vez, el rendimiento general se resiente. En este sentido, list.extend es análogo a " " .join (lista de cadenas).

Answer 14

Anexar agrega todos los datos a la vez. Todos los datos se agregarán al índice recién creado. Por otro lado, extend , como su nombre lo indica, extiende la matriz actual.

Por ejemplo

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

Con anexar obtenemos:

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

Mientras estamos en extend obtenemos:

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

Answer 15

Un diccionario de inglés define las palabras adjuntar y extend como:

añadir : agregar (algo) al final de un documento escrito.
extender : hacer más grande. Ampliar o expandir

---

Con ese conocimiento, ahora entendamos

1) La diferencia entre anexar y extend

append :

• Anexa cualquier objeto de Python tal como está al final de la lista (es decir, como un último elemento en la lista).
• La lista resultante puede estar anidada y contener elementos heterogéneos (es decir, lista, cadena, tupla, diccionario, conjunto, etc.)

extend :

• Acepta cualquier iterable como su argumento y hace que la lista sea más grande .
• La lista resultante es siempre una lista dimensional (es decir, sin anidación) y puede contener elementos heterogéneos (por ejemplo, caracteres, enteros, flotadores) como resultado de la aplicación de la lista (iterable) .

2) Similitud entre anexar y extend

• Ambos toman exactamente un argumento.
• Ambos modifican la lista in-place .
• Como resultado, ambos devuelven Ninguno .

---

Ejemplo

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)

Answer 16

Espero poder hacer un complemento útil a esta pregunta. Si su lista almacena un objeto de tipo específico, por ejemplo, Info , aquí hay una situación en la que el método extend no es adecuado: en un para y y generar un objeto Info cada vez y usar extend para almacenarlo en su lista, fallará. La excepción es como a continuación:

  

TypeError: el objeto 'Info' no es iterable

Pero si utiliza el método append , el resultado es correcto. Debido a que cada vez que use el método extend , siempre lo tratará como una lista o cualquier otro tipo de colección, itérelo y colóquelo después de la lista anterior. Un objeto específico no puede ser iterado, obviamente.

Answer 17

Para distinguirlos intuitivamente

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

Es como l1 reproducir un cuerpo dentro de su cuerpo (anidado).

# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']

Es como si dos individuos separados se casaran y formaran una familia unida.

Además, hago una lista exhaustiva de todos los métodos de la lista para su referencia.

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},
                }

Answer 18

extend (L) extiende la lista agregando todos los elementos en la lista dada 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]

Answer 19

anexar " se extiende " la lista (en su lugar) por solo un elemento , el único objeto pasado (como argumento).

extend " extiende " la lista (en su lugar) por tantos elementos como contiene el objeto pasado (como argumento).

Esto puede ser un poco confuso para los objetos str .

1. Si pasa una cadena como argumento: append agregará un único elemento de cadena al final, pero extend agregará tantos " single " Los elementos 'str' como la longitud de esa cadena.
2. Si pasa una lista de cadenas como argumento: append aún agregará un solo elemento de 'lista' al final y extend agregará tantos elementos de 'lista' como la longitud de la lista pasada.

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

produce:

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,

Answer 20

Anexar y extender son uno de los mecanismos de extensibilidad en python.

Anexar: agrega un elemento al final de la lista.

my_list = [1,2,3,4]

Para agregar un nuevo elemento a la lista, podemos usar el método de agregar de la siguiente manera.

my_list.append(5)

La ubicación predeterminada donde se agregará el nuevo elemento siempre está en la posición (longitud + 1).

Insertar: el método de inserción se usó para superar las limitaciones de la aplicación. Con la inserción, podemos definir explícitamente la posición exacta en la que queremos que se inserte nuestro nuevo elemento.

Descriptor del método de inserción (índice, objeto). Toma dos argumentos, primero es el índice que queremos insertar nuestro elemento y segundo el elemento en sí.

Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']

Extender: Esto es muy útil cuando queremos unir dos o más listas en una sola lista. Sin extender, si queremos unir dos listas, el objeto resultante contendrá una lista de listas.

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

Si intentamos acceder al elemento en la pos 2, obtenemos una lista ([3]), en lugar del elemento. Para unirnos a dos listas, tendremos que usar adjuntar.

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

Para unirte a múltiples listas

a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]