Python Lambda

¿Qué es una función lambda?

Una función lambda es una función pequeña y anónima definida con la palabra clave lambda en lugar de def. Anónima significa que no tiene un nombre asignado, aunque puedes asignarla a una variable si necesitas reutilizarla. Las funciones lambda son una forma concisa de escribir funciones simples de una sola expresión en línea, sin la sobrecarga de una definición de función completa.

Las funciones lambda son especialmente útiles como callbacks de corta duración que se pasan a funciones de orden superior como map(), filter() y sorted().

Sintaxis

lambda arguments: expression

• arguments — cero o más parámetros separados por comas (igual que la lista de parámetros de una función def, incluyendo valores por defecto).
• expression — una única expresión cuyo valor se devuelve automáticamente. Las sentencias (como bloques if/else, bucles for o return) no están permitidas dentro del cuerpo de una lambda.

Una comparación válida lado a lado:

def square(x):
    return x ** 2

square_lambda = lambda x: x ** 2

print(square(5))        # Output: 25
print(square_lambda(5)) # Output: 25

Ejemplos básicos

# No arguments
greet = lambda: "Hello, World!"
print(greet())  # Output: Hello, World!

# One argument
square = lambda x: x ** 2
print(square(5))  # Output: 25

# Two arguments
add = lambda x, y: x + y
print(add(10, 20))  # Output: 30

# Default argument value
greet_name = lambda name="World": "Hello, " + name + "!"
print(greet_name())          # Output: Hello, World!
print(greet_name("Alice"))   # Output: Hello, Alice!

Lógica condicional en una lambda

Dado que las lambdas deben ser una única expresión, no puedes usar una sentencia if/else. Sin embargo, puedes usar una expresión ternaria (condicional):

classify = lambda n: "positive" if n > 0 else ("zero" if n == 0 else "negative")

print(classify(5))   # Output: positive
print(classify(0))   # Output: zero
print(classify(-3))  # Output: negative

Las expresiones ternarias profundamente anidadas perjudican rápidamente la legibilidad — cambia a una función def regular cuando la lógica crezca.

Uso de lambda con map()

map(function, iterable) aplica una función a cada elemento de un iterable y devuelve un objeto map. Lambda encaja de forma natural como argumento de función.

nums = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, nums))
print(doubled)  # Output: [2, 4, 6, 8, 10]

La comprensión de lista equivalente suele preferirse por su legibilidad:

doubled = [x * 2 for x in nums]  # same result

Consulta Comprensión de listas para saber más sobre ese enfoque.

Uso de lambda con filter()

filter(function, iterable) conserva solo los elementos para los que la función devuelve True.

nums = [1, 2, 3, 4, 5]
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens)  # Output: [2, 4]

Uso de lambda con sorted()

El parámetro key de sorted() (y list.sort()) acepta un callable que devuelve el valor de comparación para cada elemento. Lambda hace que las claves de ordenación únicas sean concisas.

# Sort strings by length
words = ["banana", "apple", "cherry", "date"]
by_length = sorted(words, key=lambda s: len(s))
print(by_length)  # Output: ['date', 'apple', 'banana', 'cherry']

# Sort a list of tuples by the second element
pairs = [(1, "b"), (2, "a"), (3, "c")]
by_second = sorted(pairs, key=lambda p: p[1])
print(by_second)  # Output: [(2, 'a'), (1, 'b'), (3, 'c')]

Para más información sobre la ordenación de listas, consulta Ordenar listas.

Lambda invocada inmediatamente

Una lambda puede llamarse en el momento en que se define envolviéndola entre paréntesis y añadiendo los argumentos:

result = (lambda x, y: x + y)(3, 7)
print(result)  # Output: 10

Este patrón es poco común en código de producción, pero ocasionalmente resulta útil en scripts puntuales o pruebas rápidas.

Lambda almacenada en una estructura de datos

Como una lambda es un objeto de primera clase en Python, puedes almacenar lambdas en listas o diccionarios para construir tablas de despacho simples:

ops = {
    "add": lambda x, y: x + y,
    "sub": lambda x, y: x - y,
    "mul": lambda x, y: x * y,
}

print(ops["add"](3, 4))   # Output: 7
print(ops["sub"](10, 3))  # Output: 7
print(ops["mul"](2, 6))   # Output: 12

Lambda vs. def — ¿cuándo usar cada una?

La guía de estilo PEP 8 recomienda no asignar una lambda a un nombre de variable cuando un def sería más claro. Por ejemplo, es preferible usar def add(x, y): return x + y en lugar de add = lambda x, y: x + y cuando la función se encuentra en el ámbito del módulo.

Limitaciones principales

• Solo una expresión. Sin asignaciones, bucles ni lógica multilínea.
• Sin sentencias. print() es una llamada a función (válida), pero assert, raise o return son sentencias y no pueden aparecer en el cuerpo de una lambda.
• Sin anotaciones. Las anotaciones de tipo (x: int) no están permitidas en las listas de parámetros de una lambda.
• Más difícil de depurar. Los rastros de pila muestran <lambda> en lugar de un nombre de función significativo.
• No se puede serializar con pickle. El módulo estándar pickle no puede serializar objetos lambda, lo que es relevante al usar multiprocessing.

Relación con cierres y decoradores

Al igual que una función regular definida con def, una lambda captura las variables de su ámbito envolvente:

def make_multiplier(n):
    return lambda x: x * n   # 'n' is captured from the enclosing scope

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))  # Output: 10
print(triple(5))  # Output: 15

Para un análisis más profundo de cómo funcionan los cierres en Python, consulta Cierres en Python. Las funciones lambda también aparecen con frecuencia dentro de los Decoradores de Python como envoltorios ligeros. Para una visión completa de las definiciones de funciones, consulta Funciones de Python.

Práctica