Cómo Agregar Elementos a una Lista en Python

Sin duda alguna, las listas son una de las estructuras de datos más importantes en Python y uno de sus pilares fundamentales. En este artículo te cuento cómo añadir uno o varios elementos a una lista, ya sea por el final, al principio o en una posición determinada.

Para añadir un elemento al final de la lista se usa el método append y para añadir los elementos de un iterable, extend o el operador +=. Para insertar un elemento en una posición concreta se utiliza el método insert.

Este resumen tiene mucha información así que vamos a ir viendo todo esto poco a poco y, como siempre, con los ejemplos y peculiaridades correspondientes a cada caso, además de un caso extra particular usando el operador *=.

Cómo agregar un elemento al final de una lista en Python

Tal vez esta sea una de las primeras operaciones que se nos plantea en el aprendizaje de las lista de Python.

Para añadir o agregar un único elemento al final de una lista de Python puedes usar el método append perteneciente a la clase list.

Aprovecho para recordarte que todas las listas, en Python, son objetos o instancias de la clase list.

Así, si tenemos una lista de números, por ejemplo, llamada lista y queremos añadirle al final un nuevo número, digamos el 10, basta con realizar lista.append(10). Tan sencillo como eso.

Vamos a verlo en un ejemplo completo en una consola de Python:

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

Lo cierto es que es muy sencillo, directo e intuitivo.

Funciona igualmente si lo que tienes es una lista vacía y quieres insertar un primer elemento. Se puede considerar que añadir un elemento al final de una lista vacía es insertar un primer elemento:

>>> lista = []
>>> lista.append(10)
>>> print(lista)
[10]

Perfecto. Ya sabemos añadir un elemento al final. Veamos ahora como añadir varios elementos al final.

Cómo agregar varios elementos al final de una lista en Python

Este es un caso más general que el anterior que te he contado.

A veces te encontrarás en la situación de tener que añadir al final de una lista varios elementos que puedes tener en otra lista, por ejemplo. Aunque cualquier iterable sirve.

Lo primero que se te va a venir a la cabeza es realizar un bucle recorriendo la lista de los elementos a insertar y realizando llamadas a append para lograr el efecto deseado.

Te lo muestro con un ejemplo para que quede claro:

>>> lista = [10, 20, 30]
>>> nuevos_elementos = [40, 50, 60]
>>> 
>>> for elemento in nuevos_elementos:
...     lista.append(elemento)
... 
>>> print(lista)
[10, 20, 30, 40, 50, 60]

Aunque esto funciona, hay una manera más eficiente y más legible, en la que, además, no necesitas bucles.

Se trata de usar el método extend de list, que recibe un iterable y agrega sus elementos a la lista en el mismo orden de iteración.

Te lo muestro:

>>> lista = [10, 20, 30]
>>> nuevos_elementos = [40, 50, 60]
>>> 
>>> lista.extend(nuevos_elementos)
>>> print(lista)
[10, 20, 30, 40, 50, 60]

Ya ves que entre append y extend ya puedes añadir al final de una lista elementos de manera cómoda, tengas uno o varios.

De todas maneras, y gracias a los métodos dunder, podemos hacer esta operación de extend sin necesidad de escribirla.

Basta con usar el operador +=.

Como sabrás el operador + nos sirve para concatenar listas (y algunos otros iterables). Es decir, si queremos juntar los elementos de una lista con los elementos de otra en una misma lista, podemos usar +:

>>> lista1 = ['a', 'b', 'c']
>>> lista2 = ['y', 'z']
>>>
>>> lista = lista1 + lista2
>>> print(lista)
['a', 'b', 'c', 'y', 'z']
>>>
>>> print(lista1)
['a', 'b', 'c']
>>> print(lista2)
['y', 'z']

Esto, de todas maneras, genera una nueva lista de forma que las listas a concatenar quedan inalteradas como puedes ver en el ejemplo.

En nuestro caso se trata de añadir elementos a una lista y no de crear una nueva.

Usando el operador += podemos añadir los elementos de un iterable a una lista sin crear una nueva. Es decir, como si hiciéramos un extend.

Esto es así porque se ejecuta el método dunder __iadd__ de la clase list cuando usamos dicho operador, que lo que hace es una operación de extensión.

Lo vemos en un ejemplo:

>>> lista = [10, 20, 30]
>>> nuevos_elementos = [40, 50, 60]
>>> 
>>> print(id(lista))
140089540658240
>>> 
>>> lista += nuevos_elementos
>>> print(lista)
[10, 20, 30, 40, 50, 60]
>>> print(id(lista))
140089540658240

Se puede apreciar cómo se ha logrado agregar los nuevos elementos al final de la lista. Además, en el ejemplo hago uso de la función integrada id antes y después de la operación de agregación para asegurarnos de que la variable lista sigue haciendo referencia al mismo objeto y no se ha creado uno nuevo.

Vamos a ver cómo, algo que parece prácticamente lo mismo, tiene un efecto diferente:

>>> lista = [10, 20, 30]
>>> nuevos_elementos = [40, 50, 60]
>>> 
>>> print(id(lista))
140089540590208
>>> 
>>> lista = lista + nuevos_elementos
>>> print(lista)
[10, 20, 30, 40, 50, 60]
>>> print(id(lista))
140089540659520

Como puedes ver, aunque la lista final tiene los elementos esperado, se trata de otra lista y no de la original.

Esto sucede porque al ejecutar el operador + no se ejecuta el método __iadd__ como acabamos de ver, sino __add__ que ejecuta una operación de concatenación generando y devolviendo una lista nueva.

Cómo insertar un elemento en una posición concreta de una lista en Python

Si lo que necesitas es agregar un elemento a una lista, pero no al final, sino en cualquier posición, es decir, lo que llamamos una inserción, puedes usar el método insert de la clase list.

El método insert recibo dos argumentos que son la posición en la que quieres insertar el elemento y el propio elemento.

Ten en cuenta que el nuevo elemento insertado pasará a estar en la posición indicada por parámetro a la función insert y que ningún elemento es eliminado (no se reemplaza al elemento existente en dicha posición). Por tanto, todo el resto de elementos se desplazan en la lista una posición a la derecha.

Así, por ejemplo, para insertar un elemento en la posición 2 de una lista podrías hacer lo siguiente:

>>> lista = [10, 20, 30]
>>> lista.insert(2, 100)
>>> print(lista)
[10, 20, 100, 30]

¿Sencillo, no?

De este modo, para insertar un elemento justo al principio de una lista bastará con indicar que la posición de inserción es la 0:

>>> lista = [10, 20, 30]
>>> lista.insert(0, 100)
>>> print(lista)
[100, 10, 20, 30]

De la misma manera, y simulando un append, podríamos insertar al final de la lista indicando como posición una más respecto de la posición del último elemento, dicho de otro modo, len(lista).

>>> lista = [10, 20, 30]
>>> lista.insert(len(lista), 100]
>>> lista.insert(len(lista), 100)
>>> print(lista)
[10, 20, 30, 100]

De todas maneras, esto está desaconsejado, siendo preferible el uso de append que hace, además, el código mucho más legible y fácil de entender.

Si indicamos a insert cualquier número de posición superior a la longitud de la lista, el elemento se insertará al final de la misma.

Cómo insertar varios elementos en una posición concreta de una lista en Python

Lamentablemente, no existe en Python un método que nos permita insertar varios elementos en una posición concreta.

Si necesitas realizar esa operación, puedes confeccionar una función para ello utilizando un bucle e invocando a la función insert las veces necesarias para lograr el resultado deseado.

Lo vemos:

>>> def insertar_varios(lista, posicion, nuevos_elementos):
...     for elemento in nuevos_elementos:
...             lista.insert(posicion, elemento)
...             posicion += 1
... 
>>> 
>>> lista = [10, 20, 30]
>>> insertar_varios(lista, 1, [4, 5, 6])
>>> print(lista)
[10, 4, 5, 6, 20, 30]

Solo tienes que tener cuidado de actualizar la variable posicion cada vez que realices una inserción para asegurarte de que los nuevos elementos quedan insertados en el mismo orden en el que los recibe la función.

Cómo replicar y agregar al final todos los elementos de una lista en Python

Aquí te cuento una operación menos habitual pero que puede tener su utilidad.

Se trata de replicar en la propia lista todo el contenido que ya tiene insertado, una o varias veces.

Para que lo entiendas, si tienes una lista con los elementos [10, 20, 30] y necesitas replicar estos elementos y agregarlos al final de la lista para obtener [10, 20, 30, 10, 20, 30] con esta operación lo podrás hacer.

En este caso debes de usar el operador *=.

La replicación la lleva a cabo el operador * pero para que no se genere una nueva lista y se modifique la que nosotros queramos (como pasaba con el caso de + y +=) debes usar *=.

Empecemos con ejemplos de * para que veas su efecto:

>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> [1, 2, 3] * 2
[1, 2, 3, 1, 2, 3]
>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> ['a', 'b'] * 5
['a', 'b', 'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b']
>>> [0, 'a', [1, 2]] * 3
[0, 'a', [1, 2], 0, 'a', [1, 2], 0, 'a', [1, 2]]

Ya ves lo que se puede conseguir.

Ahora bien, si quieres lograr ese efecto modificando una lista concreta y no generando una nueva, como ya dije, tienes que usar *=.

Lo vemos:

>>> lista = [1, 2, 3]
>>> print(id(lista))
139751124192384
>>> 
>>> lista *= 2
>>> print(lista)
[1, 2, 3, 1, 2, 3]
>>> print(id(lista))
139751124192384

Arriba puedes observar cómo hemos logrado reinsertar los elementos 1, 2, 3 que ya estaban en la lista otra vez al final de la misma. También hemos comprobado cómo el id del objeto sigue siendo el mismo, asegurándonos de que hemos modificado la lista original y no se ha creado una nueva.

Ten en cuenta que esta operación no duplica los elementos sino que lo que hace es replicar las referencias a los mismos. Es decir, podemos tener insertado en diversas posiciones de la lista el mismo valor u objeto.

Hay que tenerlo presente porque si modificas un objeto mutable, el cambio se verá reflejado en todas las posiciones de la lista en la que se encuentre esa referencia.

Por el contrario, si sustituyes uno de los valores de una posición, se perderá la antigua referencia en esa posición para dejar paso a la nueva.

Para ver este efecto lo mejor es usar un ejemplo. Supongamos que tenemos una lista con tres elementos:

• Un número entero (tipo básico)
• Una cadena de texto (objeto inmutable)
• Una lista (objeto mutable)

Si replicamos estos elementos y los reinsertamos mediante *=, se replicarán las referencias a los objetos.

Lo vemos:

>>> lista = [1527, "texto", [1, 2, 3]]
>>> lista *= 2
>>>
>>> for indice, elemento in enumerate(lista):
...     print(f'Elemento {indice}: {elemento=}, id={id(elemento)}')
... 
Elemento 0: elemento=1527, id=139751124046512
Elemento 1: elemento='texto', id=139751124199600
Elemento 2: elemento=[1, 2, 3], id=139751124191104
Elemento 3: elemento=1527, id=139751124046512
Elemento 4: elemento='texto', id=139751124199600
Elemento 5: elemento=[1, 2, 3], id=139751124191104

Cómo puedes ver el id de los elementos 0 y 3 son el mismo. Igual que sucede con los elementos 1 y 4 y con los elementos 2 y 5.

La lista tiene 6 elementos pero en realidad solo hay 3 objetos diferentes en la misma.

Veamos que pasa si intentamos algunas modificaciones:

>>> lista[3] = 23419
>>> lista[4] = 'otro texto'
>>> lista[5].append(4)
>>> 
>>> for indice, elemento in enumerate(lista):
...     print(f'Elemento {indice}: {elemento=}, id={id(elemento)}')
... 
Elemento 0: elemento=1527, id=139751124046512
Elemento 1: elemento='texto', id=139751124199600
Elemento 2: elemento=[1, 2, 3, 4], id=139751124191104
Elemento 3: elemento=23419, id=139751124045584
Elemento 4: elemento='otro texto', id=139751124200496
Elemento 5: elemento=[1, 2, 3, 4], id=139751124191104

Como puedes observar, al modificar los elementos en las posiciones 3 y 4 se crean nuevos valores con nuevos ids. Esto es natural, pues tanto los enteros como las cadenas de texto son inmutables.

Lo interesante aquí está al modificar la lista de la posición 5. Como a dicha lista se hace referencia también en la posición 2, si accedemos a ese elemento en esta posición, vemos que ha quedado modificado. Ten esto muy en cuenta.

Conclusiones

Hemos visto varias maneras de agregar o insertar uno o varios elementos en una lista de Python, así como diferentes métodos y operadores que podemos usar según las necesidades que tengamos.

Recapitulando:

• Usa append para agregar un elemento al final.
• Usa extend o += para agregar todos los elementos de un iterable al final.
• Usa insert para insertar un elemento en cualquier posición.
• Usa *= para replicar una o más veces todas las referencias de los valores y objetos en una lista y agregarlas a la final de la misma.

Si te ha gustado este artículo y has aprendido algo, suscríbete a la lista de correo de Código Pitón para recibir contenido exclusivo, trucos y consejos de Python. Además te regalaré estos tres recursos imprescindibles que te llegarán inmediatamente cuando te suscribas:

• La Guía Rápida y Práctica de ChatGPT y Python.
• La Hoja de Referencia de Python.
• El Tutorial Básico Interactivo de Python.

¡Feliz programación!