functools.reduce()

La función reduce() del módulo functools representa una de las herramientas más potentes para la programación funcional en Python. Esta función permite aplicar de forma acumulativa una operación a los elementos de una secuencia, combinándolos en un único resultado.

El concepto detrás de reduce() es simple pero elegante: toma una función binaria (que acepta dos argumentos) y la aplica repetidamente a los elementos de una secuencia, acumulando los resultados parciales hasta obtener un único valor final.

Sintaxis básica

La sintaxis de reduce() es la siguiente:

from functools import reduce

resultado = reduce(función, secuencia, [valor_inicial])

Donde:

• función: Una función que toma dos argumentos y devuelve un valor.
• secuencia: Una colección de elementos (lista, tupla, etc.).
• valor_inicial: Un valor opcional que se usa como primer argumento en la primera llamada a la función.

Funcionamiento interno

Para entender cómo funciona reduce(), veamos paso a paso su ejecución:

1. Si se proporciona un valor_inicial, la función lo toma como primer argumento y el primer elemento de la secuencia como segundo.
2. Si no se proporciona un valor_inicial, toma los dos primeros elementos de la secuencia.
3. El resultado de esta operación se convierte en el primer argumento para la siguiente iteración, y el siguiente elemento de la secuencia es el segundo argumento.
4. Este proceso continúa hasta procesar todos los elementos.

Ejemplo básico: suma de números

Veamos un ejemplo sencillo para sumar todos los números de una lista:

from functools import reduce

numeros = [1, 2, 3, 4, 5]
suma = reduce(lambda x, y: x + y, numeros)
print(suma)  # Resultado: 15

Este código es equivalente a:

numeros = [1, 2, 3, 4, 5]
resultado = numeros[0]  # 1
for i in range(1, len(numeros)):
    resultado += numeros[i]
print(resultado)  # 15

Pero la versión con reduce() es más concisa y expresa mejor la intención de acumular valores.

Visualización del proceso

Para entender mejor cómo funciona reduce(), podemos visualizar el proceso de la suma anterior:

1. reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
2. Primera iteración: x=1, y=2 → resultado: 3
3. Segunda iteración: x=3, y=3 → resultado: 6
4. Tercera iteración: x=6, y=4 → resultado: 10
5. Cuarta iteración: x=10, y=5 → resultado: 15

Uso del valor inicial

El parámetro valor_inicial es opcional pero muy útil en muchos casos:

from functools import reduce

numeros = [1, 2, 3, 4, 5]
suma = reduce(lambda x, y: x + y, numeros, 10)
print(suma)  # Resultado: 25 (10 + 1 + 2 + 3 + 4 + 5)

En este caso, el proceso comienza con x=10 y y=1, en lugar de x=1 y y=2.

Casos de uso prácticos

Multiplicación de elementos

from functools import reduce

numeros = [1, 2, 3, 4, 5]
producto = reduce(lambda x, y: x * y, numeros)
print(producto)  # Resultado: 120 (1*2*3*4*5)

Encontrar el máximo valor

from functools import reduce

numeros = [23, 45, 12, 67, 8]
maximo = reduce(lambda x, y: x if x > y else y, numeros)
print(maximo)  # Resultado: 67

Concatenación de cadenas

from functools import reduce

palabras = ["Hola", " ", "mundo", " ", "Python"]
frase = reduce(lambda x, y: x + y, palabras)
print(frase)  # Resultado: "Hola mundo Python"

Aplanamiento de listas anidadas

from functools import reduce

listas_anidadas = [[1, 2], [3, 4], [5, 6]]
lista_plana = reduce(lambda x, y: x + y, listas_anidadas)
print(lista_plana)  # Resultado: [1, 2, 3, 4, 5, 6]

Manejo de secuencias vacías

Si intentamos usar reduce() con una secuencia vacía y sin valor inicial, obtendremos un error:

from functools import reduce

try:
    resultado = reduce(lambda x, y: x + y, [])
except TypeError as e:
    print(f"Error: {e}")
    # Resultado: Error: reduce() of empty sequence with no initial value

Para evitar este error, siempre es recomendable proporcionar un valor inicial cuando no estemos seguros de si la secuencia puede estar vacía:

from functools import reduce

resultado = reduce(lambda x, y: x + y, [], 0)
print(resultado)  # Resultado: 0

Combinación con otras funciones de orden superior

reduce() se puede combinar con map() y filter() para crear operaciones más complejas:

from functools import reduce

# Suma de los cuadrados de los números pares
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
suma_cuadrados_pares = reduce(
    lambda x, y: x + y,
    map(lambda x: x**2, filter(lambda x: x % 2 == 0, numeros))
)
print(suma_cuadrados_pares)  # Resultado: 220 (4 + 16 + 36 + 64 + 100)

Uso con funciones definidas

Aunque los ejemplos anteriores utilizan funciones lambda, también podemos usar funciones definidas normalmente:

from functools import reduce

def sumar(a, b):
    return a + b

numeros = [1, 2, 3, 4, 5]
suma = reduce(sumar, numeros)
print(suma)  # Resultado: 15

Consideraciones de rendimiento

Aunque reduce() es una herramienta poderosa, no siempre es la opción más eficiente. Para operaciones comunes como suma, multiplicación, máximo o mínimo, Python proporciona funciones integradas optimizadas:

numeros = [1, 2, 3, 4, 5]

# Usando reduce
from functools import reduce
suma_reduce = reduce(lambda x, y: x + y, numeros)

# Usando sum (más eficiente)
suma_builtin = sum(numeros)

print(suma_reduce == suma_builtin)  # True

Cuándo usar reduce()

reduce() es especialmente útil cuando:

1. Necesitas aplicar una operación acumulativa que no está disponible como función integrada.
2. Quieres transformar una secuencia en un valor de tipo diferente.
3. La operación de acumulación es compleja o personalizada.

Sin embargo, para operaciones simples como suma, multiplicación, máximo o mínimo, las funciones integradas de Python (sum(), max(), min()) suelen ser más legibles y eficientes.

Ejemplo avanzado: procesamiento de datos

Veamos un ejemplo más complejo donde reduce() muestra su verdadero potencial:

from functools import reduce

# Lista de transacciones (producto, cantidad, precio)
transacciones = [
    {"producto": "manzana", "cantidad": 3, "precio": 0.5},
    {"producto": "pera", "cantidad": 2, "precio": 0.8},
    {"producto": "manzana", "cantidad": 1, "precio": 0.5},
    {"producto": "naranja", "cantidad": 4, "precio": 0.7}
]

# Agrupar por producto y calcular el total
resultado = reduce(
    lambda acum, trans: {
        **acum,
        trans["producto"]: acum.get(trans["producto"], 0) + trans["cantidad"] * trans["precio"]
    },
    transacciones,
    {}
)

print(resultado)
# Resultado: {'manzana': 2.0, 'pera': 1.6, 'naranja': 2.8}

Este ejemplo muestra cómo reduce() puede transformar una lista de transacciones en un diccionario que agrupa los totales por producto, una operación que sería más verbosa con bucles tradicionales.

sum(), min() y max()

Python proporciona varias funciones integradas que permiten realizar operaciones de reducción y acumulación de forma sencilla y eficiente. Entre las más utilizadas se encuentran sum(), min() y max(), que nos permiten calcular la suma, el valor mínimo y el valor máximo de una colección de elementos respectivamente.

Estas funciones son alternativas más legibles y eficientes que implementar manualmente estas operaciones o utilizar functools.reduce() para casos comunes. Veamos cada una de ellas en detalle.

La función sum()

La función sum() calcula la suma de todos los elementos de un iterable (como listas, tuplas o conjuntos). Su sintaxis es simple:

sum(iterable, start=0)

Donde:

• iterable: La colección de elementos a sumar
• start: Un valor opcional que se añade al resultado (por defecto es 0)

Ejemplos básicos de sum()

Sumar todos los elementos de una lista:

numeros = [10, 20, 30, 40, 50]
total = sum(numeros)
print(total)  # Resultado: 150

Utilizando el parámetro start para añadir un valor inicial:

numeros = [1, 2, 3, 4, 5]
total = sum(numeros, 100)
print(total)  # Resultado: 115 (100 + 1 + 2 + 3 + 4 + 5)

Casos de uso prácticos de sum()

Calcular el promedio de una lista de números:

calificaciones = [85, 90, 78, 92, 88]
promedio = sum(calificaciones) / len(calificaciones)
print(f"Promedio: {promedio}")  # Resultado: Promedio: 86.6

Sumar valores de un diccionario:

carrito = {"manzanas": 2.5, "peras": 3.75, "uvas": 4.20}
total_compra = sum(carrito.values())
print(f"Total a pagar: {total_compra}")  # Resultado: Total a pagar: 10.45

Las funciones min() y max()

Las funciones min() y max() encuentran el valor mínimo y máximo respectivamente en un iterable. Su sintaxis básica es:

min(iterable, *[, key, default])
max(iterable, *[, key, default])

Donde:

• iterable: La colección de elementos
• key: Una función opcional que sirve como criterio de comparación
• default: Valor que se devuelve si el iterable está vacío

Ejemplos básicos de min() y max()

Encontrar el valor mínimo y máximo en una lista:

temperaturas = [22, 19, 24, 25, 18, 21]
temp_minima = min(temperaturas)
temp_maxima = max(temperaturas)
print(f"Temperatura mínima: {temp_minima}°C")  # Resultado: Temperatura mínima: 18°C
print(f"Temperatura máxima: {temp_maxima}°C")  # Resultado: Temperatura máxima: 25°C

Comparar cadenas (se comparan lexicográficamente):

palabras = ["python", "programación", "funcional", "iterables"]
palabra_mas_corta = min(palabras, key=len)
palabra_mas_larga = max(palabras, key=len)
print(f"Palabra más corta: {palabra_mas_corta}")  # Resultado: Palabra más corta: python
print(f"Palabra más larga: {palabra_mas_larga}")  # Resultado: Palabra más larga: programación

Uso del parámetro key

El parámetro key permite especificar una función que se aplicará a cada elemento antes de la comparación. Esto es extremadamente útil para personalizar el criterio de comparación:

estudiantes = [
    {"nombre": "Ana", "edad": 22, "promedio": 9.5},
    {"nombre": "Carlos", "edad": 20, "promedio": 8.7},
    {"nombre": "Elena", "edad": 25, "promedio": 9.2},
    {"nombre": "David", "edad": 19, "promedio": 9.8}
]

# Estudiante más joven
mas_joven = min(estudiantes, key=lambda x: x["edad"])
print(f"Estudiante más joven: {mas_joven['nombre']}, {mas_joven['edad']} años")
# Resultado: Estudiante más joven: David, 19 años

# Estudiante con mejor promedio
mejor_promedio = max(estudiantes, key=lambda x: x["promedio"])
print(f"Mejor promedio: {mejor_promedio['nombre']}, {mejor_promedio['promedio']}")
# Resultado: Mejor promedio: David, 9.8

Manejo de iterables vacíos

Si intentamos usar min() o max() con un iterable vacío, obtendremos un error ValueError. Para evitarlo, podemos usar el parámetro default:

lista_vacia = []

# Sin parámetro default
try:
    resultado = min(lista_vacia)
except ValueError as e:
    print(f"Error: {e}")  # Resultado: Error: min() arg is an empty sequence

# Con parámetro default
valor_minimo = min(lista_vacia, default="No hay elementos")
print(valor_minimo)  # Resultado: No hay elementos

Comparación con múltiples iterables

Tanto min() como max() pueden recibir múltiples argumentos posicionales en lugar de un solo iterable:

# Comparando valores individuales
menor = min(15, 7, 42, 23)
mayor = max(15, 7, 42, 23)
print(f"Menor: {menor}, Mayor: {mayor}")  # Resultado: Menor: 7, Mayor: 42

# Comparando múltiples iterables
lista1 = [1, 2, 3]
lista2 = [0, 5]
lista3 = [4]

# Encuentra la lista con el elemento mínimo más pequeño
lista_min = min(lista1, lista2, lista3, key=lambda x: min(x))
print(f"Lista con el mínimo más pequeño: {lista_min}")  # Resultado: [0, 5]

# Encuentra la lista con el elemento máximo más grande
lista_max = max(lista1, lista2, lista3, key=lambda x: max(x))
print(f"Lista con el máximo más grande: {lista_max}")  # Resultado: [0, 5]

Aplicaciones prácticas

Análisis de datos básico

datos_sensor = [22.5, 23.1, 19.8, 25.2, 22.7, 26.1, 24.5]

# Estadísticas básicas
minimo = min(datos_sensor)
maximo = max(datos_sensor)
promedio = sum(datos_sensor) / len(datos_sensor)
rango = maximo - minimo

print(f"Mínimo: {minimo}")      # Resultado: Mínimo: 19.8
print(f"Máximo: {maximo}")      # Resultado: Máximo: 26.1
print(f"Promedio: {promedio:.2f}")  # Resultado: Promedio: 23.41
print(f"Rango: {rango:.2f}")    # Resultado: Rango: 6.30

Encontrar elementos extremos en estructuras complejas

productos = [
    {"nombre": "Laptop", "precio": 1200, "stock": 5},
    {"nombre": "Teléfono", "precio": 800, "stock": 12},
    {"nombre": "Tablet", "precio": 350, "stock": 8},
    {"nombre": "Auriculares", "precio": 150, "stock": 20}
]

# Producto más caro
mas_caro = max(productos, key=lambda x: x["precio"])
print(f"Producto más caro: {mas_caro['nombre']}, ${mas_caro['precio']}")
# Resultado: Producto más caro: Laptop, $1200

# Producto con menos stock
menos_stock = min(productos, key=lambda x: x["stock"])
print(f"Producto con menos stock: {menos_stock['nombre']}, {menos_stock['stock']} unidades")
# Resultado: Producto con menos stock: Laptop, 5 unidades

# Valor total del inventario
valor_inventario = sum(p["precio"] * p["stock"] for p in productos)
print(f"Valor total del inventario: ${valor_inventario}")
# Resultado: Valor total del inventario: $17000

Combinando sum(), min() y max() con comprensiones

Las comprensiones de listas, diccionarios o generadores combinadas con estas funciones ofrecen soluciones elegantes:

texto = "Python es un lenguaje de programación versátil y poderoso"
palabras = texto.split()

# Longitud de la palabra más corta y más larga
longitud_min = len(min(palabras, key=len))
longitud_max = len(max(palabras, key=len))

print(f"Palabra más corta tiene {longitud_min} letras")  # Resultado: Palabra más corta tiene 2 letras
print(f"Palabra más larga tiene {longitud_max} letras")  # Resultado: Palabra más larga tiene 11 letras

# Suma de longitudes de todas las palabras
total_caracteres = sum(len(palabra) for palabra in palabras)
print(f"Total de caracteres: {total_caracteres}")  # Resultado: Total de caracteres: 49

Consideraciones de rendimiento

Las funciones sum(), min() y max() están implementadas en C y están altamente optimizadas, lo que las hace significativamente más rápidas que implementaciones equivalentes en Python puro:

import time

# Lista grande para pruebas
numeros_grandes = list(range(1000000))

# Medición con sum()
inicio = time.time()
resultado_sum = sum(numeros_grandes)
tiempo_sum = time.time() - inicio

# Medición con reduce
from functools import reduce
inicio = time.time()
resultado_reduce = reduce(lambda x, y: x + y, numeros_grandes)
tiempo_reduce = time.time() - inicio

print(f"sum(): {tiempo_sum:.6f} segundos")
print(f"reduce(): {tiempo_reduce:.6f} segundos")
print(f"sum() es aproximadamente {tiempo_reduce/tiempo_sum:.1f}x más rápido")

Por esta razón, siempre es preferible usar estas funciones integradas cuando sea posible, en lugar de implementar manualmente estas operaciones o usar functools.reduce() para estos casos específicos.

any(), all()

Las funciones any() y all() son herramientas fundamentales en Python para evaluar condiciones lógicas sobre colecciones de elementos. Estas funciones permiten determinar si alguno o todos los elementos de un iterable cumplen con una condición específica, lo que resulta extremadamente útil para validaciones y comprobaciones de datos.

Función any()

La función any() devuelve True si al menos uno de los elementos del iterable es evaluado como verdadero. Su sintaxis es simple:

any(iterable)

Donde iterable es cualquier objeto que pueda ser recorrido (listas, tuplas, conjuntos, etc.).

Comportamiento básico de any()

La función any() evalúa cada elemento del iterable según las reglas de veracidad de Python:

# Lista con valores mixtos
valores = [False, 0, "", None, 42, "Python"]
resultado = any(valores)
print(resultado)  # True (porque 42 y "Python" son verdaderos)

# Lista con todos los valores falsos
valores_falsos = [False, 0, "", None, [], {}]
resultado = any(valores_falsos)
print(resultado)  # False (ningún elemento es verdadero)

Si el iterable está vacío, any() devuelve False:

print(any([]))  # False

Casos de uso prácticos de any()

Verificar si algún número es par en una lista:

numeros = [1, 3, 5, 7, 9, 10]
hay_pares = any(num % 2 == 0 for num in numeros)
print(hay_pares)  # True (10 es par)

Comprobar si alguna cadena contiene una letra específica:

palabras = ["casa", "mesa", "libro", "ventana"]
contiene_i = any("i" in palabra for palabra in palabras)
print(contiene_i)  # True ("libro" contiene "i")

Validar si algún usuario tiene permisos de administrador:

usuarios = [
    {"nombre": "Ana", "admin": False},
    {"nombre": "Carlos", "admin": False},
    {"nombre": "Elena", "admin": True}
]

hay_admin = any(usuario["admin"] for usuario in usuarios)
print(hay_admin)  # True (Elena es administradora)

Función all()

La función all() devuelve True solo si todos los elementos del iterable son evaluados como verdaderos. Su sintaxis es:

all(iterable)

Comportamiento básico de all()

La función all() evalúa cada elemento según las reglas de veracidad de Python:

# Todos los valores son verdaderos
valores_verdaderos = [True, 42, "Python", [1, 2, 3]]
resultado = all(valores_verdaderos)
print(resultado)  # True

# Algunos valores son falsos
valores_mixtos = [True, 42, "", None]
resultado = all(valores_mixtos)
print(resultado)  # False (porque "" y None son falsos)

Si el iterable está vacío, all() devuelve True (esto puede parecer contraintuitivo, pero es coherente con la lógica matemática):

print(all([]))  # True

Casos de uso prácticos de all()

Verificar si todos los números son positivos:

numeros = [5, 12, 8, 3, 1]
todos_positivos = all(num > 0 for num in numeros)
print(todos_positivos)  # True

numeros = [5, 12, -8, 3, 1]
todos_positivos = all(num > 0 for num in numeros)
print(todos_positivos)  # False (-8 no es positivo)

Comprobar si todas las cadenas tienen una longitud mínima:

palabras = ["python", "programación", "funcional"]
longitud_minima = all(len(palabra) >= 6 for palabra in palabras)
print(longitud_minima)  # True (todas tienen al menos 6 caracteres)

Validar formularios o datos de entrada:

formulario = {
    "nombre": "Ana García",
    "email": "ana@ejemplo.com",
    "edad": 28,
    "acepta_terminos": True
}

campos_requeridos = ["nombre", "email", "edad", "acepta_terminos"]
formulario_valido = all(
    campo in formulario and formulario[campo] 
    for campo in campos_requeridos
)
print(formulario_valido)  # True (todos los campos existen y son verdaderos)

Combinando any() y all()

Estas funciones pueden combinarse para crear validaciones más complejas:

# Verificar si todos los estudiantes aprobaron al menos una asignatura
estudiantes = [
    {"nombre": "Ana", "notas": [7, 8, 5, 9]},
    {"nombre": "Carlos", "notas": [4, 5, 6, 3]},
    {"nombre": "Elena", "notas": [9, 8, 9, 7]}
]

todos_aprobaron_alguna = all(
    any(nota >= 5 for nota in estudiante["notas"])
    for estudiante in estudiantes
)
print(todos_aprobaron_alguna)  # True

Uso con operadores de comparación encadenados

Python permite encadenar operadores de comparación, lo que combina muy bien con all():

# Verificar si un número está en un rango
def en_rango(valor, minimo, maximo):
    return minimo <= valor <= maximo

# Equivalente usando all()
def en_rango_all(valor, minimo, maximo):
    return all([minimo <= valor, valor <= maximo])

print(en_rango(15, 10, 20))      # True
print(en_rango_all(15, 10, 20))  # True

Optimización con cortocircuito

Tanto any() como all() implementan evaluación de cortocircuito, lo que significa que dejan de evaluar elementos tan pronto como se determina el resultado:

• any() se detiene en cuanto encuentra un valor verdadero
• all() se detiene en cuanto encuentra un valor falso

Esto es especialmente útil cuando trabajamos con generadores o cuando las evaluaciones son costosas:

def es_primo(n):
    """Función costosa que verifica si un número es primo"""
    print(f"Verificando si {n} es primo...")
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

# any() con cortocircuito
print("Usando any():")
resultado = any(es_primo(n) for n in [4, 6, 8, 7, 9])
print(f"Resultado: {resultado}")
# Solo verifica hasta encontrar 7 (que es primo)

print("\nUsando all():")
resultado = all(es_primo(n) for n in [2, 3, 5, 4, 7])
print(f"Resultado: {resultado}")
# Solo verifica hasta encontrar 4 (que no es primo)

Aplicaciones en filtrado de datos

Las funciones any() y all() son excelentes para filtrar datos en conjuntos más grandes:

productos = [
    {"nombre": "Laptop", "precio": 1200, "stock": 5, "categorias": ["electrónica", "computación"]},
    {"nombre": "Teléfono", "precio": 800, "stock": 0, "categorias": ["electrónica", "móviles"]},
    {"nombre": "Teclado", "precio": 100, "stock": 15, "categorias": ["electrónica", "accesorios"]},
    {"nombre": "Monitor", "precio": 300, "stock": 8, "categorias": ["electrónica", "computación"]}
]

# Productos disponibles y con precio menor a 1000
disponibles_economicos = [
    p for p in productos 
    if all([p["stock"] > 0, p["precio"] < 1000])
]
print("Productos disponibles y económicos:")
for p in disponibles_economicos:
    print(f"- {p['nombre']}: ${p['precio']}")

# Productos que pertenecen a computación o accesorios
computacion_o_accesorios = [
    p for p in productos 
    if any(cat in ["computación", "accesorios"] for cat in p["categorias"])
]
print("\nProductos de computación o accesorios:")
for p in computacion_o_accesorios:
    print(f"- {p['nombre']}")

Validación de estructuras de datos

Estas funciones son ideales para validar estructuras de datos complejas:

def validar_producto(producto):
    """Valida que un producto tenga todos los campos requeridos y sea válido"""
    # Verificar campos requeridos
    campos_requeridos = ["id", "nombre", "precio", "stock"]
    tiene_campos = all(campo in producto for campo in campos_requeridos)
    
    # Verificar restricciones de valores
    if not tiene_campos:
        return False
    
    restricciones = [
        isinstance(producto["id"], int),
        len(producto["nombre"]) > 0,
        producto["precio"] > 0,
        producto["stock"] >= 0
    ]
    
    return all(restricciones)

# Ejemplos de uso
productos = [
    {"id": 1, "nombre": "Laptop", "precio": 1200, "stock": 5},
    {"id": 2, "nombre": "", "precio": 800, "stock": 10},
    {"id": "3", "nombre": "Teclado", "precio": 100, "stock": 15},
    {"id": 4, "nombre": "Monitor", "precio": -300, "stock": 8}
]

for i, producto in enumerate(productos):
    if validar_producto(producto):
        print(f"Producto {i+1}: Válido")
    else:
        print(f"Producto {i+1}: Inválido")

Comparación con operadores lógicos tradicionales

Aunque podríamos implementar funcionalidades similares con bucles y operadores lógicos, any() y all() ofrecen una sintaxis más concisa y expresiva:

numeros = [2, 4, 6, 8, 10]

# Verificar si todos son pares usando un bucle
todos_pares = True
for num in numeros:
    if num % 2 != 0:
        todos_pares = False
        break
print(f"Todos pares (bucle): {todos_pares}")

# Usando all()
todos_pares = all(num % 2 == 0 for num in numeros)
print(f"Todos pares (all): {todos_pares}")

# Verificar si alguno es mayor que 8 usando un bucle
alguno_mayor_8 = False
for num in numeros:
    if num > 8:
        alguno_mayor_8 = True
        break
print(f"Alguno mayor que 8 (bucle): {alguno_mayor_8}")

# Usando any()
alguno_mayor_8 = any(num > 8 for num in numeros)
print(f"Alguno mayor que 8 (any): {alguno_mayor_8}")

Uso con expresiones generadoras

Para mayor eficiencia, es recomendable usar expresiones generadoras en lugar de listas por comprensión cuando se trabaja con any() y all():

# Menos eficiente (crea una lista completa en memoria)
resultado1 = any([n % 2 == 0 for n in range(1000000)])

# Más eficiente (evalúa elementos uno a uno)
resultado2 = any(n % 2 == 0 for n in range(1000000))

La segunda versión es más eficiente en términos de memoria, especialmente para iterables grandes, ya que no crea una lista intermedia completa.