Introducción
En este laboratorio, se le presentarán las comprensiones de Python (Python comprehensions), una sintaxis especial que le permite crear estructuras de datos como listas, conjuntos (sets) y diccionarios a partir de otros iterables de una manera muy concisa. Las comprensiones son increíblemente útiles cuando se trabaja con uno o dos niveles de bucles for anidados, haciendo que su código sea más legible y, a menudo, más eficiente.
Comenzará con el tipo más común, las comprensiones de listas (list comprehensions), y verá cómo se comparan con los bucles for tradicionales. Luego, aprenderá a agregar lógica condicional para filtrar o transformar elementos. Finalmente, verá cómo se aplican los mismos principios para crear conjuntos y diccionarios.
Comprensión de listas
En este paso, aprenderás la sintaxis básica de las comprensiones de listas como una forma concisa de crear listas a partir de otros iterables. Compararemos el enfoque tradicional del bucle for con la sintaxis más elegante de la comprensión de listas.
Nota: Si no estás familiarizado con el uso de WebIDE (similar a VS Code), por favor, apréndelo primero en este laboratorio.
Primero, veamos cómo crearíamos una nueva lista a partir de una existente usando un bucle for estándar.
Abre el archivo main.py en el explorador de archivos de la izquierda. Copia y pega el siguiente código en el archivo:
## Traditional approach: create list using a for loop
names = ['Charles', 'Susan', 'Patrick', 'George']
new_list = []
for n in names:
new_list.append(n)
print(new_list)
Para ejecutar el código, abre una terminal haciendo clic en el icono + en el panel de terminal y seleccionando "New Terminal". Luego, ejecuta el siguiente comando:
python3 main.py
Verás la siguiente salida:
['Charles', 'Susan', 'Patrick', 'George']
Ahora, logremos el mismo resultado usando una comprensión de listas. La sintaxis básica es [expresión for elemento in iterable].
Reemplaza el contenido de main.py con el siguiente código:
## List comprehension: concise way to create a new list
## Syntax: [expression for item in iterable]
names = ['Charles', 'Susan', 'Patrick', 'George']
new_list = [n for n in names] ## Create list with all names
print(new_list)
Ejecuta el script de nuevo:
python3 main.py
La salida es idéntica, pero el código es mucho más corto y descriptivo.
['Charles', 'Susan', 'Patrick', 'George']
Las comprensiones de listas también pueden manejar bucles anidados (nested loops). Por ejemplo, para crear una lista de tuplas a partir de dos rangos, puedes hacer lo siguiente.
Actualiza tu archivo main.py con este código y ejecútalo.
## Nested list comprehension: create tuples from two ranges
## Equivalent to nested for loops
n = [(a, b) for a in range(1, 3) for b in range(1, 3)]
print(n)
Ejecuta el script:
python3 main.py
La salida será una lista de todas las combinaciones de tuplas posibles:
[(1, 1), (1, 2), (2, 1), (2, 2)]
Añadir condicionales
En este paso, explorará cómo incorporar lógica condicional en las comprensiones de listas. Aprenderá a filtrar elementos usando una declaración if y cómo aplicar expresiones condicionales a cada elemento usando una estructura if-else.
Supongamos que queremos crear una nueva lista que contenga solo los nombres que comienzan con la letra 'C'. Con un bucle for tradicional, agregaría una declaración if dentro del bucle.
Actualice su main.py con el siguiente código:
## Traditional approach: filter with if condition
names = ['Charles', 'Susan', 'Patrick', 'George', 'Carol']
new_list = []
for n in names:
if n.startswith('C'): ## Filter names starting with 'C'
new_list.append(n)
print(new_list)
Ejecute el script para ver el resultado:
python3 main.py
Salida:
['Charles', 'Carol']
Para hacer esto con una comprensión de listas, agrega la declaración if al final. La sintaxis es [expression for item in iterable if condition].
Pruebe esto en su main.py:
## List comprehension with condition: filter items
## Syntax: [expression for item in iterable if condition]
names = ['Charles', 'Susan', 'Patrick', 'George', 'Carol']
new_list = [n for n in names if n.startswith('C')]
print(new_list)
Ejecútelo y obtendrá la misma lista filtrada:
python3 main.py
Salida:
['Charles', 'Carol']
También puede usar una declaración if-else para realizar una acción condicional en cada elemento. En este caso, la expresión if-else viene antes del bucle for. La sintaxis es [expression_if_true if condition else expression_if_false for item in iterable].
Creemos una nueva lista que duplique los números pares pero mantenga los números impares como están. Actualice main.py con el siguiente código y ejecútelo.
## List comprehension with if-else: conditional expression
## Syntax: [expression_if_true if condition else expression_if_false for item in iterable]
nums = [1, 2, 3, 4, 5, 6]
new_list = [num*2 if num % 2 == 0 else num for num in nums] ## Double even numbers
print(new_list)
Ejecute el script:
python3 main.py
La salida muestra que solo se han duplicado los números pares:
[1, 4, 3, 8, 5, 12]
Comprensión de conjuntos (Set comprehension)
En este paso, comprenderá cómo aplicar la sintaxis de comprensión para crear conjuntos (sets). Los conceptos básicos de las comprensiones de list (listas) también se aplican a los sets (conjuntos) y dictionaries (diccionarios).
Las comprensiones de conjuntos son muy similares a las comprensiones de listas. La principal diferencia es que utilizan llaves {} en lugar de corchetes [] y producen un conjunto, que es una colección desordenada de elementos únicos.
La sintaxis es {expression for item in iterable}.
Creemos un conjunto a partir de otro conjunto, convirtiendo todos sus elementos de cadena (string) a mayúsculas. Actualice su archivo main.py con el siguiente código:
## Set comprehension: create a set using comprehension syntax
## Syntax: {expression for item in iterable}
b = {"abc", "def"}
upper_set = {s.upper() for s in b} ## Convert all strings to uppercase
print(upper_set)
Ahora, ejecute el script:
python3 main.py
La salida será un nuevo conjunto que contiene las cadenas en mayúsculas. Tenga en cuenta que, dado que los conjuntos no están ordenados, el orden de los elementos en la salida puede variar.
{'DEF', 'ABC'}
Si el iterable original tuviera elementos duplicados, el conjunto resultante solo contendría los elementos únicos, ya que los conjuntos descartan automáticamente los duplicados.
Comprensión de diccionarios (Dict comprehension)
En este paso, aprenderá a construir diccionarios utilizando comprensiones de diccionarios. Al igual que las comprensiones de conjuntos, también utilizan llaves {} pero requieren un par clave-valor separado por dos puntos.
La sintaxis es {key_expression: value_expression for item in iterable}.
Un caso de uso común es crear un nuevo diccionario transformando o intercambiando los pares clave-valor de un diccionario existente. Intentemos intercambiar las claves y los valores de un diccionario.
Actualice su archivo main.py con el siguiente código:
## Dict comprehension: swap keys and values
## Syntax: {key_expression: value_expression for item in iterable}
c = {'name': 'Pooka', 'age': 5}
swapped_dict = {v: k for k, v in c.items()} ## Reverse key-value pairs
print(swapped_dict)
Ejecute el script:
python3 main.py
La salida será un nuevo diccionario donde los valores originales son ahora claves y las claves originales son valores.
{'Pooka': 'name', 5: 'age'}
También puede usar comprensiones para crear otros tipos de datos a partir de diccionarios. Por ejemplo, así es como puede usar una comprensión de listas para generar una lista de cadenas formateadas a partir de los ítems de un diccionario.
Reemplace el código en main.py con este ejemplo y ejecútelo:
## List comprehension from dictionary: create formatted strings
c = {'name': 'Pooka', 'age': 5}
formatted_list = ["{}:{}".format(k.upper(), v) for k, v in c.items()] ## Format as "KEY:value"
print(formatted_list)
Ejecute el script:
python3 main.py
Esto producirá una lista de cadenas, no un diccionario.
['NAME:Pooka', 'AGE:5']
Esto demuestra la flexibilidad de usar comprensiones para procesar y transformar diferentes estructuras de datos. Para su tarea final en este paso, asegúrese de que su main.py contenga el código de intercambio de diccionarios.
Resumen
En este laboratorio, ha aprendido a utilizar la potente sintaxis de comprensión de Python para crear listas, conjuntos y diccionarios de una manera concisa y legible.
Comenzó con las comprensiones de listas, viendo cómo proporcionan una alternativa más elegante a los bucles for tradicionales. Luego aprendió a agregar lógica condicional, utilizando un if final para filtrar y una expresión if-else para transformar elementos. Finalmente, vio cómo se aplican estos mismos principios a las comprensiones de conjuntos y diccionarios, utilizando llaves {} para construir conjuntos de elementos únicos y diccionarios de pares clave-valor.
Las comprensiones son una parte fundamental del código Python idiomático. Dominarlas hará que su código sea más eficiente y elegante. Siga practicando para que se conviertan en una parte natural de su conjunto de herramientas de programación en Python.
