Comprensiones de listas en Python

La comprensión de listas es el proceso de crear una nueva lista a partir de una existente. Ofrecen muchos beneficios a las listas tradicionales. En este artículo, nos sumergiremos en la teoría y la práctica del uso de listas de comprensión.

Introducción

Una lista es uno de los tipos de datos fundamentales en Python. Cada vez que te encuentras con un nombre de variable seguido de un corchete [], o un constructor de lista, es una lista capaz de contener varios elementos, lo que la convierte en un tipo de datos compuesto. Del mismo modo, también es muy fácil declarar una nueva lista y, posteriormente, agregarle uno o más elementos.

Breve descripción general de las listas en Python

Vamos a crear una nueva lista poblada:

1
2
new_list = [1, 2, 3, 4, 5]
print(new_list) # [1, 2, 3, 4, 5]

O simplemente podemos usar el método append() para agregar lo que quieras a la lista:

1
2
new_list.append(6)
print(new_list) # [1, 2, 3, 4, 5, 6]

Si necesita agregar varios elementos a la misma lista, el método extender() será útil. Simplemente necesita pasar la lista de elementos para agregar al método extender, como se muestra a continuación:

1
2
new_list.extend([7, 8, 9])
print(new_list) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Como puede ver, crear una lista y agregarla con otros elementos es pan comido. Puede realizar esta tarea sin tener que realizar múltiples llamadas al método .append().

De manera similar, puede usar un bucle for para agregar varios elementos a una lista. Por ejemplo, tendremos que escribir el siguiente código para crear una lista de cuadrados para los números enteros 1-20.

1
2
3
list_a = []
for i in range(1, 20):
    list_a.append(i**2)

¿Qué son las comprensiones de lista en Python?

En las palabras más simples, la comprensión de listas es el proceso de crear una nueva lista a partir de una lista existente. O bien, puede decir que es la forma única de Python de agregar un bucle for a una lista. Pero ya es bastante simple declarar una lista y agregarle lo que desee. ¿no es así? Entonces, ¿por qué molestarse en comprender nuestras listas?

La comprensión de listas, de hecho, ofrece muchos beneficios sobre las listas tradicionales. Para empezar, el código abarca una sola línea, lo que facilita aún más su declaración y lectura. También es menos engorroso comprender listas que usar bucles for para declarar una nueva. Finalmente, también es una forma conveniente, más rápida e intuitiva de generar una nueva lista poblada.

Volviendo a los cuadrados de los números enteros 1-20, podemos obtener el mismo resultado utilizando el método de comprensión de listas. Así es como se verá nuestro código ahora:

1
list_b = [i**2 for i in range(1, 20)]

Observe cómo la lógica para generar los elementos de la lista está entre corchetes. Cubriremos más sobre la sintaxis en la siguiente sección.

Lista de sintaxis de comprensiones

Antes de seguir adelante, es imperativo explicar la sintaxis de la comprensión de listas. Aquí está la sintaxis básica de comprensión de lista que contiene una condición:

1
[expression for item in list if conditional]

Puede parecer un poco al revés con la expresión antes del bucle, ¡pero así es como se hace! El orden es así, presumiblemente, porque sería difícil poner la expresión después del condicional sin algún tipo de punto y coma, que Python no tiene.

Como ya habrás adivinado, expression es en realidad el resultado que obtenemos cuando ejecutamos el resto del código en una lista de comprensión. El código en sí es solo un bucle for iterando sobre una colección de datos. En nuestro ejemplo, estamos usando la expresión, o la salida, para generar la lista de cuadrados.

Tenga en cuenta que el condicional es opcional, por lo que, como en nuestro ejemplo anterior, no necesitamos incluirlo.

También vale la pena mencionar que tenemos una lista para recorrer, el elemento o los elementos que se van a iterar y, por supuesto, una declaración condicional tanto en la comprensión de la lista como en los bucles for tradicionales. Entonces, cada método tiene las mismas construcciones generales, pero la diferencia es cómo los formateas y organizas.

También vamos a ver otro ejemplo más complejo para comprender mejor el concepto detrás de la comprensión de listas.

1
2
3
4
5
6
7
list_a = [1, 3, 6, 9, 12, 15]
list_b = []
for number in list_a:
    if number % 4 == 0:
        list_b.append(number)

print(list_b)

En realidad, estamos recorriendo list_a en el ejemplo anterior. Posteriormente, agregaremos un elemento a list_b si su valor es divisible por 4, lo cual se verifica usando el operador de módulo (%). En este ejemplo, veríamos lo siguiente impreso en la consola:

1
[12]

Esto se debe a que 12 es el único número de esa matriz que es divisible por 4.

Una vez más, podemos usar la comprensión de listas para reducir el total de líneas de código que tenemos que escribir para lograr el mismo objetivo.

Como se mencionó anteriormente, el ciclo for en la declaración anterior está iterando sobre la lista llamada list_a. Luego ejecuta la declaración condicional que comprueba si el valor actual es divisible por 4. Finalmente, ejecuta el método .append() cuando comprueba que el valor es realmente divisible por 4.

Ahora, si desea escribir el código anterior con comprensión de lista, se vería así:

1
2
3
4
list_a = [1, 3, 6, 9, 12, 15]
list_b = [number for number in list_a if number % 4 == 0]

print(list_b)

Como puede ver, hemos reducido el bucle for, que abarcaba tres líneas, a una sola línea. Esa es en realidad la verdadera belleza de la comprensión de listas.

Cuándo usar listas de comprensión

Puede usar la comprensión de listas en muchos casos en los que necesita generar una lista a partir de un iterable. Sin embargo, el mejor momento para usar este método es cuando necesita agregar o extraer elementos a una lista de manera consistente de acuerdo con un patrón establecido. Los desarrolladores de Python los usan principalmente para extraer datos de una gran colección de elementos.

Supongamos que tiene una lista de miles de estudiantes actuales y anteriores con sus nombres, los nombres de sus padres y direcciones. Los datos de cada uno de los estudiantes se almacenan además en un diccionario respectivo. Pero, ¿y si solo quieres imprimir sus nombres?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
students = [
    {
        "name" : "Jacob Martin",
        "father name" : "Ros Martin",
        "Address" : "123 Hill Street",
    }, {
        "name" : "Angela Stevens",
        "father name" : "Robert Stevens",
        "Address" : "3 Upper Street London",
    }, {
        "name" : "Ricky Smart",
        "father name" : "William Smart",
        "Address" : "Unknown",
    }
]

Tenemos la opción de iterar sobre la lista usando el bucle for tradicional:

1
2
3
4
5
6
names_list = []

for student in students:
    names_list.append(student['name'])

print(names_list)

Aunque en este ejemplo son solo dos líneas de código para el bucle for, ni siquiera necesitamos escribir tantas líneas. Podemos realizar la misma tarea escribiendo solo una línea de código a través del método de comprensión de listas:

1
2
3
names_list = [student['name'] for student in students]

print(names_list)
1
['Jacob Martin', 'Angela Stevens', 'Ricky Smart']

Conclusión

Es realmente sorprendente cómo la comprensión de listas también reduce su carga de trabajo. Sin embargo, puede parecer confuso al principio. Es particularmente desconcertante para los principiantes que nunca antes se han aventurado en este territorio, principalmente debido a la sintaxis. También puede resultarle difícil comprender el concepto si ha estado programando en otros lenguajes porque la comprensión de listas no existe en ninguno de ellos. La única forma de entender la comprensión de la lista es practicar mucho.

Licensed under CC BY-NC-SA 4.0