Convertir tupla en lista en Python

Para convertir una tupla en una lista en Python, pase la tupla al constructor list(): list(my_tuple). Las tuplas son inmutables y las listas son mutables, por lo que convertir una tupla es la forma de obtener una versión modificable de sus datos cuando necesita agregar, eliminar o reordenar elementos. La conversión crea una nueva lista externa; los elementos en sí no se convierten, y su orden y valores se conservan exactamente. Este artículo muestra la conversión directa, la forma con desempaquetado y las dos formas estándar de convertir tuplas anidadas, cuyas tuplas internas necesitan un paso adicional.

Convertir una tupla en una lista con list()

El constructor list() acepta cualquier iterable y construye una nueva lista a partir de sus elementos. Funciona con tuplas de cualquier contenido, incluidas las tuplas que mezclan tipos diferentes:

mixed_tuple = ('apple', 42, 3.14, True)
my_list = list(mixed_tuple)
print(my_list)

Salida:

['apple', 42, 3.14, True]

Solo cambia el contenedor. La cadena, el entero, el flotante y el booleano dentro de la nueva lista son los mismos objetos que antes, en el mismo orden; no se convierte nada de ellos. Si luego modifica my_list, la tupla original no se ve afectada, porque la lista es un objeto separado. Para una tupla plana, esta única llamada es la respuesta completa y es el método al que debe recurrir primero.

Convertir una tupla en una lista con desempaquetado

También puede crear la lista desempaquetando la tupla con el operador * dentro de una expresión de lista:

my_tuple = (1, 2, 3, 4, 5)
my_list = [*my_tuple]
print(my_list)

Salida:

[1, 2, 3, 4, 5]

La expresión [*my_tuple] desempaqueta los elementos de la tupla en una nueva lista. Esta forma se basa en el desempaquetado generalizado (PEP 448), por lo que está disponible en Python 3.5 y versiones posteriores; no funciona en Python 2 ni en Python 3.4 y versiones anteriores. El desempaquetado es más útil cuando la nueva lista combina varias secuencias a la vez, por ejemplo [*first, *second], donde list() por sí solo necesitaría un paso de concatenación adicional. Para una conversión sencilla de una sola tupla, produce exactamente la misma lista que list().

Convertir tuplas anidadas con una comprensión de lista

Una llamada simple a list() convierte solo el contenedor externo. Si la tupla contiene otras tuplas, las internas permanecen como tuplas:

nested = ((1, 2), (3, 4), (5, 6))
print(list(nested))

Salida:

[(1, 2), (3, 4), (5, 6)]

Para convertir también cada tupla interna, aplique list() a cada fila con una comprensión de lista:

nested = ((1, 2), (3, 4), (5, 6))
converted = [list(row) for row in nested]
print(converted)

Salida:

[[1, 2], [3, 4], [5, 6]]

Cada row es una tupla interna, y list(row) la convierte en una lista, de modo que el resultado es una lista de listas. El mismo patrón se extiende a anidamientos más profundos aplicándolo en cada nivel que necesite cambiar.

Convertir tuplas anidadas con map()

La función map() consigue el mismo resultado aplicando list a cada elemento de la tupla externa. Como map() devuelve un iterador, envuélvalo en list() para construir la lista final:

nested = ((1, 2), (3, 4), (5, 6))
converted = list(map(list, nested))
print(converted)

Salida:

[[1, 2], [3, 4], [5, 6]]

map(list, nested) llama a list una vez por cada tupla interna, exactamente lo que la comprensión de la sección anterior escribe de forma explícita. Elija la forma que se lea mejor en su código: la comprensión muestra la operación por elemento de manera explícita, mientras que map() es compacta cuando la conversión es una única función existente. Ambas dejan la tupla anidada original sin cambios y devuelven una nueva lista de listas.