Funciones lambda en Python: cuándo usarlas (y cuándo no)

Intermedio20 min5 ejercicios70 XP

Esta lección es una traducción del original en inglés.Read in English Avisar de un error de traducción

Antes de empezar

Funciones en Python: definir, llamar y devolver valores

0/5 ejercicios

Imagina que tienes que dejarle a alguien una nota rápida: "Vuelvo en 5 minutos". No escribirías una carta formal con saludo, tres párrafos y firma. La apuntarías en una nota adhesiva y listo.

Las funciones lambda son las notas adhesivas de Python. Son funciones diminutas, anónimas y desechables, para cuando necesitas algo rápido de una sola línea y un bloque def completo sería demasiado.

En este tutorial aprenderás a escribir funciones lambda, dónde brillan (ordenar, filtrar, transformar) y, algo igual de importante, cuándo conviene dejarlas de lado y usar una función normal.

Cómo escribir una función lambda

Una función lambda se crea con la palabra clave lambda, seguida de los parámetros, dos puntos y una sola expresión. Esa expresión se devuelve automáticamente, sin necesidad de la palabra clave return.

Lambda frente a def: el mismo resultado

# Regular function

def double(x):

return x * 2

# Same thing as a lambda

double_lambda = lambda x: x * 2

print(double(5))

print(double_lambda(5))

Salida

10
10

La sintaxis es: lambda parameters: expression. No hay nombre de función (por eso se llaman "anónimas"), ni def, ni return, ni un cuerpo de varias líneas. Solo una expresión que se evalúa y se devuelve.

Las lambdas pueden recibir varios parámetros, igual que las funciones normales:

Lambda con varios parámetros

add = lambda a, b: a + b

print(add(3, 7))

full_name = lambda first, last: first + ' ' + last

print(full_name('Ada', 'Lovelace'))

Salida

10
Ada Lovelace

Usar lambda con sorted()

El uso más común de las funciones lambda es como argumento key de sorted(). El parámetro key le dice a Python: "antes de comparar los elementos, transforma cada uno con esta función".

Ordenar sin distinguir mayúsculas de minúsculas con lambda

names = ['Charlie', 'alice', 'Bob']

# Default sort is case-sensitive (uppercase first)

print(sorted(names))

# Sort by lowercase version (case-insensitive)

print(sorted(names, key=lambda name: name.lower()))

Salida

['Bob', 'Charlie', 'alice']
['alice', 'Bob', 'Charlie']

La lambda lambda name: name.lower() le indica a sorted() que compare la versión en minúsculas de cada cadena. Las cadenas originales no cambian: la lambda solo afecta a la comparación.

Las lambdas son especialmente útiles para ordenar datos complejos, como listas de tuplas o de diccionarios:

Ordenar tuplas por el segundo elemento

students = [

('Alice', 88),

('Bob', 95),

('Charlie', 72),

('Diana', 91),

]

# Sort by grade (second element)

by_grade = sorted(students, key=lambda s: s[1])

for name, grade in by_grade:

print(name + ': ' + str(grade))

Salida

Charlie: 72
Alice: 88
Diana: 91
Bob: 95

Ordenar diccionarios por un campo

products = [

{'name': 'Laptop', 'price': 999},

{'name': 'Mouse', 'price': 25},

{'name': 'Keyboard', 'price': 75},

]

# Sort by price, cheapest first

by_price = sorted(products, key=lambda p: p['price'])

for item in by_price:

print(item['name'] + ': $' + str(item['price']))

Salida

Mouse: $25
Keyboard: $75
Laptop: $999

Usar lambda con map() y filter()

map() aplica una función a cada elemento de una lista y te devuelve los resultados transformados. filter() conserva solo los elementos para los que la función devuelve True. Las dos reciben una función como primer argumento: el lugar perfecto para una lambda.

map() y filter() con lambdas

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

# Double every number

doubled = list(map(lambda x: x * 2, numbers))

print(doubled)

# Keep only even numbers

evens = list(filter(lambda x: x % 2 == 0, numbers))

print(evens)

Salida

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

Envolvemos map() y filter() en list() porque devuelven iteradores perezosos (lazy), no listas. La llamada a list() los obliga a producir todos los resultados de una vez.

Aquí tienes un ejemplo más práctico, en el que se extraen y filtran datos:

map y filter en la práctica

prices = [10.50, 23.99, 5.00, 45.00, 12.75]

# Add 10% tax to each price

with_tax = list(map(lambda p: round(p * 1.1, 2), prices))

print(with_tax)

# Filter prices over $20

expensive = list(filter(lambda p: p > 20, prices))

print(expensive)

Salida

[11.55, 26.39, 5.5, 49.5, 14.03]
[23.99, 45.0]

Lambda con map/filter

doubled = list(map(
    lambda x: x * 2, numbers
))
evens = list(filter(
    lambda x: x % 2 == 0, numbers
))

Comprensión de listas (suele preferirse)

doubled = [x * 2 for x in numbers]

evens = [x for x in numbers
         if x % 2 == 0]

Lambda frente a def: cuándo usar cada una

Las lambdas son tentadoras porque parecen ingeniosas y compactas. Pero tienen limitaciones reales. Así puedes decidir cuál usar:

Usa lambda cuando:

Necesitas una función diminuta para un argumento key=, map() o filter()

La lógica cabe en una expresión sencilla

No vas a reutilizar la función en otro sitio

Usa `def` cuando:

La lógica necesita más de una expresión

Necesitas instrucciones if/else, bucles o manejo de errores

Quieres un nombre descriptivo que documente lo que hace

Vas a reutilizar la función en varios lugares

Lógica de ordenación sencilla frente a compleja

# Lambda: fine for simple key functions

words = ['banana', 'apple', 'cherry']

print(sorted(words, key=lambda w: len(w)))

# def: better when logic is complex

def sort_key(word):

'''Sort by length, then alphabetically.'''

return (len(word), word)

print(sorted(words, key=sort_key))

Salida

['apple', 'banana', 'cherry']
['apple', 'banana', 'cherry']

Patrones comunes con lambda

Estos son algunos patrones que verás en código Python real. Reconocerlos te ayudará a leer el código de otras personas y a saber cuándo una lambda es la herramienta adecuada.

Patrón: ordenar una lista de diccionarios

# Pattern 1: Sort by dictionary key

people = [{'name': 'Zara', 'age': 22}, {'name': 'Alex', 'age': 30}]

by_name = sorted(people, key=lambda p: p['name'])

for p in by_name:

print(p['name'] + ': ' + str(p['age']))

Salida

Alex: 30
Zara: 22

Patrón: lambda condicional

# Pattern 2: Conditional expression in lambda

classify = lambda x: 'even' if x % 2 == 0 else 'odd'

print(classify(4))

print(classify(7))

Salida

even
odd

Patrón: max/min con key

# Pattern 3: Using max/min with a key

words = ['python', 'is', 'awesome']

longest = max(words, key=lambda w: len(w))

print(longest)

shortest = min(words, key=lambda w: len(w))

print(shortest)

Salida

awesome
is

Ejercicios de práctica

Predice la salida de la lambda

Predice la salida

¿Qué imprime este código? Escribe la salida exacta.

operation = lambda a, b: a * b + 1
print(operation(3, 4))
print(operation(0, 10))

operation = lambda a, b: a * b + 1

print(operation(3, 4))

print(operation(0, 10))

Ordenar por el último carácter

Escribe el código

Dada una lista de palabras, usa sorted() con una lambda para ordenarlas por su último carácter. Imprime la lista ordenada que obtienes.

Usa esta lista: words = ['hello', 'world', 'python', 'code']

Salida esperada: ['world', 'code', 'python', 'hello']

words = ['hello', 'world', 'python', 'code']

# Sort by last character and print

Filtrar y transformar

Escribe el código

Dada una lista de números, usa filter() con una lambda para quedarte solo con los números mayores que 10 y después usa map() con una lambda para elevar al cuadrado cada número restante. Imprime la lista final.

Usa esta lista: numbers = [3, 15, 7, 20, 8, 12]

Salida esperada: [225, 400, 144]

numbers = [3, 15, 7, 20, 8, 12]

# Filter numbers > 10, then square them

Ordenar estudiantes por promedio

Escribe el código

Dada una lista de tuplas de estudiantes (name, gpa), ordénalas por promedio de mayor a menor usando sorted() con una lambda. Imprime cada estudiante en una línea aparte con el formato name: gpa.

Usa esta lista:

students = [('Alice', 3.5), ('Bob', 3.9), ('Charlie', 3.2), ('Diana', 3.7)]

Salida esperada:

Bob: 3.9
Diana: 3.7
Alice: 3.5
Charlie: 3.2

students = [('Alice', 3.5), ('Bob', 3.9), ('Charlie', 3.2), ('Diana', 3.7)]

# Sort by GPA (highest first) and print

Clasificar palabras por longitud

Escribe el código

Dada una lista de palabras, usa sorted() con una lambda para ordenarlas por longitud (las más cortas primero). Si dos palabras tienen la misma longitud, deben aparecer en orden alfabético. Imprime la lista ordenada.

Usa esta lista: words = ['fig', 'apple', 'date', 'kiwi', 'banana', 'pear', 'plum']

Salida esperada: ['fig', 'date', 'kiwi', 'pear', 'plum', 'apple', 'banana']

words = ['fig', 'apple', 'date', 'kiwi', 'banana', 'pear', 'plum']

# Sort by length, then alphabetically

Cómo escribir una función lambda

Usar lambda con sorted()

Usar lambda con map() y filter()

Lambda frente a def: cuándo usar cada una

Patrones comunes con lambda

Ejercicios de práctica

Tutoriales relacionados