Funciones Lambda en Python

Introducción

En este laboratorio, aprenderá a utilizar las funciones lambda en Python. Comenzaremos por comprender el concepto de funciones anónimas y la palabra clave lambda, comparándolas con las definiciones de funciones tradicionales. Luego, creará funciones lambda sencillas con diferentes números de parámetros.

El laboratorio explorará además cómo utilizar eficazmente las funciones lambda con funciones integradas de Python como sorted. Finalmente, discutiremos las mejores prácticas para usar funciones lambda para asegurar que su código sea legible y mantenible.

Comprender las Funciones Anónimas y Lambda

En este paso, introduciremos el concepto de funciones anónimas en Python, centrándonos en la palabra clave lambda. Las funciones anónimas son funciones sin nombre, que ofrecen una forma concisa de definir funciones simples de una sola expresión.

En Python, normalmente definimos funciones usando la palabra clave def. Por ejemplo, una función que duplica un número se ve así:

def double(x):
    return x * 2

print(double(10))

Para funciones pequeñas como esta, lambda proporciona una sintaxis más compacta. Crearemos la misma función usando lambda.

En el explorador de archivos del WebIDE a la izquierda, encuentre y abra el archivo ~/project/lambda_example1.py. Agregue el siguiente código:

## Define a lambda function to double a number
double_lambda = lambda x: x * 2

## Call the lambda function and print the result
print(double_lambda(10))

La sintaxis es lambda argumentos: expresión. Los argumentos son las entradas, y la expresión es una única operación que se evalúa y devuelve. Observe que no hay palabra clave return; la devolución es implícita.

Guarde el archivo. Para ejecutar el script, abra la terminal en el WebIDE y ejecute el siguiente comando:

python3 ~/project/lambda_example1.py

Debería ver la salida en la terminal.

20

Esto demuestra cómo una función lambda puede asignarse a una variable y llamarse como una función normal.

Crear Funciones Lambda con Parámetros Variados

Las funciones lambda son flexibles y se pueden definir con cero, uno o múltiples parámetros. Sin embargo, siempre están restringidas a una única expresión. En este paso, exploraremos la creación de lambdas con diferentes números de parámetros.

Primero, creemos una función lambda que no tome argumentos. Esto puede ser útil para definir una constante o una acción simple y repetible.

Abra el archivo ~/project/lambda_example2.py desde el explorador de archivos. Agregue el siguiente código:

## Define a lambda function with no arguments
get_greeting = lambda: "Hello, World!"

## Call the lambda function and print the result
print(get_greeting())

A continuación, creemos una función lambda que acepte múltiples argumentos. Definiremos una lambda que suma dos números. Agregue este código al mismo archivo lambda_example2.py:

## Define a lambda function that adds two numbers
add_numbers = lambda x, y: x + y

## Call the lambda function with two arguments and print the result
print(add_numbers(5, 3))

Guarde el archivo. Ahora, ejecute el script desde la terminal para ver ambas salidas:

python3 ~/project/lambda_example2.py

La terminal mostrará los resultados de ambas funciones lambda.

Hello, World!
8

Esto demuestra que las funciones lambda pueden manejar diferentes configuraciones de parámetros, lo que las hace versátiles para diversas tareas sencillas.

Usar Lambda con la Función sorted()

Uno de los casos de uso más comunes para las funciones lambda es servir como una función rápida en línea para funciones de orden superior (funciones que toman otras funciones como argumentos). Un ejemplo principal es la función incorporada sorted() de Python, que puede aceptar un argumento key. La key especifica una función que se llamará en cada elemento antes de realizar las comparaciones de ordenación.

Imagine que tiene una lista de tuplas, donde cada tupla representa un producto y su precio. Quiere ordenar esta lista basándose en el precio.

Abra el archivo ~/project/lambda_sorted.py en el editor. Agregue el siguiente código:

## A list of tuples (product, price)
products = [('Laptop', 1200), ('Mouse', 25), ('Keyboard', 75)]

## Sort the list by price (the second element of each tuple) using a lambda function
sorted_products = sorted(products, key=lambda item: item[1])

## Print the sorted list
print(sorted_products)

En este código, key=lambda item: item[1] le indica a sorted() que use el segundo elemento (item[1], que es el precio) de cada tupla como el valor para la ordenación. Esto es mucho más conciso que definir una función separada con def.

Guarde el archivo y ejecútelo desde la terminal:

python3 ~/project/lambda_sorted.py

Verá la lista de productos ordenada por precio en orden ascendente.

[('Mouse', 25), ('Keyboard', 75), ('Laptop', 1200)]

Este patrón es extremadamente común y útil para ordenar estructuras de datos complejas de una manera simple y legible.

Técnicas Avanzadas de Lambda

En este paso, exploraremos formas ligeramente más avanzadas de usar funciones lambda, incluyendo el establecimiento de valores de parámetros predeterminados e invocar inmediatamente una función lambda.

Al igual que las funciones regulares, las funciones lambda pueden tener parámetros con valores predeterminados. Esto proporciona un valor de reserva si no se suministra un argumento durante la llamada a la función.

Abra el archivo ~/project/lambda_advanced.py en el editor. Agregue el siguiente código:

## Define a lambda function with a default parameter value
power = lambda base, exponent=2: base ** exponent

## Call the lambda function without the optional argument (uses default)
print(power(3))

## Call the lambda function with both arguments
print(power(3, 3))

Otra técnica interesante es definir e invocar inmediatamente una función lambda. Esto se conoce como una Expresión de Función Invocada Inmediatamente (IIFE, por sus siglas en inglés). Puede ser útil para crear una función temporal de un solo uso para calcular un valor sin saturar el espacio de nombres (namespace).

Agregue el siguiente código al archivo lambda_advanced.py:

## Define and immediately invoke a lambda function to calculate a discounted price
price = 100
discount_percentage = 20
final_price = (lambda p, d: p * (1 - d / 100))(price, discount_percentage)

print(final_price)

Guarde el archivo y ejecútelo desde la terminal:

python3 ~/project/lambda_advanced.py

La salida mostrará los resultados de ambos ejemplos.

9
27
80.0

Si bien estas técnicas demuestran la flexibilidad de las lambdas, recuerde que la legibilidad es clave. Si la lógica se vuelve compleja, una función estándar definida con def suele ser una mejor opción.

Mejores Prácticas y Legibilidad

En este paso final, discutiremos las mejores prácticas para usar funciones lambda. Si bien las lambdas son una herramienta poderosa para escribir código conciso, deben usarse con prudencia para mantener la legibilidad y la mantenibilidad.

Cuándo usar lambda:

• Como argumentos para funciones de orden superior: Este es el caso de uso principal. Funciones como sorted(), map() y filter() son candidatas perfectas para lambdas.
• Operaciones simples y cortas: Si la lógica cabe cómodamente y claramente en una sola línea, una lambda es una buena opción.

Cuándo evitar lambda:

• Lógica compleja: Si necesita múltiples sentencias, lógica condicional compleja o bucles, siempre use una función def.
• Problemas de legibilidad: Si una expresión lambda es difícil de entender de un vistazo, anula su propósito. Una función con nombre y una denominación descriptiva es mejor.
• Reutilización: Si necesita la misma lógica en varios lugares, defínala una vez con def para seguir el principio de No Repetirse (DRY, por sus siglas en inglés).

Veamos un ejemplo bueno y legible que refuerza el caso de uso de la mejor práctica. Abra el archivo ~/project/lambda_best_practice.py y agregue el siguiente código:

## A list of dictionaries
students = [
    {'name': 'Alice', 'grade': 88},
    {'name': 'Bob', 'grade': 95},
    {'name': 'Charlie', 'grade': 72}
]

## A good use of lambda: sorting a list of dictionaries by a value
sorted_by_grade = sorted(students, key=lambda student: student['grade'])

print("Sorted by grade:", sorted_by_grade)

## For comparison, a more complex task is better with a named function.
## For example, if you needed to apply a curve and check for a minimum score,
## a 'def' function would be much clearer than a complex lambda.
def process_grade(student):
    curved_grade = student['grade'] * 1.05
    return max(curved_grade, 75) ## Ensure a minimum score

processed_grades = [process_grade(s) for s in students]
print("Processed grades:", processed_grades)

Guarde el archivo y ejecútelo:

python3 ~/project/lambda_best_practice.py

Verá la salida:

Sorted by grade: [{'name': 'Charlie', 'grade': 72}, {'name': 'Alice', 'grade': 88}, {'name': 'Bob', 'grade': 95}]
Processed grades: [92.4, 99.75, 75.60000000000001]

La primera parte muestra un uso claro y apropiado de lambda. La segunda parte ilustra un escenario donde una función con nombre es más adecuada. Siempre priorice escribir código que sea fácil de leer y comprender para usted y para otros.

Resumen

En este laboratorio, aprendió los fundamentos de las funciones lambda de Python. Comenzó comprendiendo su sintaxis y cómo difieren de las funciones estándar definidas con def. Practicó la creación de lambdas con cero, uno y múltiples parámetros, y vio cómo pueden asignarse a variables y llamarse.

Una conclusión clave fue la aplicación práctica de las funciones lambda como argumentos para funciones de orden superior, particularmente con sorted() para definir lógica de ordenamiento personalizada de forma concisa. También exploramos técnicas avanzadas como los parámetros predeterminados y las expresiones de función invocadas inmediatamente (IIFE). Finalmente, revisó las mejores prácticas para usar lambdas, enfatizando que si bien son potentes para casos simples y de un solo uso, la legibilidad y la mantenibilidad siempre deben ser la prioridad, favoreciendo las funciones con nombre para una lógica más compleja.