Lista de comprensiones en Python

L

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 list constructor, 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 sencillo declarar una nueva lista y, posteriormente, agregarle uno o más elementos.

Creemos una nueva lista poblada, por ejemplo:

>>> new_list = [1, 2, 3, 4, 5]
>>> new_list
[1, 2, 3, 4, 5]

O simplemente podemos usar el append() método para agregar cualquier cosa que desee a la lista:

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

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

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

Como puede ver, crear una lista y adjuntarla a otros elementos es muy sencillo. Puede realizar esta tarea sin tener que realizar varias llamadas al .append() método.

Del mismo modo, puede utilizar un for bucle para agregar varios elementos a una lista. Por ejemplo, tendremos que escribir el siguiente fragmento de código para crear una lista de cuadrados para los enteros 1-20.

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

¿Qué son las listas de comprensión 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 puede decir que es la forma única de Python de agregar un for bucle a una lista. Pero, ya es bastante simple declarar una lista y agregarle lo que quiera. ¿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 ocupa 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 for bucles para declarar uno nuevo. Por último, también es una forma cómoda, rápida e intuitiva de generar una lista nueva y completa.

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

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

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

Sintaxis para comprensiones de listas

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

[expression for item in list if conditional]

Puede parecer un poco al revés con la expresión antes del ciclo, 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á adivinado, “expresión” es en realidad el resultado que obtenemos cuando ejecutamos el resto del código en la comprensión de listas. El código en sí es solo un bucle for que recorre 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 es necesario incluirlo.

También vale la pena mencionar que tenemos una lista sobre la que se repite el bucle, el elemento o 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 formatea y organiza.

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

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 el list_a en el ejemplo anterior. Posteriormente, agregaremos un artículo 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:

[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 for bucle en la declaración anterior está iterando sobre la lista llamada list_a. Luego ejecuta la declaración condicional que verifica si el valor actual es divisible por 4. Finalmente, ejecuta la .append() método cuando determina que el valor es realmente divisible por 4.

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

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 for bucle, que abarcaba más de tres líneas, hasta una sola línea. Esa es realmente la verdadera belleza de la comprensión de listas.

Cuándo usar listas de comprensión

Puede utilizar la comprensión de listas en muchos casos en los que necesite 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 utilizan 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, el nombre de su padre y direcciones. Los datos de cada uno de los estudiantes se almacenan además en un diccionario respectivo. Pero, ¿y si solo desea imprimir sus nombres?

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 tradicional for lazo:

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 for loop, ni siquiera necesitamos escribir tantas líneas. Podemos lograr la misma tarea escribiendo solo una línea de código a través del método de comprensión de listas:

names_list = [student['name'] for student in students]

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

Conclusión

Es realmente sorprendente cómo las listas por comprensión también reducen la 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 las listas es practicar mucho.

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias para su correcto funcionamiento. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad