He diseñado este tutorial para que los desarrolladores avancen desde el nivel básico hasta la experticia en el uso de comprehensions. A lo largo del artículo, exploraremos las comprehensions de listas, diccionarios y sets, incluyendo ejemplos prácticos, errores comunes y soluciones.
1. Fundamentos: ¿Qué son las comprehensions y por qué usarlas?
Las comprehensions son una forma eficiente de crear estructuras de datos en Python, como listas, diccionarios y sets, a partir de otros datos. La sintaxis básica es la siguiente:
python
comprehension = [expression for variable in iterable]
Donde:
expression
es el valor que se asigna a cada elemento.variable
es el nombre del iterador.iterable
es la fuente de los elementos.
Ventajas de usar comprehensions:
✅ Más legibles que los bucles tradicionales.
✅ Más eficientes en términos de rendimiento.
✅ Ideales para procesar grandes volúmenes de datos.
2. List comprehensions: desde básicas hasta anidadas
Las list comprehensions son una de las formas más comunes de utilizar comprehensions. Veamos algunos ejemplos:
Ejemplo básico
python
numbers = [1, 2, 3, 4, 5]
squared_numbers = [x**2 for x in numbers]
print(squared_numbers) # Output: [1, 4, 9, 16, 25]
Con condición
python
fruits = ['apple', 'banana', 'cherry']
long_fruits = [fruit for fruit in fruits if len(fruit) > 5]
print(long_fruits) # Output: ['banana', 'cherry']
Anidadas
python
numbers = [1, 2, 3, 4, 5]
squared_numbers = [[x**2 for x in numbers] for _ in range(3)]
print(squared_numbers) # Output: [[1, 4, 9, 16, 25], [1, 4, 9, 16, 25], [1, 4, 9, 16, 25]]
Ejercicio práctico
Encuentra la raíz cuadrada de los números pares en la lista.
Solución:
python
numbers = [1, 2, 3, 4, 5]
squared_numbers = [x**0.5 for x in numbers if x % 2 == 0]
print(squared_numbers) # Output: [1.4142135623730951, 2.0]
3. Dictionary comprehensions con casos prácticos
Las dictionary comprehensions se utilizan para crear diccionarios de manera concisa.
Ejemplo básico
python
numbers = [1, 2, 3, 4, 5]
squared_dict = {x: x**2 for x in numbers}
print(squared_dict) # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
Con condición
python
students = [('John', 20), ('Jane', 21), ('Bob', 22)]
age_dict = {name: age for name, age in students if age >= 21}
print(age_dict) # Output: {'Jane': 21, 'Bob': 22}
Ejercicio práctico
Crea un diccionario que relacione los nombres de los meses con su número correspondiente.
Solución:
python
months = ['January', 'February', 'March']
month_dict = {month: i for i, month in enumerate(months, start=1)}
print(month_dict) # Output: {'January': 1, 'February': 2, 'March': 3}
4. Set comprehensions y cuándo aplicarlas
Los sets son colecciones sin elementos duplicados. Las set comprehensions permiten crearlos de manera eficiente.
Ejemplo básico
python
numbers = [1, 2, 2, 3, 4]
unique_numbers = {x for x in numbers}
print(unique_numbers) # Output: {1, 2, 3, 4}
Con condición
python
fruits = ['apple', 'banana', 'apple', 'cherry']
unique_fruits = {fruit for fruit in fruits if fruit != 'apple'}
print(unique_fruits) # Output: {'banana', 'cherry'}
Ejercicio práctico
Encuentra los números que están entre 2 y 4 (inclusive).
Solución:
python
numbers = [1, 2, 3, 4, 5]
unique_numbers = {x for x in numbers if 2 <= x <= 4}
print(unique_numbers) # Output: {2, 3, 4}
5. Comparación de rendimiento vs loops tradicionales
Las comprehensions suelen ser más rápidas que los bucles tradicionales. Veamos un ejemplo:
python
import timeit
numbers = list(range(10000))
def comprehension(numbers):
return [x**2 for x in numbers]
def loop(numbers):
result = []
for x in numbers:
result.append(x**2)
return result
comprehension_time = timeit.timeit(lambda: comprehension(numbers), number=1000)
loop_time = timeit.timeit(lambda: loop(numbers), number=1000)
print(f"Comprehension time: {comprehension_time:.6f} seconds")
print(f"Loop time: {loop_time:.6f} seconds")
# Output típico:
# Comprehension time: 1.342222 seconds
# Loop time: 2.541111 seconds
Ejercicio práctico
Calcula la suma total de los elementos en el resultado de elevar al cuadrado una lista de números.
Solución:
python
total_sum = sum(result)
print(total_sum) # Output: 49001005000
6. Patrones avanzados y técnicas pro
Técnicas avanzadas
- Usando
zip
ymap
para comprehensions más complejas. - Funciones
lambda
dentro de comprehensions. - Comprehensions anidadas para estructuras de datos profundas.
Ejercicio práctico
Dada una lista de tuplas, calcula la suma total de las dos columnas después de elevar cada número al cuadrado.
Solución:
python
numbers = [(1, 2), (3, 4), (5, 6)]
squared_numbers = [[x**2 for x in pair] for pair in numbers]
total_sum = sum(sum(pair) for pair in squared_numbers)
print(total_sum) # Output: 91
Resumen final (Cheat Sheet)
Tipo de Comprehension | Sintaxis Básica | Ejemplo |
---|---|---|
List Comprehension | [x for x in iterable] | [x*2 for x in range(5)] → [0, 2, 4, 6, 8] |
Dict Comprehension | {k:v for k,v in iterable} | {x: x**2 for x in [1,2,3]} → {1:1, 2:4, 3:9} |
Set Comprehension | {x for x in iterable} | {x%3 for x in [1,2,3,4]} → {0, 1, 2} |
Conclusión
Las comprehensions son una herramienta poderosa en Python que mejora la legibilidad y eficiencia del código. Con este conocimiento, estarás preparado para aplicarlas en tus proyectos y optimizar tu código.
¡Espero que este artículo te haya sido útil! Si tienes dudas, déjalas en los comentarios. 🚀
Deja una respuesta