Lista de comprensiones en Python

Lista de comprensiones en Python
Las comprensiones de la lista a menudo se usan en Python para escribir declaraciones de línea única que crean una nueva lista o diccionario al pasar por un objeto Iterer. Este artículo explicará cómo usar las comprensiones de la lista en Python, comenzando con una explicación básica de cómo funcionan los bucles en Python.

Para bucle en python

A la declaración para bucle en Python itera secuencialmente sobre los miembros de cualquier objeto, lista, cadena, etc. En comparación con otros lenguajes de programación, su sintaxis es mucho más limpia y no requiere una definición manual de los pasos de iteración y la iteración inicial. Aunque hay formas de hacer que su comportamiento sea igual que otros lenguajes de programación (no se cubrirá en este artículo). También puede ejercer algo de control para los bucles utilizando declaraciones como continuar, romper, pasar, etc. A continuación se muestra un ejemplo simple de For Loop en Python:

para x en el rango (10):
Imprimir (x)

El bucle for arriba imprimirá diez números a partir de 0 y finalizará a las 9.

Enumere las comprensiones

La comprensión de la lista no es más que una forma abreviada / concisa de escribir múltiples líneas para bucles en una declaración de una línea. El ejemplo de comprensión de la lista a continuación creará una nueva lista como [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] al incluir todos los valores de "x" en él.

números = [x para x en el rango (10)]
Imprimir (números)

Tenga en cuenta que la comprensión de la lista siempre crea una nueva lista y no modifica los iterables originales utilizados en la expresión. Una expresión típica de comprensión de la lista debe tener una cláusula "para" y puede seguir las declaraciones condicionales "si" y "más". Sin usar una comprensión de la lista, el ejemplo anterior se escribirá de manera siguiente:

números = []
para x en el rango (10):
números.adjuntar (x)
Imprimir (números)

Rendimiento y legibilidad

Las comprensiones de la lista son más rápidas que para los bucles. Sin embargo, a menos que esté iciando más de cientos de miles de artículos, no notará las mejoras importantes de rendimiento. Si bien la comprensión de la lista proporciona una forma concisa de escribir para bucles, las expresiones complejas pueden conducir a una mala legibilidad del código y al aumento de la verbosidad. Es importante mantener legible el código, a menos que lograr el máximo rendimiento sea una necesidad absoluta para su programa.

Ejemplo: Uso de la sintaxis de las comprensiones de la lista con diccionarios y conjuntos

Un diccionario de Python es una colección de elementos definidos en pares de valores clave, mientras que un conjunto es una colección de valores únicos donde no están permitidos duplicados. Las comprensiones de la lista se pueden usar con diccionarios y conjuntos de pitón también. La sintaxis difiere ligeramente, en lugar de terminar la expresión en aparatos cuadrados, ahora tendrá que usar aparatos ortopédicos rizados. También obtendrá un nuevo objeto de diccionario / set en lugar de una nueva lista.

data = "City": "Nueva York", "Nombre": "John Doe"
formatted_data = k: v.Title () para K, V en datos.elementos()
Imprimir (Formatted_Data)

El ejemplo anterior convertirá los valores de cadena en caso de título y creará un nuevo diccionario llamado "Formatted_Data", cuya salida será: 'City': 'Nueva York', 'Nombre': 'John Doe'. También puede cambiar el diccionario / establecer en el lugar especificando la variable de diccionario existente en el lado izquierdo.

data = "City": "Nueva York", "Nombre": "John Doe"
data = k: v.Title () para K, V en datos.elementos()
Imprimir (datos)

Sin usar comprensiones del diccionario, el código se vería así:

data = "City": "Nueva York", "Nombre": "John Doe"
formatted_data =
Para K, V en datos.elementos():
formatted_data [k] = v.título()
Imprimir (Formatted_Data)

Como no hay pares de valor clave en los conjuntos, una comprensión de conjunto se puede definir de la misma manera que una comprensión de la lista. La única diferencia es el uso de aparatos ortopédicos rizados.

Ejemplo: múltiples para bucles en una comprensión de la lista

El ejemplo de comprensión de la lista mencionado anteriormente es básico y utiliza una sola instrucción "para". A continuación se muestra un ejemplo que usa múltiples para bucles y una declaración condicional "si".

adjetivos = ["disco", "eoan", "focal", "ingenioso"]
animales = ["dingo", "armine", "fosa", "castor"]
CodeNames = [x + "" + y para x en adjetivos para y en animales si y.Startswith (x [0])]
Imprimir (nombres de código)

El código mostrará ['Dingo de disco', 'Eoan armine', 'Focal Fossa'] como salida. Los dos para bucles repasan las listas de "adjetivos" y "animales" y sus miembros se unen usando un espacio, solo si la primera letra de ambas palabras es la misma. Sin usar las comprensiones de la lista, el código se vería así:

adjetivos = ["disco", "eoan", "focal", "ingenioso"]
animales = ["dingo", "armine", "fosa", "castor"]
CodeNames = []
para x en adjetivos:
para y en animales:
Si y.Inicio con (x [0]):
nombres de código.append (x + "" + y)
Imprimir (nombres de código)

Ejemplo: Comprensión de la lista con la cláusula if-else

El siguiente ejemplo mostrará el uso de las declaraciones de IF y de lo contrario en las comprensiones de la lista.

number_list = [1, 2, 3, 4]
otro_list = [5, 6, 7, 8]
resultado = [true if (x + y) % 2 == 0 más falso para x en número_list para y en otra_list]
Imprimir (resultado)

Al pasar por dos listas, la comprensión de la lista revisa si la suma del par de elementos es uniforme o no. Ejecución del código anterior le mostrará [verdadero, falso, verdadero, falso, falso, verdadero, falso, verdadero, verdadero, falso, verdadero, falso, falso, verdadero, falso] como salida. Sin usar la comprensión de la lista, el código se vería así:

number_list = [1, 2, 3, 4]
otro_list = [5, 6, 7, 8]
resultado = []
para x en número_list:
para y en otra_list:
if (x + y) % 2 == 0:
resultado.anexar (verdadero)
demás:
resultado.agregar (falso)
Imprimir (resultado)

Conclusión

La lista de la lista proporciona una buena manera de escribir declaraciones de bucle limpias y concisas. Sin embargo, pueden ser rápidamente complejos y difíciles de entender si se utilizan múltiples bucles y declaraciones condicionales. Al final, se produce el nivel de comodidad de un programador, pero en general es una buena idea escribir código explícito, legible y fácil de depurar en lugar de usar excesivamente taquillas en taquigrafía.