Tutorial de comprensión de listas en Python

Cuando haces ciencia de datos, es posible que quieras leer listas de listas, filtrar nombres de columnas, eliminar vocales de una lista o aplanar una matriz. Puedes utilizar fácilmente una función lambda o un bucle for; como bien sabes, hay múltiples formas de hacerlo. Otra forma de hacerlo es utilizando comprensiones de listas.

Este tutorial tratará este último tema:

• Primero tendrás una breve recapitulación de lo que son las listas de Python y cómo se comparan con otras estructuras de datos de Python;
• A continuación, te sumergirás en las comprensiones de listas de Python: aprenderás más sobre las matemáticas que hay detrás de las listas de Python, cómo puedes construir comprensiones de listas, cómo puedes reescribirlas como bucles for o funciones lambda, ..... No sólo leerás sobre esto, ¡sino que también harás algunos ejercicios!
• Cuando hayas dominado los conceptos básicos, también es hora de perfeccionar tus comprensiones de listas añadiéndoles condicionales: aprenderás cómo puedes incluir condicionales en las comprensiones de listas y cómo puedes manejar múltiples condiciones if y sentencias if-else.
• Por último, te sumergirás en las comprensiones de listas anidadas para iterar varias veces sobre listas.

Si también te interesa abordar la comprensión de listas junto con iteradores y generadores? ¡Echa un vistazo al curso Python Data Science Toolbox de DataCamp!

Listas Python

A estas alturas, probablemente habrás jugado con valores que tenían varios tipos de datos. Has guardado todos y cada uno de los valores en una variable distinta: cada variable representa un único valor. Sin embargo, en la ciencia de datos, a menudo trabajarás con muchos puntos de datos, lo que hará difícil seguir almacenando cada valor en una variable separada. En su lugar, almacena todos estos valores en una lista Python.

Las listas son una de las cuatro estructuras de datos incorporadas en Python. Otras estructuras de datos que quizá conozcas son las tuplas, los diccionarios y los conjuntos. Una lista en Python es diferente de, por ejemplo, int o bool, en el sentido de que es un tipo de datos compuesto: puedes agrupar valores en listas. De hecho, estos valores no tienen por qué ser del mismo tipo: pueden ser una combinación de valores booleanos, String, enteros, ....

Es importante tener en cuenta que las listas son colecciones ordenadas de elementos u objetos. Esto hace que las listas en Python sean "tipos secuencia", ya que se comportan como una secuencia. Otros ejemplos de secuencias son las cadenas, las tuplas o los conjuntos.

Consejo: si quieres saber más, poner a prueba o practicar tus conocimientos sobre las listas en Python, puedes hacerlo repasando aquí las preguntas más frecuentes sobre las listas en Python.

Ahora, en una nota práctica: construyes una lista con dos corchetes; dentro de estos corchetes, utilizarás comas para separar tus valores. A continuación, puedes asignar tu lista a una variable. Los valores que pongas en una lista Python pueden ser de cualquier tipo de datos, ¡incluso listas!

Mira el siguiente ejemplo de lista:

Consejo: ¡construye tu propia lista en el intérprete de comandos IPython que contiene el fragmento anterior de DataCamp Light!

Comprensión de listas en Python

Con la recapitulación de las listas de Python fresca en la mente, puedes ver fácilmente que definir y crear listas en Python puede ser un trabajo pesado: teclear todos los valores por separado puede llevarte bastante tiempo y puedes cometer errores fácilmente.

Las comprensiones de listas en Python se construyen del siguiente modo:

list_variable = [x for x in iterable]

Pero, ¿cómo se llega a esta forma de construir y utilizar estas construcciones en Python? Profundicemos un poco más.

Comprensión de listas en Python: Las matemáticas

Por suerte, Python tiene la solución para ti: te ofrece una forma de implementar una notación matemática para hacerlo: la comprensión de listas.

Recuerda que en matemáticas, las formas habituales de describir listas (o conjuntos, o tuplas, o vectores) son:

S = {x² : x in {0 ... 9}}
V = (1, 2, 4, 8, ..., 2¹²)
M = {x | x in S and x even}

En otras palabras, verás que las definiciones anteriores en realidad te dicen lo siguiente:

• La secuencia S es en realidad una secuencia que contiene valores entre 0 y 9 incluidos que se elevan a la potencia de dos.
• En cambio, la secuencia V contiene el valor 2 elevado a una determinada potencia. Para el primer elemento de la secuencia, es 0, para el segundo es 1, y así sucesivamente, hasta llegar a 12.
• Por último, la secuencia M contiene elementos de la secuencia S, pero sólo los pares.

Si las definiciones anteriores te dan dolor de cabeza, echa un vistazo a las listas reales que producirían estas definiciones:

S = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
V = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096}
M = {0, 4, 16, 36, 64}

¡Ves claramente el resultado de cada lista y las operaciones que se describían en ellas!

Ahora que has entendido algunas de las matemáticas que hay detrás de las listas, ¡puedes traducir o implementar la notación matemática de la construcción de listas en Python utilizando comprensiones de listas! Echa un vistazo a las siguientes líneas de código:

Todo esto se parece mucho a las definiciones matemáticas que acabas de ver, ¿verdad?

No te preocupes si estás un poco perdido en este punto; aunque no seas un genio de las matemáticas, estas comprensiones de listas son bastante fáciles si te tomas tu tiempo para estudiarlas. Echa un segundo vistazo al código Python que ves en el fragmento de código anterior.

Verás que el código te lo indica:

• La lista S se construye con los corchetes que has leído más arriba en la primera sección. En esos paréntesis, ves que hay un elemento x, que está elevado a la potencia de 10. Ahora, sólo necesitas saber para cuántos valores (¡y qué valores!) necesitas elevar a la potencia de 2. Esto se determina en range(10). Considerando todo esto, puedes deducir que elevarás todos los números, del 0 al 9, a la potencia de 2.
• La lista V contiene el valor base 2, que se eleva a una determinada potencia. Igual que antes, ahora necesitas saber qué potencia o i se va a utilizar exactamente para hacerlo. Ves que i en este caso forma parte de range(13), lo que significa que empiezas en 0 y llegas hasta 12. Todo esto significa que tu lista va a tener 13 valores: esos valores serán 2 elevado a la potencia 0, 1, 2, ... hasta 12.
• Por último, la lista M contiene elementos que forman parte de S si -y sólo si- se pueden dividir por 2 sin que sobren. El módulo tiene que ser 0. En otras palabras, la lista M se construye con los valores iguales que están almacenados en la lista S.

Ahora que ves todo esto escrito, tiene mucho más sentido, ¿verdad?

Recapitulación y práctica

En resumen, ves que hay un par de elementos que vuelven en todas estas líneas de código:

• Los corchetes, que son una firma de las listas de Python;
• La palabra clave for, seguida de una variable que simbolice un elemento de la lista; y
• La palabra clave in, seguida de una secuencia (¡que puede ser una lista!).

Y esto da como resultado el trozo de código que has visto al principio de esta sección:

list_variable = [x for x in iterable]

¡Ahora te toca a ti seguir adelante y empezar con las comprensiones de listas en Python! Vamos a ceñirnos a las listas matemáticas que has visto antes:

La comprensión de listas como alternativa a...

La comprensión de listas es un sustituto completo de los bucles for, la función lambda y las funciones map(), filter() y reduce(). Es más, para algunas personas, ¡la comprensión de listas puede ser incluso más fácil de entender y utilizar en la práctica! Leerás más sobre esto en la siguiente sección.

Sin embargo, si quieres saber más sobre las funciones y las funciones lambda en Python, consulta nuestro Tutorial de funciones en Python.

Bucles For

Como ya sabrás, los bucles for se utilizan para repetir un bloque de código un número fijo de veces. En realidad, las comprensiones de listas son buenas alternativas a los bucles for, ya que son más compactas. Considera el siguiente ejemplo que comienza con la variable numbers, definida como un intervalo desde 0 hasta 10 (no incluido).

Recuerda que el número que pasas a la función range() es en realidad el número de enteros que quieres generar, empezando por cero, claro. Esto significa que range(10) devolverá [0,1,2,3,4,5,6,7,8,9].

# Initialize `numbers`
numbers = range(10)

Si ahora quieres realizar una operación en cada elemento de numbers, puedes hacerlo con un bucle for, como éste:

# Initialize `new_list`
new_list = []

# Add values to `new_list`
for n in numbers:
    if n%2==0:
        new_list.append(n**2)

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Todo esto está muy bien, pero ahora considera el siguiente ejemplo de comprensión de una lista, donde básicamente haces lo mismo con una notación más compacta:

# Create `new_list` 
new_list = [n**2 for n in numbers if n%2==0]

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Estudiemos la diferencia de rendimiento entre la comprensión de listas y el bucle for con una pequeña prueba: puedes configurarlo muy rápidamente con la biblioteca timeit, que puedes utilizar para cronometrar pequeños fragmentos de código Python de forma sencilla. En este caso, los pequeños trozos de código que vas a probar son el bucle for, que pondrás en una función llamada power_two() para mayor comodidad, y la comprensión exacta de la lista que has formulado más arriba.

Ten en cuenta que también debes introducir el número de ejecuciones que quieres considerar. En este caso, se fija en 10000 en el argumento number.

# Import `timeit`
import timeit

# Print the execution time
print(timeit.timeit('[n**2 for n in range(10) if n%2==0]', number=10000))

0.05234622399802902

# Define `power_two()` 
def power_two(numbers):
    for n in numbers:
        if n%2==0:
            new_list.append(n**2)
    return new_list

# Print the execution time 
print(timeit.timeit('power_two(numbers)', globals=globals(), number=10000))

0.07795589299712447

Observa que en este último fragmento de código, también añades el argumento globals, que hará que el código se ejecute dentro de tu espacio de nombres global actual. Esto es muy útil si tienes una Función Definida por el Usuario (UDF) como la función power_two() del ejemplo anterior. También puedes pasar un parámetro setup que contenga una sentencia import. Puedes leer más sobre ello aquí.

Consejo: consulta el tutorial de DataCamp Bucles en Python para obtener más información sobre los bucles en Python.

Funciones lambda con map(), filter() y reduce()

Las funciones lambda también se denominan "funciones anónimas" o "funciones sin nombre". Eso significa que sólo utilizas este tipo de funciones cuando se crean. Las funciones lambda toman prestado su nombre de la palabra clave lambda de Python, que se utiliza para declarar estas funciones en lugar de la palabra clave estándar def.

Normalmente utilizas estas funciones junto con las funciones map(), filter(), y reduce().

Cómo sustituir map() en combinación con funciones lambda

Puedes reescribir la combinación map() y una función lambda como en el ejemplo siguiente:

# Initialize the `kilometer` list 
kilometer = [39.2, 36.5, 37.3, 37.8]

# Construct `feet` with `map()`
feet = map(lambda x: float(3280.8399)*x, kilometer)

# Print `feet` as a list 
print(list(feet))

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

Ahora, puedes sustituir fácilmente esta combinación de funciones que definen la variable feet por comprensiones de listas, teniendo en cuenta los componentes sobre los que has leído en el apartado anterior:

• Empieza con los corchetes.
• A continuación, añade el cuerpo de la función lambda entre esos corchetes: float(3280.8399)*x.
• A continuación, añade la palabra clave for y asegúrate de repetir el elemento de la secuencia x, al que ya hiciste referencia al añadir el cuerpo de la función lambda.
• No olvides especificar de dónde viene x: añade la palabra clave in, seguida de la secuencia de donde vas a obtener x. En este caso, transformarás los elementos de la lista kilometer.

Si haces todo esto, obtendrás el siguiente resultado:

# Convert `kilometer` to `feet` 
feet = [float(3280.8399)*x for x in kilometer]

# Print `feet`
print(feet)

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

filter() y funciones lambda a las comprensiones de lista

Ahora que has visto lo fácil que es convertir la función map() en combinación con una función lambda, también puedes abordar el código que contiene la función filter() de Python con funciones lambda y reescribirlo también.

Considera el siguiente ejemplo:

# Map the values of `feet` to integers 
feet = list(map(int, feet))

# Filter `feet` to only include uneven distances 
uneven = filter(lambda x: x%2, feet)

# Check the type of `uneven`
type(uneven)

# Print `uneven` as a list
print(list(uneven))

[122375, 124015]

Para reescribir las líneas de código del ejemplo anterior, en realidad puedes utilizar dos comprensiones de lista, almacenadas en las variables feet y uneven.

En primer lugar, reescribes la función map(), que utilizas para convertir los elementos de la lista feet en enteros. A continuación, abordas la función filter(): tomas el cuerpo de la función lambda, utilizas las palabras clave for y in para conectar lógicamente x y feet:

# Constructing `feet` 
feet = [int(x) for x in feet]

# Print `feet`
print(feet)

# Get all uneven distances
uneven = [x%2 for x in feet]

# Print `uneven`
print(uneven)

[128608, 119750, 122375, 124015]
[0, 0, 1, 1]

Reduce reduce() y Funciones Lambda en Python

Por último, también puedes reescribir las funciones lambda que se utilizan con la función reduce() en líneas de código más compactas. Mira el siguiente ejemplo:

# Import `reduce` from `functools` 
from functools import reduce

# Reduce `feet` to `reduced_feet`
reduced_feet = reduce(lambda x,y: x+y, feet)

# Print `reduced_feet`
print(reduced_feet)

[128608, 119750, 122375, 124015]
494748

Ten en cuenta que en Python 3, la función reduce() se ha trasladado al paquete functools. Por tanto, tendrás que importar el módulo para utilizarlo, como en el ejemplo de código anterior.

El trozo de código anterior es bastante largo, ¿verdad?

¡Vamos a reescribir este trozo de código!

¡Ten cuidado! Debes tener en cuenta que no puedes utilizar y. Las comprensiones de lista sólo funcionan con un único elemento, como el x que has visto a lo largo de los numerosos ejemplos de este tutorial.

¿Cómo vas a solucionarlo?

Pues bien, en casos como éste, las funciones de agregación como sum() pueden resultar útiles:

# Construct `reduced_feet`
reduced_feet = sum([x for x in feet])

# Print `reduced_feet`
print(reduced_feet)

494748

Ten en cuenta que, si lo piensas, el uso de funciones de agregación al reescribir la función reduce() en combinación con una función lambda tiene sentido: es muy parecido a lo que haces en SQL cuando utilizas funciones de agregación para limitar el número de registros que obtienes tras ejecutar tu consulta. En este caso, utilizas la función sum() para agregar los elementos en feet ¡y obtener sólo un valor definitivo!

Ten en cuenta que, aunque este enfoque puede no ser tan eficaz en SQL, ¡definitivamente es el camino a seguir cuando trabajas en Python!

Comprensión de listas con condicionales

Ahora que has comprendido los fundamentos de las comprensiones de listas en Python, es hora de ajustar el flujo de control de tus comprensiones con la ayuda de los condicionales.

# Define `uneven`
uneven = [x/2 for x in feet if x%2==0]

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

¡Ten en cuenta que puedes reescribir el trozo de código anterior con un bucle for de Python fácilmente!

# Initialize and empty list `uneven` 
uneven = []

# Add values to `uneven` 
for x in feet:
    if x % 2 == 0:
        x = x / 2
        uneven.append(x)

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Múltiples condiciones Si

Ahora que has comprendido cómo puedes añadir condiciones, es hora de convertir el siguiente bucle for en una comprensión de lista con condicionales.

divided = []

for x in range(100):
    if x%2 == 0 :
        if x%6 == 0:
            divided.append(x)

Ten cuidado, ¡ves que el siguiente bucle for contiene dos condiciones! Piensa detenidamente cómo vas a resolver esto.

divided = [x for x in range(100) if x % 2 == 0 if x % 6 == 0]

print(divided)

[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]

Condiciones Si-Si

Por supuesto, es mucho más habitual trabajar con condicionales que implican más de una condición. Así es, verás más a menudo if en combinación con elif y else. Ahora bien, ¿cómo te enfrentas a eso si piensas reescribir tu código?

Mira el siguiente ejemplo de una condicional más compleja en un bucle for:

[x+1 if x >= 120000 else x+5 for x in feet]

[128609, 119755, 122376, 124016]

Ahora mira el siguiente trozo de código, que es una reescritura del trozo de código anterior:

for x in feet:  
    if x >= 120000:
        x + 1
    else: 
        x+5

Verás que se trata básicamente del mismo código, pero reestructurado: el último for x in feet inicializa ahora el bucle for. Después, añades la condición if x >= 120000 y la línea de código que quieres ejecutar si esta condición es True: x + 1. Si en cambio la condición es False, se ejecuta el último trozo de código de tu comprensión de lista: x+5.

Comprensiones de listas anidadas

Aparte de las condicionales, también puedes ajustar tus comprensiones de lista anidándolas dentro de otras comprensiones de lista. Esto es muy útil cuando quieres trabajar con listas de listas: generar listas de listas, transponer listas de listas o aplanar listas de listas a listas normales, por ejemplo, resulta extremadamente fácil con las comprensiones de listas anidadas.

Mira el siguiente ejemplo:

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

# Flatten `list_of_list`
[y for x in list_of_list for y in x]

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

Asignas una lista bastante simple de lista a una variable list_of_list. En la línea siguiente, ejecutas una comprensión de lista que devuelve una lista normal. Lo que ocurre en realidad es que tomas los elementos de lista ( y ) de las listas anidadas ( x ) en list_of_list y devuelves una lista de aquellos elementos de lista y que están comprendidos en x.

Verás que la mayoría de las palabras clave y elementos que se utilizan en el ejemplo de comprensión de lista anidada son similares a los que utilizaste en los ejemplos de comprensión de lista simple:

• Corchetes
• Dos palabras clave for, seguidas de una variable que simboliza un elemento de la lista de listas (x) y un elemento de una lista anidada (y); y
• Dos palabras clave in, seguidas de una lista de listas (list_of_list) y un elemento de lista (x).

La mayoría de los componentes sólo se utilizan dos veces y subes un nivel (o más, ¡depende de cómo lo mires!).

Lleva algún tiempo acostumbrarse, pero es bastante sencillo, ¿no?

Veamos ahora otro ejemplo, en el que verás que también puedes utilizar dos pares de corchetes para cambiar la lógica de la comprensión de tu lista anidada:

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

[[row[i] for row in matrix] for i in range(3)]

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

Ahora practica: reescribe el trozo de código anterior en un bucle for anidado. Si necesitas algunas indicaciones sobre cómo abordar este ejercicio, ve a una de las secciones anteriores de este tutorial.

transposed = []

for i in range(3):
     transposed_row = []
     for row in matrix:
            transposed_row.append(row[i])
     transposed.append(transposed_row)

También puedes utilizar comprensiones de listas anidadas cuando necesites crear una lista de listas que sea en realidad una matriz. Mira el siguiente ejemplo:

matrix = [[0 for col in range(4)] for row in range(3)]

matrix

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Consejo: ¡practica tus habilidades con los bucles en Python y reescribe el trozo de código anterior en un bucle for anidado!

Puedes encontrar la solución a continuación.

for x in range(3):
    nested = []
    matrix.append(nested)
    for row in range(4):
        nested.append(0)

Si quieres hacer algún trabajo extra, trabaja en la traducción de este bucle for a un bucle while. Puedes encontrar la solución a continuación:

x = 0
matrix =[]

while x < 3:
    nested = []
    y = 0
    matrix.append(nested)
    x = x+1
    while y < 4:
        nested.append(0)
        y= y+1

Por último, es bueno que sepas que también puedes utilizar funciones como int() para convertir las entradas de tu lista feet en números enteros. Encapsulando [int(x) for x in feet] dentro de otra comprensión de lista, construyes una matriz o listas de tu lista con bastante facilidad:

[[int(x) for x in feet] for x in feet]

[[128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015]]

Domina Python para la Ciencia de Datos

¡Enhorabuena! Has llegado al final de este tutorial, en el que has abordado la comprensión de listas, un mecanismo muy utilizado en Python para la ciencia de datos. Ahora que entiendes el funcionamiento de este mecanismo, ¡estás preparado para enfrentarte también a las comprensiones de diccionario, conjunto, ...!

No olvides que puedes practicar tus conocimientos de Python a diario con el modo de práctica diaria de DataCamp. Puedes encontrarlo en tu panel de control. Si aún no conoces el modo de práctica diaria, ¡leelo aquí!

Aunque las comprensiones de listas pueden hacer que nuestro código sea más sucinto, es importante garantizar que nuestro código final sea lo más legible posible, por lo que deben evitarse las líneas individuales de código muy largas para garantizar que nuestro código sea fácil de usar.