Cálculos perezosos — Python: Funciones

• Evaluación perezosa en expresiones lógicas
• Evaluación perezosa en colecciones
• Generadores en Python
• Resumen

Lazy Evaluation es una técnica que retrasa los cálculos hasta que realmente son necesarios. Esto ayuda a ahorrar memoria y procesar grandes volúmenes de datos sin cargarlos todos de una vez.

En Python, esta técnica se usa en varias funciones, como map(), filter() y range(), para optimizar el rendimiento.

Evaluación perezosa en expresiones lógicas

Muchos lenguajes de programación incluyen evaluación perezosa en expresiones lógicas.

⏬ Ejemplo en Python:

# True
True or print('message')

or evalúa de izquierda a derecha. Como el primer valor (True) ya es verdadero, no evalúa la segunda parte (print('mensaje')).

Esta optimización permite escribir código más eficiente, por ejemplo, verificando si un objeto no es None antes de acceder a sus métodos:

if obj and obj.metodo():
    ...

Si obj es None, la segunda parte nunca se ejecuta, evitando errores.

Evaluación perezosa en colecciones

Python tiene funciones que no devuelven los resultados de inmediato, sino que crean iteradores.

⏬ Ejemplo con reversed():

nums = [1, 2, 3, 4, 5]
reversed(nums) # <list_reverseiterator at 0x75e0455d73d0>

reversed(nums) no devuelve la lista invertida, sino un iterador, que genera los elementos cuando se necesitan.

Podemos recorrerlo con for:

for num in reversed(nums):
    print(num)

# => 5
# => 4
# => 3
# => 2
# => 1

Un iterador es un flujo de datos que produce elementos bajo demanda. Esto permite procesar grandes cantidades de datos sin cargar todo en memoria.

Para entender cómo funciona, veamos qué ocurre internamente:

it = iter(nums)

for num in it:
    print(num)
    if num == 3:
        break

# => 1
# => 2
# => 3

# Continúa desde donde quedó
for num in it:
    print(num)

# => 4
# => 5

Los iteradores avanzan en una sola dirección. Si detenemos la iteración, cuando volvamos a recorrerlo, continuará desde donde quedó.

Generadores en Python

Python permite crear funciones que actúan como iteradores personalizados, llamadas generadores.

⏬ Ejemplo de una función que genera cuadrados de números hasta n:

def gen_cuadrados_hasta(n):
    i = 1
    while i <= n:
        yield i ** 2
        i += 1

for num in gen_cuadrados_hasta(5):
    print(num)

# => 1
# => 4
# => 9
# => 16
# => 25

yield pausa la función y guarda su estado. Cuando el iterador solicita el siguiente valor, la función continúa desde donde quedó.

Los generadores permiten flujos de datos infinitos, ya que no almacenan todos los valores en memoria:

def gen_cuadrados():
    i = 1
    while True:
        yield i ** 2
        i += 1

result = []
for num in gen_cuadrados():
    result.append(num)
    if num > 100:
        break

print(result)
# => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121]

Solo generamos valores hasta que sean necesarios.

Resumen

• Lazy Evaluation permite diferir cálculos hasta que sean necesarios, optimizando el rendimiento.
• Se usa en expresiones lógicas, colecciones con iteradores y generadores.
• Es clave para trabajar con grandes volúmenes de datos o flujos infinitos sin gastar memoria innecesaria.

Este concepto es fundamental en Big Data, procesamiento de streams y programación funcional.

Materiales adicionales

1. Evaluación perezosa 📚 Wikipedia