Funciones lambda de Python: Guía para principiantes

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, optimizar 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 escenarios sencillos. En este artículo se explican qué son las funciones lambda, cuáles son sus características y cómo utilizarlas de forma eficaz.

En esta guía, proporcionaremos una guía completa sobre 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 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 se diferencian 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 concisas y se definen en una sola línea sin necesidad de una instrucción return. Esto los hace ideales para operaciones simples y únicas, y para su uso como argumentos en línea en funciones de orden superior como map, filter y sorted.

A continuación se muestra un ejemplo de una función lambda que suma dos números:

fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xe508b8>

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 muy 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 logra la misma tarea.

# Example: add two numbers using a lambda function
fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xbfb968>

La palabra clave lambda significa que estamos definiendo una función lambda, lo que elimina la necesidad de utilizar la palabra clave def. A continuación de 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 comprender 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 a la derecha de la asignación toma una entrada x y devuelve True si x es par (es decir, si el resto al dividir por 2 es 0). 

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

Las funciones lambda también son ideales para definir fórmulas sencillas. Por ejemplo, para convertir grados Celsius a Fahrenheit, puedes utilizar una función lambda: c_to_f = lambda c: (c * 9/5) + 32. A continuación, 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 funcional, especialmente con funciones como map() y filter(), que toman otras funciones como argumentos para procesar elementos de una colección. Veamos cómo usar 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, comenzamos definiendo un conjunto de e 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 la longitud de las cadenas de una lista aplicando 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]

Las funciones lambda también se utilizan 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 valor absoluto. ¿Cómo lo lograrí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 en función de un elemento específico, por ejemplo, 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 ordenarlos.

¿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 en un código byte similar. Sin embargo, pueden reducir ligeramente la sobrecarga en los casos en que definir una función completa añadiría código repetitivo innecesario.

A continuación se muestran algunos casos de prueba en los que se comparan las funciones lambda con las funciones estándar de Python. El código se ejecutó en tu ordenador portátil, un MacBook Pro con un chip Apple M1 Pro, 16 GB de memoria y macOS Sequoia 15.2.

Las funciones lambda se pueden utilizar 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 hacer referencia a una función con nombre independiente, lo que reduce 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 único o temporal, ya que eliminan la necesidad de un bloque formal def, lo que ahorra 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 prácticos más para mostrar cómo funcionan las funciones Lambda en Python. 

Ejemplos prácticos

Las funciones lambda se utilizan a menudo con métodos integrados de Python. Por ejemplo, veamos cómo usar reduce() para aplicar una función binaria definida por el usuario de forma acumulativa 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() arriba, reduce() aplica una función, en este caso dada por una lambda, a un conjunto de elementos.

Ahora, exploremos otra función integrada de Python, zip(). La función zip empareja 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}.')

# The result of multiplying corresponding elements is [4, 10, 18].

Este código calcula el producto de los elementos correspondientes de dos listas, list1 y list2. Utiliza zip() para emparejar elementos de las listas en tuplas, luego aplica una función lambda con map() para multiplicar los elementos emparejados y, finalmente, 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.

Primero, creamos algunos registros de ventas. A continuación, 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 descomprime el diccionario original, asegurando que todas sus claves y valores se conserven en el nuevo diccionario. Por último, imprimimos cada registro de los datos transformados.

# 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},
]

# 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
	)
)

# 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 que los usuarios pueden resolver con funciones lambda.

Si deseas practicar el uso de funciones lambda, aquí tienes algunos problemas para que pruebes.

• Dado un número, calcula su cuadrado.
• Dados dos números, encuentra 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 su tercer elemento.
• 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 que se puede cometer es confundir la sintaxis. Por ejemplo, si olvidas la palabra clave lambda, se producirá un error. Otro error sintáctico habitual es omitir los 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 este es incluir casos de prueba informales y sencillos durante el desarrollo.

print(list(squared))

3. Otro error que hay que evitar es no incluir lógica para los casos extremos. Por ejemplo, este código falla cuando y es 0. La solución consiste en incluir una simple instrucción if para detectar el caso problemático o envolver el código en un bloque de excepción.

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

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 olvidarse de convertir el iterador en una lista al generar los resultados. Por ejemplo, la función map() devuelve un objeto map, no una lista. Para acceder a los resultados, convierte el objeto map en un list.

# 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

# <map object at 0x106d2b0>

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

# [1, 4, 9]

Estrategias de depuración de Python Lambda

Entonces, ¿cómo se depuran las lambdas? Aquí hay algunas posibilidades.

• Descomponer la función lambda. Conviértelo temporalmente en una función con nombre para fines de depuración.
• Usa sentencias de impresión para mostrar valores intermedios en funciones de orden superior como map() o filter().
• Prueba los casos extremos. Realiza pruebas con valores extremos, no válidos o límite para detectar posibles errores.

Un truco útil para imprimir los pasos intermedios es incluir una instrucción print dentro de una tupla junto con el resultado. A continuación, el resultado deseado se puede pasar a la función de orden superior indexando la tupla en la posición 1.

Aquí tienes 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 mientras se filtra una lista de números. La función lambda en filter incluye una tupla: el primer elemento es una instrucción print que registra el número actual y si cumple la condición (x >= 3), y el segundo elemento es la condición en sí. 

El operador [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 instrucción print para la depuración.

Convertir el objeto filter en una lista obliga a evaluar todos los elementos, lo que activa las instrucciones print para cada número. Este enfoque ayuda a depurar la lógica mientras se mantiene la funcionalidad de la operación de filtrado.

Prácticas recomendadas para usar funciones Lambda

Las mejores prácticas para utilizar las funciones lambda implican comprender cuándo son adecuadas y cuándo deben evitarse.

Cuándo utilizar funciones Lambda

• Lógica breve 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 para funciones de orden superior como map(), filter() o sorted().
• Funciones temporales (desechables). Útil cuando una función solo se necesita una vez y definirla con def sobrecargarí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 complejas.
• Funciones reutilizables o con nombre. Si la función necesita reutilizarse o te conviene darle un nombre descriptivo, es más apropiado utilizar una función estándar def.
• Depuración o documentación. Las funciones lambda no pueden incluir cadenas de documentación y pueden ser más difíciles de depurar en comparación con las funciones con nombre.

Para mejorar la legibilidad y la facilidad de mantenimiento al utilizar lambdas, sigue estas prácticas recomendadas:

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

Conclusión

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

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

Para obtener más información sobre las funciones de Python, consulta los recursos de DataCamp.

• Funciones de Python: Cómo llamar y escribir funciones
• Curso de escritura de funciones en Python
• Fundamentos de datos en Python
• Fundamentos de programación en Python
• Curso de Python intermedio para programadores