Comprensión de listas en Python: una guía para principiantes

¿Qué son las comprensiones de lista?

La comprensión de listas es una forma compacta de crear una nueva lista basada en una secuencia existente o en un objeto iterable. En lugar de escribir varias líneas con bucles, puedes expresar la misma lógica en una sola línea.

Sintaxis básica

La estructura básica de la comprensión de listas es la siguiente:

новый_список = [выражение for элемент in последовательность]

Ejemplo: enfoque tradicional vs. comprensión de listas

Vamos a crear una lista de cuadrados de números del 0 al 9.

Enfoque tradicional:

squares = []
for i in range(10):
    squares.append(i ** 2)
print(squares)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Con comprensión de lista:

squares = [i ** 2 for i in range(10)]
print(squares)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

El resultado es el mismo, pero la segunda opción es más corta y se lee casi como una oración normal: "crea una lista de cuadrados i para cada i en el rango de 0 a 9".

Añadimos condiciones

Puedes filtrar los elementos añadiendo una condición al final:

новый_список = [выражение for элемент in последовательность if условие]

Ejemplos con condiciones

Solo números pares:

evens = [i for i in range(20) if i % 2 == 0]
print(evens)
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Cuadrados de números impares:

odd_squares = [i ** 2 for i in range(10) if i % 2 != 0]
print(odd_squares)
# [1, 9, 25, 49, 81]

Filtrado de filas:

words = ["apple", "banana", "cherry", "date", "elderberry"]
long_words = [word for word in words if len(word) > 5]
print(long_words)
# ['banana', 'cherry', 'elderberry']

Trabajar con líneas

Las comprensiones de lista son excelentes para el procesamiento de cadenas.

Conversión a mayúsculas:

names = ["anna", "bob", "charlie"]
upper_names = [name.upper() for name in names]
print(upper_names)
# ['ANNA', 'BOB', 'CHARLIE']

Extracción de las primeras letras:

words = ["Python", "is", "awesome"]
first_letters = [word[0] for word in words]
print(first_letters)
# ['P', 'i', 'a']

Ciclos anidados

Las comprensiones de lista admiten bucles anidados para trabajar con datos multidimensionales.

Creación de pares de coordenadas:

coordinates = [(x, y) for x in range(3) for y in range(3)]
print(coordinates)
# [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

Multiplicación de elementos de dos listas:

list1 = [1, 2, 3]
list2 = [10, 20, 30]
products = [x * y for x in list1 for y in list2]
print(products)
# [10, 20, 30, 20, 40, 60, 30, 60, 90]

Operador condicional if-else

Puedes usar el operador ternario para una lógica más compleja:

новый_список = [выражение_if if условие else выражение_else for элемент in последовательность]

Ejemplo: reemplazamos los pares por "par", los impares los dejamos como están:

numbers = [1, 2, 3, 4, 5, 6]
result = ["even" if n % 2 == 0 else n for n in numbers]
print(result)
# [1, 'par', 3, 'par', 5, 'par']

Ejemplos prácticos

Trabajar con diccionarios

Extracción de valores:

prices = {"apple": 50, "banana": 30, "cherry": 80}
expensive = [fruit for fruit, price in prices.items() if price > 40]
print(expensive)
# ['apple', 'cherry']

Procesamiento de archivos

Lectura y filtrado de líneas:

# Supongamos que tenemos un archivo con el texto
lines = ["  hello  ", "world", "  Python  ", ""]
cleaned = [line.strip() for line in lines if line.strip()]
print(cleaned)
# ['hello', 'world', 'Python']

Operaciones matemáticas

Aplicación de la función a todos los elementos:

import math
numbers = [4, 9, 16, 25]
roots = [math.sqrt(n) for n in numbers]
print(roots)
# [2.0, 3.0, 4.0, 5.0]

Cuándo NO usar comprensiones de lista

A pesar de su elegancia, hay situaciones en las que son preferibles los ciclos tradicionales:

1. Lógica compleja: si la expresión se vuelve demasiado larga y difícil de leer

2. Efectos secundarios: Las comprensiones de lista están diseñadas para crear listas, no para realizar acciones

3. Anidamiento profundo: más de dos bucles anidados hacen que el código sea ilegible

Mal ejemplo (demasiado complejo):

# ¡No lo hagas!
result = [x * y if x % 2 == 0 else x + y for x in range(10) if x > 5 for y in range(10) if y % 3 == 0]

Es mejor dividirlo en varias líneas con bucles regulares.

Otros tipos de comprensión

Python no solo admite comprensiones de listas:

Dictionary comprehension:

squares_dict = {x: x ** 2 for x in range(5)}
print(squares_dict)
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Set comprehension:

unique_squares = {x ** 2 for x in [1, 2, 2, 3, 3, 4]}
print(unique_squares)
# {1, 4, 9, 16}

Expresión del generador (para ahorrar memoria):

squares_gen = (x ** 2 for x in range(1000000))
# Crea un generador, no una lista, ahorrando memoria

Productividad

Las comprensiones de lista suelen funcionar más rápido que los bucles equivalentes con append() porque están optimizadas a nivel del intérprete de Python.

Conclusión

Las comprensiones de listas son una herramienta poderosa que hace que tu código Python sea más elegante y legible. Comienza con ejemplos sencillos, practica con tareas reales y, con el tiempo, las usarás de forma natural y eficaz.

Puntos clave para recordar:

• Las comprensiones de lista hacen que el código sea más corto y expresivo

• Se pueden añadir condiciones para el filtrado

• Ciclos anidados compatibles

• No abuses de la complejidad: la legibilidad es más importante que la brevedad

• También existen dict, set comprehensions y generator expressions

¡Practica, experimenta y las comprensiones de listas se convertirán en una parte natural de tu estilo de programación en Python!

Únete a Kodik — ¡nuestra aplicación de aprendizaje para desarrolladores! Tenemos comunidad amigable en el canal de Telegram, donde los programadores principiantes y experimentados comparten sus conocimientos, se ayudan mutuamente con las tareas y discuten las nuevas tecnologías. ¡Aprende con nosotros!