Comprensiones de Listas y Diccionarios en Python

Introducción

Contenido de la lección.

Objetivos de aprendizaje

Objetivo 1
Objetivo 2
Objetivo 3

Objetivos de Aprendizaje

Al finalizar este tema, serás capaz de:

Dominar la sintaxis de comprensiones de listas, diccionarios y conjuntos
Aplicar filtros y transformaciones usando comprensiones anidadas
Comparar el rendimiento entre comprensiones y bucles tradicionales
Implementar comprensiones en casos de uso profesionales reales

📚 Fundamentos de Comprensiones de Listas

Una comprensión de lista es una forma concisa de crear listas basada en iterables existentes. La sintaxis básica sigue el patrón: [expresión for elemento in iterable]. Esta estructura elimina la necesidad de inicializar una lista vacía y usar append() en un bucle. Las comprensiones también permiten incluir condiciones de filtrado usando la palabra clave 'if'. La expresión puede ser cualquier operación válida de Python, desde simples transformaciones hasta llamadas de función complejas. Es importante entender que las comprensiones crean nuevas listas sin modificar el iterable original, manteniendo la inmutabilidad de datos cuando sea necesario.

Crear una lista de cuadrados usando comprensión Copiar

# Comprensión básica para generar cuadrados
numeros = [1, 2, 3, 4, 5]
cuadrados = [x**2 for x in numeros]
print('Números originales:', numeros)
print('Cuadrados:', cuadrados)

Números originales: [1, 2, 3, 4, 5]
Cuadrados: [1, 4, 9, 16, 25]

Explicación: La comprensión [x**2 for x in numeros] itera sobre cada elemento y calcula su cuadrado, creando una nueva lista con los resultados.

Filtrar elementos con condiciones Copiar

# Filtrar números pares y calcular su cuadrado
numeros = range(1, 11)
pares_cuadrados = [x**2 for x in numeros if x % 2 == 0]
print('Números del 1 al 10:', list(numeros))
print('Cuadrados de pares:', pares_cuadrados)

Números del 1 al 10: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Cuadrados de pares: [4, 16, 36, 64, 100]

Explicación: La condición 'if x % 2 == 0' filtra solo los números pares antes de calcular sus cuadrados, combinando filtrado y transformación en una línea.

🎯 Comprensiones de Diccionarios y Conjuntos

Las comprensiones no se limitan a listas; también pueden crear diccionarios y conjuntos usando sintaxis similar. Para diccionarios, la estructura es {clave: valor for elemento in iterable}, mientras que para conjuntos es {expresión for elemento in iterable}. Las comprensiones de diccionarios son especialmente útiles para transformar datos, crear mapeos inversos, o filtrar elementos de diccionarios existentes. Los conjuntos creados mediante comprensiones automáticamente eliminan duplicados, lo cual es valioso para operaciones de deduplicación. Estas estructuras mantienen las mismas ventajas de rendimiento y legibilidad que las comprensiones de listas.

Crear diccionario con comprensión Copiar

# Crear diccionario de números y sus cuadrados
numeros = [1, 2, 3, 4, 5]
dict_cuadrados = {x: x**2 for x in numeros}
print('Diccionario número -> cuadrado:')
for k, v in dict_cuadrados.items():
    print(f'{k}: {v}')

Diccionario número -> cuadrado:
1: 1
2: 4
3: 9
4: 16
5: 25

Explicación: La comprensión {x: x**2 for x in numeros} crea pares clave-valor donde la clave es el número original y el valor es su cuadrado.

Comprensión de conjuntos para eliminar duplicados Copiar

# Crear conjunto de longitudes de palabras
palabras = ['python', 'java', 'go', 'rust', 'javascript', 'c++']
longitudes = {len(palabra) for palabra in palabras}
print('Palabras:', palabras)
print('Longitudes únicas:', sorted(longitudes))

Palabras: ['python', 'java', 'go', 'rust', 'javascript', 'c++']
Longitudes únicas: [2, 3, 4, 6, 10]

Explicación: El conjunto automáticamente elimina longitudes duplicadas, mostrando solo los valores únicos de longitud de las palabras.

💡 Comprensiones Anidadas y Complejas

Las comprensiones pueden anidarse para trabajar con estructuras de datos multidimensionales como matrices o listas de listas. La sintaxis para comprensiones anidadas sigue el orden natural de lectura: los bucles externos van primero. También es posible combinar múltiples condiciones usando operadores lógicos and/or. Sin embargo, es importante mantener un equilibrio entre concisión y legibilidad; comprensiones excesivamente complejas pueden ser menos mantenibles que bucles tradicionales. Las comprensiones anidadas son especialmente útiles en procesamiento de matrices, análisis de datos tabulares y transformaciones de estructuras complejas.

Comprensión anidada para matriz 3x3 Copiar

# Crear matriz 3x3 con comprensión anidada
matriz = [[i*3 + j for j in range(3)] for i in range(3)]
print('Matriz 3x3:')
for fila in matriz:
    print(fila)
# Aplanar matriz con comprensión
plana = [elemento for fila in matriz for elemento in fila]
print('Matriz aplanada:', plana)

Matriz 3x3:
[0, 1, 2]
[3, 4, 5]
[6, 7, 8]
Matriz aplanada: [0, 1, 2, 3, 4, 5, 6, 7, 8]

Explicación: La comprensión anidada crea una matriz y luego la aplana. El orden de los bucles en la comprensión de aplanado es crucial: primero fila, luego elemento.

Filtros múltiples en comprensiones Copiar

# Filtrar con múltiples condiciones
numeros = range(1, 21)
resultado = [x for x in numeros if x % 2 == 0 if x % 3 == 0]
print('Números del 1 al 20 divisibles por 2 Y por 3:', resultado)
# Equivalente con operador and
resultado2 = [x for x in numeros if x % 2 == 0 and x % 3 == 0]
print('Usando and:', resultado2)

Números del 1 al 20 divisibles por 2 Y por 3: [6, 12, 18]
Usando and: [6, 12, 18]

Explicación: Ambas sintaxis son equivalentes: múltiples 'if' consecutivos se comportan como operador 'and', filtrando elementos que cumplen todas las condiciones.

🔧 Casos de Uso Profesionales y Optimización

En el desarrollo profesional, las comprensiones son fundamentales para el procesamiento eficiente de datos. Son especialmente valiosas en análisis de logs, transformación de APIs JSON, procesamiento de archivos CSV y manipulación de bases de datos. Las comprensiones generalmente superan en rendimiento a los bucles tradicionales porque están optimizadas a nivel de intérprete. Sin embargo, para operaciones muy complejas, pueden ser menos legibles que funciones dedicadas. Es crucial conocer cuándo usar comprensiones versus bucles tradicionales, map(), filter(), o generadores. En aplicaciones de big data, las comprensiones de generadores pueden ser más eficientes en memoria que las comprensiones de listas.

Procesamiento de datos tipo API JSON Copiar

# Simular respuesta de API con datos de usuarios
usuarios = [
    {'nombre': 'Ana', 'edad': 25, 'activo': True},
    {'nombre': 'Luis', 'edad': 17, 'activo': False},
    {'nombre': 'María', 'edad': 30, 'activo': True}
]
# Extraer nombres de usuarios activos y mayores de edad
activos_adultos = [u['nombre'] for u in usuarios 
                  if u['activo'] and u['edad'] >= 18]
print('Usuarios activos y mayores de edad:', activos_adultos)

Usuarios activos y mayores de edad: ['Ana', 'María']

Explicación: Este patrón es común en APIs REST: filtrar y extraer campos específicos de respuestas JSON basándose en múltiples criterios de negocio.

Transformación y agregación de datos Copiar

# Análisis de ventas por categoría
ventas = [
    {'producto': 'laptop', 'categoria': 'tech', 'precio': 1000},
    {'producto': 'mouse', 'categoria': 'tech', 'precio': 25},
    {'producto': 'libro', 'categoria': 'edu', 'precio': 15}
]
# Crear mapping de categoría a lista de precios
precios_por_categoria = {}
for venta in ventas:
    cat = venta['categoria']
    if cat not in precios_por_categoria:
        precios_por_categoria[cat] = []
    precios_por_categoria[cat].append(venta['precio'])
print('Precios por categoría:', precios_por_categoria)

Precios por categoría: {'tech': [1000, 25], 'edu': [15]}

Explicación: Aunque este ejemplo usa bucle tradicional para claridad, muestra cómo preparar datos para análisis posterior usando comprensiones en cada categoría.

Ejercicios Prácticos

Filtrado y Transformación de Calificaciones

BÁSICO

Descripción:

Dada una lista de estudiantes con sus calificaciones, crear un diccionario que mapee solo los estudiantes aprobados (calificación >= 60) a sus calificaciones convertidas a escala de 4.0 (calificación/25).

Pista: Usa comprensión de diccionarios con filtro if y aplica la fórmula de conversión en el valor.

Análisis de Texto con Comprensiones

INTERMEDIO

Descripción:

Dado un párrafo de texto, crear un conjunto con todas las palabras únicas que tengan más de 4 caracteres y no contengan números. Luego crear un diccionario que mapee cada palabra a su longitud.

Pista: Usa métodos de string como split(), isalpha() y len(). Combina comprensión de conjuntos y diccionarios.

Matriz de Correlación Simplificada

INTERMEDIO

Descripción:

Crear una matriz 5x5 donde cada elemento [i][j] sea la suma de i+j. Luego crear una lista con todos los elementos de la diagonal principal usando comprensión anidada.

Pista: Para la matriz usa comprensión anidada. Para la diagonal, recuerda que elementos diagonales tienen i==j.

Procesamiento de Log de Servidor

AVANZADO

Descripción:

Simula entradas de log como diccionarios con campos: timestamp, IP, status_code, response_time. Crea un diccionario que mapee cada IP única a la lista de sus tiempos de respuesta, pero solo para requests exitosos (status 200).

Pista: Primero filtra por status_code, luego agrupa por IP. Considera usar defaultdict o comprensión con condicional.

Resumen y Próximos Pasos

Las comprensiones de listas y diccionarios representan una herramienta fundamental en el arsenal de cualquier desarrollador Python profesional. Hemos explorado desde la sintaxis básica hasta casos de uso complejos que encontrarás en proyectos reales. La clave está en encontrar el equilibrio entre concisión y legibilidad, aplicando comprensiones donde mejoren tanto el rendimiento como la claridad del código. En el siguiente tema exploraremos generadores y expresiones generadoras, que extienden los conceptos de comprensiones hacia el manejo eficiente de memoria para grandes volúmenes de datos. Estas técnicas son especialmente relevantes en el contexto de big data y procesamiento de streams, completando tu formación en técnicas avanzadas de Python.

🏷️ Etiquetas:

python comprensiones listas diccionarios sintaxis avanzada programación funcional