python elementos - Diferencia entre los métodos de agregar y ampliar la lista en Python




12 Answers

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

una listas

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




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

  • append agrega su argumento como un elemento único 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á sin embargo, muchos elementos estaban en el argumento iterable.

append

El método list.append 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 quiere):

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

Tenga en cuenta que una cadena es una iterable, por lo que si extiende una lista con una cadena, agregará cada carácter a medida que itere 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__ ( += )

Los operadores + y += se definen para la list . 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 se confunda - my_list = my_list + another_list no es equivalente a += - le da una nueva lista asignada a my_list.

Complejidad del tiempo

El apéndice tiene una complejidad de tiempo constante , O (1).

Extender tiene complejidad de tiempo, O (k).

Iterar a través de las múltiples llamadas a append agrega a la complejidad, lo que la hace equivalente a la de extenderse, y dado que la iteración de la extensión se implementa en C, siempre será más rápido si pretende agregar elementos sucesivos de un iterable a una lista.

Actuación

Tal vez 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 tiempo de ellos:

import timeit

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

Dirigiendo un comentario sobre tiempos

Un comentarista dijo:

Respuesta perfecta, simplemente pierdo la oportunidad de comparar solo agregar 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 append .

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

Aprendemos de esto que no se gana nada con el uso de extend cuando tenemos solo un elemento 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 correcta ™.

Es posible 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 la extend es semánticamente más clara, y que puede ejecutarse mucho más rápido que la append , cuando se intenta anexar cada elemento en una lista de iterables.

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




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 a medida que el bucle se implementa en C.




Puede 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 ligeras diferencias de append y extend . Una de las mayores diferencias de += de append y extend es cuando se utiliza en los ámbitos de funciones, consulte esta publicación de blog .




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



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



Un punto interesante que se ha sugerido, pero no se ha explicado, es que extender es más rápido que añadir. 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 realocació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).




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

anexar : agregar (algo) al final de un documento escrito.
extender : hacer más grande. Ampliar o ampliar

Con ese conocimiento, ahora entendamos

1) La diferencia entre append y extend

append

  • Anexa cualquier objeto de Python tal como está al final de la lista (es decir, como ú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 su argumento y hace la lista 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, flotantes) como resultado de aplicar la list(iterable) .

2) Similitud entre append y extend

  • Ambos toman exactamente un argumento.
  • Ambos modifican la lista en el lugar .
  • Como resultado, ambos devuelve 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
lis.append(object)



Adjuntar un diccionario a otro:

>>>def foo():
    dic = {1:'a', 2:'b', 3:'c', 4:'a'}
    newdic = {5:'v', 1:'aa'}
    for i in dic.keys():
        if not newdic.has_key(dic[i]):
            newdic[i] = dic[i]
    print "Appended one:", newdic

>>>foo()
Appended one: {1: 'a', 2: 'b', 3: 'c', 4: 'a', 5: 'v'}



Distinguirlos intuitivamente.

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

Es como si l1 reprodujera 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 construyeran 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'},
                }



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]



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 adición 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 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.

Método descriptor 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]

Unirse a multiples listas

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



Related

python list data-structures append extend