comprensión de la lista python

Aumente la legibilidad de su secuencia de comandos de Python con una herramienta simple

Las comprensiones de listas reducen drásticamente la longitud y la complejidad de su código. Aquí se explica cómo construirlos.

Uno de los mayores desafíos que enfrentan los programadores principiantes cuando aprenden un nuevo idioma es descubrir cómo hacer que su código sea más legible. Dado que la colaboración es una parte fundamental del mundo laboral moderno, es vital que nos aseguremos de que otras personas puedan entender y hacer uso de nuestro código fácilmente. Al mismo tiempo, los programadores principiantes luchan por descubrir cómo hacer que su código funcione, y descubrir cómo hacerlo fácil de usar parece ser un obstáculo adicional para el que simplemente no tiene tiempo.

He estado allí, lo entiendo.

Afortunadamente, hay algunos pasos bastante simples que puede seguir para escribir un código más claro. Una de las principales formas de hacer que el código de Python sea más legible es unir varias líneas de código en una sola línea. Hay muchas maneras de hacer esto, por lo que nos sumergiremos en un método en particular: listas de comprensión. La mejor parte de este proceso es que, dado que se trata de un método estándar, otros programadores de Python que revisen su código podrán comprender rápidamente lo que está haciendo.

¿Qué son las listas de comprensión?

La comprensión de listas es una herramienta de Python que le permite crear una nueva lista al filtrar los elementos en su conjunto de datos, transformar los elementos que pasan el filtro y guardar la lista resultante, todo en una sola línea de código.

Aclara tu código: 5 formas de escribir más código pitónico

¿Por qué usar listas de comprensión?

La comprensión de listas es una herramienta que le permite crear una nueva lista filtrando los elementos en su conjunto de datos, transformar los elementos que pasan el filtro y guardar la lista resultante, todo en una sola línea de código.

Pero antes de sumergirnos en eso, tomemos un segundo para pensar qué código tenemos que escribir para lograr eso sin listas de comprensión.

Primero necesitamos crear una lista vacía para llenarla más tarde.

Luego, necesitamos escribir un ciclo for para iterar a través de cada valor en nuestro conjunto de datos.

Luego, debemos escribir una declaración if para filtrar los datos en función de una condición.

Y finalmente, necesitamos escribir otra declaración para agregar los datos resultantes a la lista.

Echemos un vistazo al código para ver cómo se ve esto. Imagina que tenemos una lista de 10 números y queremos identificar y guardar cada número mayor que el valor medio.

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

Result = []

for Number in Numbers:

   if Number > sum(Numbers)/len(Numbers):

       Result.append(Number)

Ese código de ejemplo primero crea una lista llamada Números que contiene nuestro conjunto de datos, luego ejecuta los cuatro pasos descritos anteriormente para crear la lista resultante. ¿Cuál crees que será el resultado?

Cuando esté listo para verificar su respuesta, aquí está: [6, 7, 8, 9, 10].

Esto toma cuatro líneas de código. Cuatro líneas no es una cantidad inmanejable de código, pero si puede escribirlo en una sola línea que otros entiendan fácilmente, ¿por qué no?

Más sobre listas de Python: Cómo agregar listas en Python

Practicar comprensiones de listas

La estructura general de una lista por comprensión es la siguiente:

[Function for Value in DataSet if Condition]

Escrito en lenguaje sencillo, esto dice: «Ejecute esta función en cada valor en el conjunto de datos que cumpla con una determinada condición». 

  • La función es cómo desea modificar cada dato, ¡lo que quizás no desee hacer! Las modificaciones no son necesarias y puede usar listas por comprensión para almacenar valores sin modificarlos. 

  • Value es un iterador que usamos para realizar un seguimiento del valor de datos particular rastreado en cada paso a través del ciclo for. 

  • DataSet es el conjunto de datos que está analizando en la lista de comprensión. 

  • Condición es la condición que deben cumplir los datos para ser incluidos.

Para mapear esos términos al código en nuestro ejemplo anterior, tenemos:

  • Función : Número. Como solo estamos almacenando los datos sin modificación, almacenamos el iterador sin llamar a una función.

  • Valor : Número. Este es el nombre del iterador que usamos en el ejemplo anterior, así que lo usamos nuevamente aquí. Nota: Para este ejemplo, el término utilizado en Función y Valor debe ser el mismo porque nuestro objetivo es almacenar Valor.

  • Conjunto de datos : Números. Esta fue la lista que usamos como nuestro conjunto de datos en el ejemplo anterior y la usaremos de la misma manera aquí.

  • Condición : si Número > sum(Números)/len(Números). Esta declaración if identifica números que son mayores que la media del conjunto de datos e instruye a la lista de comprensión para pasar esos valores.

Así es como se ve escrito como una sola lista de comprensión:

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

Result = [Number for Number in Numbers if Number > sum(Numbers)/len(Numbers)]

El resultado de ejecutar este código es [6, 7, 8, 9, 10]. Es el mismo resultado mientras se escribe con una sola línea de código usando una estructura que otros codificadores entenderán fácilmente.

Aprenda más con Peter GrantAprenda los fundamentos del flujo de control en Python

Comprensiones para conjuntos y diccionarios 

Nos hemos centrado en las listas, pero este método también se puede aplicar a los diccionarios (para su información, si es nuevo en la codificación, es posible que vea «diccionario» comúnmente abreviado como «dict»). Solo necesitamos hacer algunos cambios leves. a la sintaxis que corresponde a la diferente sintaxis utilizada para esas estructuras de datos.

Establecer comprensiones

La única diferencia entre conjuntos y listas, sintácticamente, es que los conjuntos usan corchetes en lugar de los corchetes que usamos para las listas. Un conjunto de comprensión se ve así:

Numbers = {1,2,3,4,5,6,7,8,9,10}

Result = {Number for Number in Numbers if Number > sum(Numbers)/len(Numbers)}

Observe cómo solo hay dos diferencias aquí. Números con corchetes en lugar de corchetes, lo que lo convierte en un conjunto en lugar de una lista. También rodeamos la comprensión que crea el resultado con corchetes en lugar de corchetes, lo que la convierte en una comprensión de conjunto en lugar de una lista de comprensión. Eso es.

Obtenemos el mismo resultado en forma de conjunto en lugar de forma de lista: {6, 7, 8, 9, 10}.

Comprensiones de diccionario

Hay dos diferencias entre las comprensiones de lista y las comprensiones de diccionario, ambas impulsadas por los requisitos de los diccionarios.

Primero, los diccionarios usan corchetes en lugar de corchetes, por lo que la estructura de comprensión de la lista debe usar corchetes. Dado que este es el mismo requisito para la comprensión de conjuntos, si comienza tratando un diccionario como un conjunto, está a mitad de camino.

La segunda diferencia se debe al hecho de que los diccionarios usan pares clave:valor en lugar de solo valores. Como resultado, debe estructurar el código para usar pares clave: valor.

Estos dos cambios conducen a una estructura que se ve así:

Result = {DictKey: DictValue for Value in DataSet if Condition}

Esto produce un resultado ligeramente diferente, porque ahora la salida es un diccionario en lugar de una lista o un conjunto. Los diccionarios tienen tanto claves como valores, por lo que la salida tiene tanto claves como valores. Esto significa que la salida será: {6: 6, 7: 7, 8: 8, 9: 9, 10:10}.

¿Cómo aplicamos funciones?

Puede recordar que dije que puede aplicar funciones a estos valores a medida que los procesa. Todavía no lo hemos hecho, pero vale la pena tomarse un momento para considerarlo ahora.

Entonces, ¿cómo hacemos para aplicar funciones? Simplemente agregamos su descripción a la parte Función del código.

Por ejemplo, si queremos calcular el cuadrado de los valores en lugar de simplemente devolver el valor, usamos el siguiente código:

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

Result_List = [Number**2 for Number in Numbers if Number > sum(Numbers)/len(Numbers)]

Result_Set = {Number**2 for Number in Numbers if Number > sum(Numbers)/len(Numbers)}

Result_Dict ={Number: Number**2 for Number in Numbers if Number > sum(Numbers)/len(Numbers)}

These three lines of code return the following outputs:

List: [36, 49, 64, 81, 100]

Set: {36, 49, 64, 81, 100}

Dictionary: {6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

Puede aplicar cualquier número de otras funciones, lo que hace que las listas de comprensión sean una forma flexible y poderosa de simplificar su código.

Una palabra de precaución

Tenga en cuenta que el propósito de la comprensión de listas es hacer que su código sea más fácil de leer. Si la comprensión de su lista hace que sea más difícil de leer, entonces anula el propósito. Las listas de comprensión pueden volverse difíciles de leer si la función o la condición son demasiado largas. Por lo tanto, cuando esté escribiendo comprensiones de listas, tenga esto en cuenta y evítelas si cree que su código será más confuso con ellas que sin ellas.  

Las personas que aprenden un nuevo lenguaje de programación tienen suficiente desafío para descubrir cómo hacer que su código funcione correctamente y, a menudo, aún no tienen las herramientas para hacer que su código sea claro y fácil de leer. Sin embargo, la colaboración efectiva es vital para el lugar de trabajo moderno. Es importante que tengamos las herramientas necesarias para que nuestro código sea legible para aquellos que no tienen experiencia en codificación. Las comprensiones de listas son una herramienta estándar de Python que puede usar para hacer que su código sea más fácil de leer y más fácil de entender para sus colegas. 

Este artículo se publicó originalmente en Python en inglés sencillo .