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

3116

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

Claudiu
fuente

Respuestas:

5255

append: Agrega 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]

kender
fuente
122
¿Cuál es la diferencia entre extendy simplemente utilizando el operador de suma - en el ejemplo anterior, x = x + [4, 5]?
Rohan
303
En realidad, hay una gran diferencia : x + [4, 5]le da una nueva lista asignada a x, x.extend()muta la lista original. Elaboro mi respuesta aquí abajo.
Aaron Hall
@AaronHall @Rohan pero es lo mismo que x += [4,5].
Astitva Srivastava
1
@AstitvaSrivastava En realidad, creo que extender es más rápido en términos de bytecode
MilkyWay90
1
La palabra clave cuando se usa appendes Object . Si intenta usar extendy pasa un diccionario , agregará la clave y no el hash completo al final de la matriz.
Anthony
640

appendagrega un elemento a una lista y extendconcatena la primera lista con otra lista (u otro 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']
Harley Holcombe
fuente
490

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

  • appendagrega su argumento como un elemento único al final de una lista. La longitud de la lista aumentará en uno.
  • extenditera 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

El list.appendmé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 my_listcomo una sola entrada en la lista.

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

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

El list.extendmé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 +=operadores están definidos para list. Son semánticamente similares a extender.

my_list + another_list crea una tercera lista en la memoria, para que pueda devolver el resultado, pero requiere que el segundo iterable sea una lista.

my_list += another_listmodifica la lista en el lugar ( es el operador en el lugar, y las listas son objetos mutables, como hemos visto) para que no cree 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_listno es equivalente a +=, le da una nueva lista asignada a my_list.

Complejidad de tiempo

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

Extender tiene complejidad de tiempo, O (k).

La iteración a través de las múltiples llamadas a appendagrega complejidad, haciéndola equivalente a la 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.

Actuación

Quizás se pregunte qué es más eficaz, ya que append se puede usar 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, solo extraño el momento de comparar agregar solo un elemento

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

Ok, entonces 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 salir de nuestro camino para crear una extensión iterable solo para usar 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 extendcuando solo tenemos un elemento para agregar.

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

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 que extendes semánticamente más clara, y que puede funcionar mucho más rápido que append, cuando se tiene la intención de añadir cada elemento en un iterable a una lista.

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

Aaron Hall
fuente
1
@Aaron Hall Un pequeño comentario en el algoritmo de sincronización. "extend_one" puede devolver el tiempo "ligeramente incorrecto" porque la creación de una lista también está involucrada. Probablemente mejor es crear los elementos como variables ( ex1 = 0y ex2 = [0]) y pasar estas variables, si quieres ser más estricto.
ilias iliadis
19
Respuesta perfecta de hecho. ¿Qué pasa con el rendimiento de l1 += l2vs l1.extend(l2)?
Jean-Francois T.
66
@ Jean-FrancoisT .: l1 += l2y l1.extend(l2)finalmente ejecuta el mismo código (la list_extendfunción en listobject.c). Las únicas diferencias son: 1. +=reasignación l1(a sí mismo para lists, pero la reasignación admite tipos inmutables que no son el mismo objeto después), lo que lo hace ilegal si en l1realidad es un atributo de un objeto inmutable; por ejemplo, t = ([],), t[0] += lstfallaría, mientras que t[0].extend(lst)funcionaría. 2. l1 += l2usa bytecodes dedicados, mientras que l1.extend(l2)usa el envío generalizado de métodos; esto hace +=más rápido que extend.
ShadowRanger
3
El hecho de que +=debe reasignarse l1significa que, en algunos casos, el despacho más lento extendse compensa parcial o totalmente al no asignar de nuevo al lado izquierdo. Por ejemplo, si listes un atributo de un objeto self.l1 += l2y self.l1.extend(l2)tiene un rendimiento idéntico en mi instalación de Python 3.6, simplemente porque la operación real es más parecida self.l1 = self.l1.__iadd__(l2), lo que significa que debe realizar un costo moderadamente costoso STORE_ATTRque self.l1.extend(l2)no tiene que ser así.
ShadowRanger
2
Comparación simple en pruebas locales: para una variable local (por lo +=que solo se usa STORE_FAST, que es súper barata), donde el valor agregado es un valor existente listcon un elemento, con la operación repetida 1000 veces, +=tomó aproximadamente 33 ns en promedio , mientras que extendtomó 78 ns, una diferencia de 45 ns. Si l1es global (requiere más caro STORE_GLOBAL), la diferencia se reduce a 17 ns. Si l1es en realidad local.l1(requiere aún más caro STORE_ATTR), no hay una diferencia significativa entre +=y extend(tiempos más o menos idénticos; a extendveces gana).
ShadowRanger
121

appendagrega un solo elemento. extendagrega una lista de elementos.

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

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

Agregar vs Extender

ingrese la descripción de la imagen aquí

Con append 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 cambio, con extender, puede extender un solo elemento como este

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

O, de manera diferente, anexar, extender más elementos a la vez sin anidar la lista en la original (esa es la razón del nombre extendido)

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

Agregar un elemento con ambos métodos

ingrese la descripción de la imagen aquí

Tanto append como extend pueden agregar un elemento al final de la lista, aunque append es más simple.

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

Añadiendo más elementos ... con diferentes resultados

Si usa append para más de un elemento, debe pasar una lista de elementos como argumentos y obtendrá 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á extender para obtener una lista con más elementos. Sin embargo, agregar una lista no agregará más elementos a la lista, sino un elemento que es una lista anidada, como puede ver claramente en la salida del código.

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

Giovanni G. PY
fuente
61

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 bucle se implementa en C.

Erik
fuente
20
Ampliar es ~ 4 veces más rápido en mi máquina que agregar en un bucle (16us vs 4us para 100 bucles de ceros)
Alex L
66
extend()probablemente preasigna, mientras que append()probablemente no.
Físico loco
@MadPhysicist: Para completar, habría momentos en los extend() que no se puede preasignar con sensatez ya que algunos iterables no se implementan __len__(), pero como tú, me sorprendería si no lo intenta. Parte de la ganancia de rendimiento también proviene de hacer la parte de iteración en C puro en lugar de en Python, como se señala en la respuesta de Aaron .
Soren Bjornstad
44

El append()método 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 extend()método 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 instancia de una clase. Como tal, una lista tiene métodos que funcionan 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 sumergirse en Python .

CodyChan
fuente
No se puede extender con solo 6 ya que no es iterable. Y la segunda salida en su ejemplo es incorrecta. 'abc' se agrega como un solo elemento ya que lo pasó extendcomo una lista con un elemento ['abc']: [1, 2, 3, 4, 5, 'abc']. Para hacer su salida de ejemplo correcto, cambie la línea ABC a: x.extend('abc'). Y elimine el x.extend(6)o cámbielo a x.extend([6]).
Aneroide
37

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]

Del mismo modo +=para el comportamiento en el lugar, pero con ligeras diferencias de append& extend. Una de las mayores diferencias de +=from appendy extendes cuando se usa en ámbitos de funciones, vea esta publicación de blog .

denfromufa
fuente
¿Usar el '+' para devolver extender tiene algún efecto en la complejidad del tiempo?
franklin
55
@franklin, vea esta respuesta para más detalles: stackoverflow.com/a/28119966/2230844
denfromufa
1
No veo cómo esto responde la pregunta
pppery
22

append(object) - 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) - Básicamente concatena 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]
Chaitanya
fuente
20

extend()se puede usar con un argumento 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]]

usted quiere

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

Puede itertools.chain.from_iterable()hacerlo 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 hacer

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

y obtener la lista de buscados.

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

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Kiriloff
fuente
2
Esta respuesta no contrasta con extend con append y, por lo tanto, no responde la pregunta
pppery
19

Este es el equivalente appendy el extenduso del +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]]
skdev75
fuente
¿Por qué no = +? Más conciso
denfromufa
16

append () : se usa básicamente 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 usa para fusionar dos listas o insertar múltiples 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]
El Gr8 Adakron
fuente
12

Un punto interesante que se ha insinuado, pero no explicado, es que extender es más rápido que agregar. Para cualquier bucle que se haya agregado dentro, se debe considerar que se reemplaza por list.extend (procesado_elementos).

Tenga en cuenta que la aplicación de nuevos elementos puede resultar en la reasignació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 ve afectado. En este sentido, list.extend es análogo a "" .join (stringlist).

bconstanzo
fuente
12

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

Por ejemplo

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

Con appendnosotros obtenemos:

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

Mientras extendestamos en:

result = [123, 456, 678, 111, 222]
Shiv
fuente
8

Un diccionario de inglés define las palabras appendy extendcomo:

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


Con ese conocimiento, ahora entendamos

1) La diferencia entre appendyextend

append:

  • Agrega cualquier objeto Python como está al final de la lista (es decir, como el último elemento de 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 argumento y hace que la lista sea más grande .
  • La lista resultante es siempre una lista unidimensional (es decir, sin anidamiento) y puede contener elementos heterogéneos (por ejemplo, caracteres, enteros, flotantes) como resultado de la aplicación list(iterable).

2) Similitud entre appendyextend

  • Ambos toman exactamente un argumento.
  • Ambos modifican la lista en el lugar .
  • Como resultado, ambos regresan None.

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
list.append(object)
kmario23
fuente
5

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 extendmétodo no es adecuado: en un forciclo y generando un Infoobjeto cada vez y usando extendpara almacenarlo en su lista, fallará. La excepción es la siguiente:

TypeError: el objeto 'Info' no es iterable

Pero si usa el appendmétodo, el resultado está bien. Porque cada vez que usa el extendmétodo, siempre lo tratará como una lista o cualquier otro tipo de colección, lo iterará y lo colocará después de la lista anterior. Un objeto específico no puede ser iterado, obviamente.

Crabime
fuente
4

Para distinguirlos intuitivamente

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

Es como l1reproducir 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 personas separadas se casaran y construyeran una familia unida.

Además, hago una hoja de referencia 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'},
                }
Cálculo
fuente
2

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]
Tessie
fuente
0

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

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

Esto puede ser un poco confuso para los strobjetos.

  1. Si pasa una cadena como argumento: appendagregará un único elemento de cadena al final, pero extendagregará tantos elementos de "cadena" única como la longitud de esa cadena.
  2. Si pasa una lista de cadenas como argumento: appendtodavía agregará un solo elemento '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,
ilias iliadis
fuente
0

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

Agregar: 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 append de la siguiente manera.

my_list.append(5)

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

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

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

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 posición 2, obtenemos una lista ([3]), en lugar del elemento. Para unir dos listas, tendremos que usar append.

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

Para unir múltiples listas

a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]
vivek
fuente
2
¿Por qué estás respondiendo una pregunta que ya ha sido respondida muchas veces? Esta pregunta tiene 10 años ...
Mike - SMT