Saltar al contenido principal

Funciones lambda de Python: Guía para principiantes

Conoce las funciones lambda de Python, su finalidad y cuándo utilizarlas. Incluye ejemplos prácticos y buenas prácticas para una aplicación eficaz.
Actualizado 31 ene 2025  · 10 min de lectura

Las funciones lambda en Python son herramientas potentes y concisas para crear pequeñas funciones anónimas sobre la marcha. Son perfectas para simplificar tareas a corto plazo, agilizar el código con funciones de orden superior como map, filter, o sorted, y reducir el desorden al definir lógica temporal o desechable. También ofrecen una solución elegante para mejorar la legibilidad del código en situaciones sencillas. Este artículo explorará qué son las funciones lambda, sus características y cómo utilizarlas eficazmente.

En esta guía, proporcionaremos una guía completa de las funciones lambda en Python, cubriendo su mecánica, sintaxis y cómo se comparan con las funciones estándar, con ejemplos sencillos para ilustrar los conceptos clave.Exploramos casos de uso comunes, como el uso de funciones lambda dentro de paradigmas de programación funcional y su eficiencia en relación con las funciones estándar.... Se incluyen ejemplos prácticos y las mejores prácticas para ayudarte a incorporar eficazmente las funciones lambda en tu programación en Python.

¿Qué es una función lambda en Python?

Las funciones lambda difieren de las funciones estándar de Python en varios aspectos clave. Son expresiones anónimas, lo que significa que no tienen nombre a menos que se asignen explícitamente a una variable. También son más concisos y se definen en una sola línea sin necesidad de una declaración return. Esto las hace ideales para operaciones sencillas de una sola vez y para utilizarlas como argumentos en línea en funciones de orden superior como map, filter y sorted.

Aquí tienes un ejemplo de función lambda que suma dos números:

lambda x, y: x + y

    (x, y)>

Cómo funcionan las funciones lambda

¿Cómo funciona esta función lambda? Para entenderlo, comparémoslo con una función estándar de Python.

# Example: add two numbers using standard Python function
def add_numbers(x, y):
    return x + y

Esta función estándar es sencilla. La palabra clave def define la función, que toma dos argumentos, x y y. Calcula la suma de x y y y devuelve el resultado.

Ahora, veamos cómo nuestra función lambda consigue la misma tarea.

# Example: add two numbers using a lambda function
lambda x, y: x + y

    (x, y)>

La palabra clave lambda significa que estamos definiendo una función lambda, eliminando la necesidad de la palabra clave def. Tras esta palabra clave lambda, se enumeran los argumentos de entrada x y y. Después de los dos puntos, especificamos la expresión cuyo resultado se devolverá, x + y.

Escribir funciones lambda en Python: Ejemplos

Para ayudarte a familiarizarte con los conceptos que hemos explorado hasta ahora, veamos algunos ejemplos de cómo funcionan las funciones lambda en Python. 

Guía paso a paso para escribir funciones lambda

Las funciones lambda son ideales para crear funciones cortas y sencillas sin complejidad adicional. 

Por ejemplo, supongamos que quieres comprobar si un número entero distinto de cero es par. Podrías escribir una función estándar de Python, pero se puede conseguir la misma funcionalidad con una función lambda concisa de una sola línea asignada a una variable: is_even = lambda x: x % 2 == 0

Aquí, la función lambda de la parte derecha de la asignación toma una entrada x y devuelve True si x es par (es decir, si el resto al dividirlo por 2 es 0). 

A continuación, esta función lambda se asigna a la variable is_even, lo que permite llamarla como a una función normal. Por ejemplo, is_even(5) (devuelve False) y is_even(678432) (devuelve True).

Las funciones lambda también son estupendas para definir fórmulas sencillas. Por ejemplo, para convertir Celsius a Fahrenheit, podrías utilizar una función lambda: c_to_f = lambda c: (c * 9/5) + 32. Luego llamas a la función como a cualquier otra función: c_to_f(0).

Casos de uso habituales de las funciones lambda

Las funciones lambda se utilizan a menudo en programación funcionalsobre todo con funciones como map() y filter(), que toman otras funciones como argumentos para procesar elementos de una colección. Veamos cómo utilizar una función lambda con filter(). Aquí tienes un fragmento de código:

# Use filter with lambda function
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # print the list of the filter object to see the result

    [2, 4, 6, 8]

En este código, empezamos definiendo un conjunto de numbers. A continuación, creamos una función lambda para comprobar si un número es par. La función filter aplica esta función lambda al conjunto numbers. A continuación, imprimimos la lista de números pares identificados por la función filter.

Del mismo modo, podemos utilizar la función map para aplicar una lambda a una colección de elementos. En el ejemplo siguiente, calculamos las longitudes de las cadenas de una lista asignando la función len() a cada elemento.

# Use map with lambda function
fruits = ['apple', 'banana', 'cherry']
lengths = list(map(lambda x: len(x), fruits))
print(lengths)

    [5, 6, 6]

La función lambda también se utiliza con la función sorted(), que ordena los elementos de una colección para devolver una nueva colección. En el siguiente ejemplo (sin lambda), utilizamos la función sorted() para ordenar una lista de números.

numbers = [1, 10, -1, 3, -10, 5]
sorted_stuff = sorted(numbers)
print(sorted_stuff)

    [-10, -1, 1, 3, 5, 10]

Supongamos que queremos ordenar la lista de números por su valor absoluto. ¿Cómo lo conseguiríamos? La función sorted() incluye un argumento key que nos permite personalizar el orden de clasificación proporcionando una función lambda.

# Sort according to absolute value
sorted_numbers_absolute = sorted(numbers, key=lambda x: abs(x))
print(sorted_numbers_absolute)

    [1, -1, 3, 5, 10, -10]

Otro caso de uso de sort() con una función lambda es ordenar una lista de tuplas basándose en un elemento concreto, digamos el segundo.

# Sort a list of tuples by the second element
data = [(1, 3), (2, 1), (4, 2)]
sorted_data = sorted(data, key=lambda x: x[1])
print(sorted_data)

    [(2, 1), (4, 2), (1, 3)]

En este fragmento de código, definimos data como una lista de tuplas. A continuación, utilizamos la función sorted() con el parámetro key, donde una función lambda extrae el segundo elemento de cada tupla para ordenarlo.

¿Son más rápidas las funciones lambda en Python?

En Python, las funciones lambda no son intrínsecamente más rápidas que las funciones estándar, ya que ambas se compilan a bytecode similar. Sin embargo, pueden reducir ligeramente la sobrecarga en los casos en que la definición de una función completa añadiría una repetición innecesaria.

Aquí tienes algunos casos de prueba que comparan las funciones lambda con las funciones estándar de Python. El código se ejecutó en mi portátil, un MacBook Pro con un chip Apple M1 Pro, 16 GB de memoria y ejecutando macOS Sequoia 15.2.

Las funciones lambda pueden utilizarse en línea como funciones anónimas cuando se pasan directamente a funciones de orden superior como map(), filter() o sorted(). Esto evita la necesidad de definir y referenciar una función con nombre separada, reduciendo tanto el código repetitivo como la sobrecarga de búsqueda.

import time

numbers = list(range(1, 1000000))

# Standard function
def double_standard(x):
    return x * 2

start = time.time()
map(double_standard, numbers)
print(time.time() - start)

# Lambda function
double_lambda = map(lambda x: x * 2, numbers)

start = time.time()
list(map(lambda x: x * 2, numbers))
print(time.time() - start)

    3.504753112792969e-05

    2.384185791015625e-05

Las funciones lambda son ideales para un uso puntual o temporal, ya que eliminan la necesidad de un bloque formal def, ahorrando tiempo y espacio. En el siguiente bloque de código, comparamos el rendimiento de una función estándar con el de una función lambda. Ordenamos un diccionario con un millón de elementos, donde las claves son códigos aleatorios de dos letras, y los valores son números enteros aleatorios.

import random
import string

# Generate a dictionary with elements of the form 'XX': number.
NUMBER_ITEMS = 1000000
items = {
    ''.join(random.choices(string.ascii_uppercase, k=2)): random.randint(1, 100)
    for _ in range(NUMBER_ITEMS)
}

# Standard function (extra definition step)
def sort_standard(item):
    return item[1]

print('Standard')
start = time.time()
sorted_items_standard = sorted(items, key=sort_standard)
print(time.time() - start)
print(sorted_items_standard[:5])
print()

# Lambda function
print('Lambda')
start = time.time()
sorted_items_lambda = sorted(items, key=lambda x: x[1])
print(time.time() - start)
print(sorted_items_lambda[:5])
print()

    Standard

    0.00011610984802246094

    ['OA', 'VA', 'XA', 'IA', 'BA']

    

    Lambda

    0.00011014938354492188

    ['OA', 'VA', 'XA', 'IA', 'BA']

Funciones lambda de Python: Ejemplos y práctica

Veamos algunos ejemplos más prácticos para mostrar cómo funcionan las funciones lambda en Python. 

Ejemplos prácticos

Las funciones lambda se utilizan a menudo con los métodos incorporados de Python. Por ejemplo, veamos cómo utilizar reduce() para aplicar acumulativamente una función binaria definida por el usuario a los elementos de una secuencia.

# Example: Use lambda function with built-in Python method reduce.
from functools import reduce

numbers = [5, -6, 2, 7]
total = reduce(lambda x, y: x + y, numbers)
print(f'The sum of the numbers is {total}.')

    The sum of the numbers is 8.

De forma similar a filter() o map(), reduce() aplica una función, aquí dada por una lambda, a un conjunto de elementos.

Ahora, vamos a explorar otra función incorporada de Python, zip(). La función zip empareja los elementos correspondientes de varias listas en tuplas. Por ejemplo, el resultado de zip(['a', 'b', 'c'], [1, 2, 3]) es [('a', 1), ('b', 2), ('c', 3)].

# Example: Use lambda function with built-in Python method zip.
list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Using zip and a lambda function to multiply corresponding elements
result = list(map(lambda x: x[0] * x[1], zip(list1, list2)))

print(f'The result of multiplying corresponding elements is {result}.')

El resultado de multiplicar los elementos correspondientes es [4, 10, 18].

Este código calcula el producto de los elementos correspondientes de dos listas, list1 y list2. Utiliza zip() para emparejar los elementos de las listas en tuplas, luego aplica una función lambda con map() para multiplicar los elementos emparejados y, por último, convierte el resultado en una lista.

Ejemplo real: transformación de datos

Imaginemos que tienes un puesto de fruta y quieres calcular el importe total de las ventas de cada tipo de fruta.

En primer lugar, vamos a crear algunos registros de ventas.

# Sample data: list of dictionaries representing sales records
sales_data = [
    {'fruit': 'peaches', 'price': 1.41, 'quantity': 3},
    {'fruit': 'pears', 'price': 1.21, 'quantity': 2},
    {'fruit': 'mangoes', 'price': 0.56, 'quantity': 3},
]

Ahora, utilizamos map() con una función lambda para calcular total_sales multiplicando el precio y la cantidad de cada artículo del diccionario sales_data. La sintaxis **record desempaqueta el diccionario original, asegurándose de que todas sus claves y valores se conservan en el nuevo diccionario.

# Using a lambda function to calculate total sales for each record
transformed_data = list(
                        map(
                            lambda entry: {**entry, 'total_sales': round(entry['price'] * entry['quantity'], 2)},
                            sales_data
                        )
                    )

Por último, imprimimos cada registro de los datos transformados.

# Print the transformed data
for record in transformed_data:
    print(record)

    {'fruit': 'peaches', 'price': 1.41, 'quantity': 3, 'total_sales': 4.23}

    {'fruit': 'pears', 'price': 1.21, 'quantity': 2, 'total_sales': 2.42}

    {'fruit': 'mangoes', 'price': 0.56, 'quantity': 3, 'total_sales': 1.68}

Problemas sencillos para que los usuarios los resuelvan con funciones lambda

Si quieres practicar el uso de las funciones lambda, aquí tienes algunos problemas que puedes probar.

  • Dado un número, halla su cuadrado.
  • Dados dos números, halla el mayor.
  • Dado un número, comprueba si es impar.
  • Dada una lista de números enteros positivos, filtra todos los números impares.
  • Ordena una lista de tuplas de 3 elementos utilizando sus terceros elementos.
  • Extrae el dominio de una dirección de correo electrónico. Por ejemplo, dado user@example.com, extrae example.com.

Errores comunes relacionados con lambda

Veamos algunos errores comunes que cometen los programadores con las lambdas y algunas soluciones.

1. El primer error es utilizar una función lambda cuando no es apropiado. Es importante recordar que las funciones lambda están diseñadas para tareas cortas y sencillas, no para manejar lógica compleja. Por ejemplo, el siguiente fragmento de código no es un caso de uso ideal para una función lambda.

# Complex logic in a lambda
result = lambda x: (x ** 2 + x - 1) / (x + 1 if x != -1 else 1)
print(result(5))  # Hard to understand

    4.833333333333333

En este caso, es mejor utilizar una función estándar de Python.

def complex_logic(x):
    if x == -1:
        return x ** 2 + x - 1
    return (x ** 2 + x - 1) / (x + 1)
print(complex_logic(5))

    4.833333333333333

2. Otro error sencillo es confundir la sintaxis. Por ejemplo, si olvidas la palabra clave lambda, se producirá un error. Otro error sintáctico común es omitir el argumento o argumentos de entrada:

# Forgetting the required arguments
numbers = [1, 2, 3, 4]
squared = map(lambda: x ** 2, numbers)  # <-- Where is the input argument? Error: lambda missing argument

La solución es incluir el argumento de entrada:

squared = map(lambda x: x ** 2, numbers)

Una buena forma de detectar errores como éste es incluir casos de prueba informales y sencillos al desarrollar.

print(list(squared))

    [1, 4, 9, 16]

3. Otro error con el que hay que tener cuidado es no incluir la lógica para los casos límite. Por ejemplo, este código falla cuando y es 0.

# Dividing without handling zero
divide = lambda x, y: x / y

La solución es incluir una simple sentencia if para atrapar el caso infractor o envolver el código en un bloque de excepción.

safe_divide = lambda x, y: x / y if y != 0 else "undefined"
print(safe_divide(5, 0))

    undefined

4. Un problema más sutil es olvidar convertir el iterador en una lista al emitir los resultados. Por ejemplo, la función map() devuelve un objeto map, no una lista.

# Forgetting to convert to a list
numbers = [1, 2, 3]
squared = map(lambda x: x ** 2, numbers)
print(squared)  # <-- squared is the map, not the result

    

Para acceder a los resultados, convierte el objeto map en un list.

print(list(squared))  # list(squared) gives the result

    [1, 4, 9]

Estrategias de depuración de lambda de Python

Entonces, ¿cómo depuramos las lambdas? Aquí tienes algunas posibilidades.

  • Descomponer la lambda. Conviértela temporalmente en una función con nombre a efectos de depuración.
  • Utiliza sentencias print para mostrar valores intermedios en funciones de orden superior como map() o filter().
  • Probar casos límite. Prueba con valores extremos, no válidos o límite para detectar posibles errores.

Un truco útil para imprimir los pasos intermedios es incluir una sentencia print dentro de una tupla junto al resultado. La salida deseada puede pasarse a la función de orden superior indexando la tupla en la posición 1. 

He aquí un ejemplo:

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

# Lambda function with print to debug intermediate values
filtered_numbers = filter(lambda x: (print(f'Checking: {x} -> {x >= 3}'), x >= 3)[1], numbers)

# Converting filter object to list to force evaluation
print(list(filtered_numbers))

    Checking: 1 -> False

    Checking: 2 -> False

    Checking: 3 -> True

    Checking: 4 -> True

    Checking: 5 -> True

    [3, 4, 5]

En este código, se utiliza un truco para imprimir los pasos intermedios al filtrar una lista de números. La función lambda en filter incluye una tupla: el primer elemento es una declaración print que registra el número actual y si cumple la condición (x >= 3), y el segundo elemento es la propia condición. 

El [1] al final de la lambda garantiza que la condición (x >= 3) se devuelva a la función filter al tiempo que permite que se ejecute la sentencia print para la depuración. 

Convertir el objeto filter en una lista fuerza la evaluación de todos los elementos, activando las sentencias print para cada número. Este enfoque ayuda a depurar la lógica manteniendo la funcionalidad de la operación de filtrado.

Buenas prácticas para utilizar funciones lambda

Las mejores prácticas para utilizar funciones lambda implican entender cuándo son apropiadas y cuándo deben evitarse.

Cuándo utilizar funciones lambda

  • Lógica corta y sencilla. Ideal para operaciones concisas que no requieren una definición completa de la función.
  • Funciones de orden superior. Funcionan eficazmente como argumentos de funciones de orden superior como map(), filter(), o sorted().
  • Funciones temporales (desechables). Útil cuando una función sólo se necesita una vez, y definirla con def abarrotaría innecesariamente el código.
  • Mejora de la legibilidad. Adecuado para tareas sencillas en las que el uso de una función lambda mantiene el código compacto y fácil de seguir.

Cuándo evitar las funciones lambda

  • Lógica compleja o multilínea. Las lambdas están limitadas a una sola expresión y pueden volverse rápidamente ilegibles para operaciones más intrincadas.
  • Funciones reutilizables o con nombre. Si la función debe reutilizarse o se beneficia de un nombre descriptivo, es más adecuada una función estándar de def.
  • Depuración o documentación. Las funciones lambda carecen de la capacidad de incluir docstrings y pueden ser más difíciles de depurar en comparación con las funciones con nombre.

Para mejorar la legibilidad y la mantenibilidad al utilizar lambdas, sigue estas buenas prácticas:

  • Utiliza nombres descriptivos para mayor claridad.
  • Hazlo sencillo: Lo ideal es que las lambdas quepan en una línea y representen una lógica directa.
  • Limita el anidamiento: Evita utilizar funciones lambda dentro de otras funciones lambda o estructuras de datos complejas a menos que sea necesario.
  • Prefiere la legibilidad a la concisión: Si utilizar una lambda sacrifica la legibilidad, es mejor definir una función con nombre.

Conclusión

Las funciones lambda de Python son una potente herramienta para escribir funciones concisas y anónimas. Destacan en situaciones que requieren operaciones cortas, temporales o en línea, sobre todo cuando se utilizan con funciones de orden superior como map, filter o sorted

Sin embargo, deben utilizarse con criterio, ya que la lógica más compleja se adapta mejor a las funciones estándar definidas con def. Si conoces sus puntos fuertes, sus limitaciones y las mejores prácticas, podrás aprovechar eficazmente las funciones lambda para escribir código Python limpio, eficiente y fácil de mantener.

Para saber más sobre las funciones de Python, consulta los recursos de DataCamp.

Preguntas frecuentes sobre las funciones lambda de Python

¿Por qué utilizar una función lambda?

Son perfectas para simplificar tareas a corto plazo, agilizar el código con funciones de orden superior como map, filter, o sorted, y reducir el desorden al definir lógica temporal o desechable.

¿Cuándo debo utilizar funciones lambda?

Las funciones lambda son apropiadas para: lógica breve y sencilla, adecuadas para frases de una línea, como argumentos de funciones de orden superior, como map() o filter(), y para funciones temporales que sólo se necesitan una vez.

¿Cuándo debo evitar las funciones lambda?

Las funciones lambda pueden no ser la mejor opción para lógica compleja o funciones que requieran documentación (como docstrings).


Mark Pedigo's photo
Author
Mark Pedigo
LinkedIn

Mark Pedigo, PhD, es un distinguido científico de datos con experiencia en ciencia de datos sanitarios, programación y educación. Doctor en Matemáticas, Licenciado en Informática y Certificado Profesional en Inteligencia Artificial, Mark combina los conocimientos técnicos con la resolución práctica de problemas. Su carrera incluye funciones en la detección del fraude, la predicción de la mortalidad infantil y la previsión financiera, junto con contribuciones al software de estimación de costes de la NASA. Como educador, ha impartido clases en DataCamp y en la Universidad Washington de San Luis, y ha sido mentor de programadores noveles. En su tiempo libre, Mark disfruta de la naturaleza de Minnesota con su esposa Mandy y su perro Harley, y toca el piano de jazz.

Temas

Los mejores cursos de DataCamp

programa

Fundamentos de Datos en Python

28 horas hr
Desarrolla tus habilidades con los datos, descubre cómo manipularlos y visualizarlos, y aplica análisis avanzados para tomar decisiones basadas en datos.
Ver detallesRight Arrow
Comienza el curso
Certificación disponible

curso

Escribir funciones en Python

4 hr
93.8K
Aprende a utilizar las mejores prácticas para escribir funciones mantenibles, reutilizables y complejas con una buena documentación.
Ver másRight Arrow
Relacionado

blog

Cómo aprender Python desde cero en 2024: Guía del experto

Descubre cómo aprender Python, sus aplicaciones y la demanda de conocimientos de Python. Comienza hoy tu andadura en Python ​con nuestra guía completa.
Matt Crabtree's photo

Matt Crabtree

19 min

tutorial

Tutorial y Ejemplos de Funciones y Métodos de Listas en Python

Conozca las funciones y métodos de lista de Python. Siga ahora ejemplos de código de list() y otras funciones y métodos de Python.
Abid Ali Awan's photo

Abid Ali Awan

7 min

tutorial

Tutorial de funciones de Python

Un tutorial sobre funciones en Python que cubre cómo escribir funciones, cómo invocarlas y mucho más.
Karlijn Willems's photo

Karlijn Willems

14 min

tutorial

Tutorial de comprensión del diccionario Python

¡Aprende todo sobre la comprensión de diccionarios en Python: cómo puedes utilizarla para crear diccionarios, para sustituir los for loops (anidados) o las funciones lambda por map(), filter() y reduce(), ...!
Sejal Jaiswal's photo

Sejal Jaiswal

14 min

tutorial

Función Print() de Python

Aprenda cómo puede aprovechar la capacidad de una simple función de impresión de Python de varias maneras con la ayuda de ejemplos.
Aditya Sharma's photo

Aditya Sharma

10 min

tutorial

Desarrollo de backend en Python: Guía completa para principiantes

Esta completa guía te enseña los fundamentos del desarrollo backend en Python. Aprende conceptos básicos, marcos de trabajo y buenas prácticas para empezar a crear aplicaciones web.
Oluseye Jeremiah's photo

Oluseye Jeremiah

26 min

Ver másVer más