En este tutorial, exploraremos cómo usar funciones lambda para actualizar los valores de los diccionarios en Python. Las funciones lambda son funciones compactas y anónimas que pueden hacer que su código sea más conciso y legible cuando se trabaja con diccionarios. Al final de esta guía, comprenderá cómo usar estas poderosas herramientas para optimizar las operaciones de diccionarios en sus programas Python.
En este paso, aprenderemos qué son las funciones lambda y cómo crearlas en Python.
Una función lambda es una función pequeña y anónima definida con la palabra clave lambda. A diferencia de las funciones regulares declaradas con la palabra clave def, las funciones lambda se pueden escribir en una sola línea y no necesitan un nombre. Son perfectas para operaciones simples que necesita realizar rápidamente.
La sintaxis básica de una función lambda es:
lambda argumentos: expresiónAquí, argumentos son las entradas de la función, y expresión es la operación que produce el resultado.
Creemos una función lambda simple y veamos cómo funciona. Abra un nuevo archivo Python en el editor de código haciendo clic en "Archivo" > "Nuevo archivo" en la barra de menú superior. Nombre el archivo lambda_basics.py y guárdelo en el directorio /home/labex/project.
Agregue el siguiente código al archivo:
## Define a regular function
def add_numbers(x, y):
return x + y
## Same function as a lambda
add_lambda = lambda x, y: x + y
## Test both functions
print("Regular function result:", add_numbers(5, 3))
print("Lambda function result:", add_lambda(5, 3))Ejecute el código abriendo una terminal (si aún no está abierta) y ejecutando:
python3 lambda_basics.pyDebería ver la siguiente salida:
Regular function result: 8
Lambda function result: 8Ambas funciones realizan la misma operación, pero la versión lambda es más concisa.
Las funciones lambda son más útiles en situaciones donde:
Veamos otro ejemplo. Agregue el siguiente código a su archivo lambda_basics.py:
## Using lambda with built-in functions
numbers = [1, 2, 3, 4, 5]
## Square each number using lambda
squared = list(map(lambda x: x**2, numbers))
## Filter even numbers using lambda
evens = list(filter(lambda x: x % 2 == 0, numbers))
print("Original numbers:", numbers)
print("Squared numbers:", squared)
print("Even numbers:", evens)Ejecute el archivo de nuevo:
python3 lambda_basics.pyLa salida ahora incluirá:
Original numbers: [1, 2, 3, 4, 5]
Squared numbers: [1, 4, 9, 16, 25]
Even numbers: [2, 4]En este ejemplo, usamos funciones lambda con las funciones integradas map y filter para transformar y filtrar una lista de números. Este tipo de operaciones serán útiles cuando trabajemos con diccionarios en los siguientes pasos.
Antes de usar funciones lambda con diccionarios, asegurémonos de entender cómo funcionan los diccionarios en Python.
Un diccionario es una colección de pares clave-valor. Cada clave está conectada a un valor, lo que le permite acceder rápidamente a los valores cuando conoce la clave. Los diccionarios son mutables, lo que significa que puede cambiar, agregar o eliminar elementos después de que se crea el diccionario.
Creemos un nuevo archivo llamado dictionary_basics.py en el directorio /home/labex/project y agreguemos el siguiente código:
## Creating a dictionary
product_prices = {
'apple': 1.50,
'banana': 0.75,
'orange': 1.20,
'grapes': 2.50
}
## Accessing dictionary values
print("Price of apple:", product_prices['apple'])
## Adding a new item
product_prices['watermelon'] = 3.75
print("Updated dictionary:", product_prices)
## Modifying an existing item
product_prices['banana'] = 0.85
print("After modification:", product_prices)
## Iterating through a dictionary
print("\nAll products and their prices:")
for product, price in product_prices.items():
print(f"{product}: ${price:.2f}")Ejecute el archivo:
python3 dictionary_basics.pyDebería ver una salida similar a esta:
Price of apple: 1.5
Updated dictionary: {'apple': 1.5, 'banana': 0.85, 'orange': 1.2, 'grapes': 2.5, 'watermelon': 3.75}
After modification: {'apple': 1.5, 'banana': 0.85, 'orange': 1.2, 'grapes': 2.5, 'watermelon': 3.75}
All products and their prices:
apple: $1.50
banana: $0.85
orange: $1.20
grapes: $2.50
watermelon: $3.75Los diccionarios tienen varios métodos útiles. Agreguemos el siguiente código a nuestro archivo dictionary_basics.py:
## Dictionary methods
print("\nDictionary Methods:")
print("Keys:", list(product_prices.keys()))
print("Values:", list(product_prices.values()))
print("Items:", list(product_prices.items()))
## Check if a key exists
if 'apple' in product_prices:
print("Apple is in the dictionary")
## Get a value with a default if key doesn't exist
price = product_prices.get('pineapple', 'Not available')
print("Price of pineapple:", price)Ejecute el archivo de nuevo:
python3 dictionary_basics.pyDebería ver la salida adicional:
Dictionary Methods:
Keys: ['apple', 'banana', 'orange', 'grapes', 'watermelon']
Values: [1.5, 0.85, 1.2, 2.5, 3.75]
Items: [('apple', 1.5), ('banana', 0.85), ('orange', 1.2), ('grapes', 2.5), ('watermelon', 3.75)]
Apple is in the dictionary
Price of pineapple: Not availableAhora que entendemos tanto las funciones lambda como los diccionarios, estamos listos para combinarlos en el siguiente paso.
Ahora que entendemos tanto las funciones lambda como los diccionarios, veamos cómo podemos usar las funciones lambda para actualizar los valores de los diccionarios.
Creemos un nuevo archivo llamado update_dictionaries.py en el directorio /home/labex/project y agreguemos el siguiente código:
## Create a dictionary of product prices
prices = {
'apple': 1.50,
'banana': 0.75,
'orange': 1.20,
'grapes': 2.50
}
print("Original prices:", prices)
## Apply a 10% discount to all prices using lambda and dictionary comprehension
discounted_prices = {item: round(price * 0.9, 2) for item, price in prices.items()}
print("Prices after 10% discount:", discounted_prices)
## Another way: using map() and lambda
## First, let's create a function that applies the map
def apply_to_dict(func, dictionary):
return dict(map(func, dictionary.items()))
## Now apply a 20% increase using the function and lambda
increased_prices = apply_to_dict(lambda item: (item[0], round(item[1] * 1.2, 2)), prices)
print("Prices after 20% increase:", increased_prices)Ejecute el archivo:
python3 update_dictionaries.pyDebería ver una salida similar a:
Original prices: {'apple': 1.5, 'banana': 0.75, 'orange': 1.2, 'grapes': 2.5}
Prices after 10% discount: {'apple': 1.35, 'banana': 0.68, 'orange': 1.08, 'grapes': 2.25}
Prices after 20% increase: {'apple': 1.8, 'banana': 0.9, 'orange': 1.44, 'grapes': 3.0}Desglosemos lo que sucedió:
apply_to_dict que usa map() y convierte el resultado de nuevo en un diccionario.Ahora, actualicemos los valores de nuestro diccionario condicionalmente. Agregue el siguiente código a su archivo update_dictionaries.py:
print("\n--- Conditional Updates ---")
## Apply different discounts: 15% for items over $1.00, 5% for the rest
varied_discount = {
item: round(price * 0.85, 2) if price > 1.00 else round(price * 0.95, 2)
for item, price in prices.items()
}
print("Varied discounts:", varied_discount)
## Using filter and lambda to update only certain items
def update_filtered_items(dictionary, filter_func, update_func):
## First, filter the items
filtered = dict(filter(filter_func, dictionary.items()))
## Then, update the filtered items
updated = {key: update_func(value) for key, value in filtered.items()}
## Merge with the original dictionary (only updating filtered items)
result = dictionary.copy()
result.update(updated)
return result
## Apply a 50% discount only to fruits starting with 'a'
special_discount = update_filtered_items(
prices,
lambda item: item[0].startswith('a'),
lambda price: round(price * 0.5, 2)
)
print("Special discount on items starting with 'a':", special_discount)Ejecute el archivo de nuevo:
python3 update_dictionaries.pyAhora debería ver una salida adicional:
--- Conditional Updates ---
Varied discounts: {'apple': 1.28, 'banana': 0.71, 'orange': 1.02, 'grapes': 2.12}
Special discount on items starting with 'a': {'apple': 0.75, 'banana': 0.75, 'orange': 1.2, 'grapes': 2.5}En este ejemplo:
Estos ejemplos demuestran cómo las funciones lambda pueden hacer que las actualizaciones de diccionarios sean más concisas y legibles, especialmente cuando se combinan con las funciones integradas de Python como map() y filter().
Exploremos algunas aplicaciones más avanzadas de las funciones lambda con diccionarios, centrándonos en la clasificación y transformación de datos de diccionarios.
Los diccionarios en Python no están ordenados por defecto, pero a veces necesitamos procesarlos en un orden específico. Creemos un nuevo archivo llamado advanced_dictionary_ops.py en el directorio /home/labex/project y agreguemos el siguiente código:
## Create a dictionary of student scores
student_scores = {
'Alice': 92,
'Bob': 85,
'Charlie': 78,
'David': 95,
'Eva': 88
}
print("Original student scores:", student_scores)
## Sort by student names (keys)
sorted_by_name = dict(sorted(student_scores.items()))
print("\nSorted by name:", sorted_by_name)
## Sort by scores (values) in ascending order
sorted_by_score_asc = dict(sorted(student_scores.items(), key=lambda item: item[1]))
print("\nSorted by score (ascending):", sorted_by_score_asc)
## Sort by scores (values) in descending order
sorted_by_score_desc = dict(sorted(student_scores.items(), key=lambda item: item[1], reverse=True))
print("\nSorted by score (descending):", sorted_by_score_desc)
## Get the top 3 students by score
top_3_students = dict(sorted(student_scores.items(), key=lambda item: item[1], reverse=True)[:3])
print("\nTop 3 students:", top_3_students)Ejecute el archivo:
python3 advanced_dictionary_ops.pyDebería ver una salida similar a:
Original student scores: {'Alice': 92, 'Bob': 85, 'Charlie': 78, 'David': 95, 'Eva': 88}
Sorted by name: {'Alice': 92, 'Bob': 85, 'Charlie': 78, 'David': 95, 'Eva': 88}
Sorted by score (ascending): {'Charlie': 78, 'Bob': 85, 'Eva': 88, 'Alice': 92, 'David': 95}
Sorted by score (descending): {'David': 95, 'Alice': 92, 'Eva': 88, 'Bob': 85, 'Charlie': 78}
Top 3 students: {'David': 95, 'Alice': 92, 'Eva': 88}En este ejemplo, usamos la función sorted() con funciones lambda para ordenar el diccionario de diferentes maneras:
También usamos el slicing [:3] para obtener solo los 3 mejores estudiantes después de ordenar.
Ahora, veamos cómo podemos transformar los valores en un diccionario. Agregue el siguiente código a su archivo advanced_dictionary_ops.py:
print("\n--- Transforming Dictionary Values ---")
## Create a dictionary of temperatures in Celsius
celsius_temps = {
'New York': 21,
'London': 18,
'Tokyo': 26,
'Sydney': 22,
'Moscow': 14
}
print("Temperatures in Celsius:", celsius_temps)
## Convert Celsius to Fahrenheit: F = C * 9/5 + 32
fahrenheit_temps = {city: round(temp * 9/5 + 32, 1) for city, temp in celsius_temps.items()}
print("Temperatures in Fahrenheit:", fahrenheit_temps)
## Categorize temperatures as cool, moderate, or warm
def categorize_temp(temp):
if temp < 18:
return "Cool"
elif temp < 25:
return "Moderate"
else:
return "Warm"
categorized_temps = {city: categorize_temp(temp) for city, temp in celsius_temps.items()}
print("Categorized temperatures:", categorized_temps)
## Group cities by temperature category using a lambda and reduce
from collections import defaultdict
from functools import reduce
grouped_cities = reduce(
lambda result, item: result[categorize_temp(item[1])].append(item[0]) or result,
celsius_temps.items(),
defaultdict(list)
)
print("\nCities grouped by temperature category:")
for category, cities in grouped_cities.items():
print(f"{category}: {', '.join(cities)}")Ejecute el archivo de nuevo:
python3 advanced_dictionary_ops.pyAhora debería ver una salida adicional:
--- Transforming Dictionary Values ---
Temperatures in Celsius: {'New York': 21, 'London': 18, 'Tokyo': 26, 'Sydney': 22, 'Moscow': 14}
Temperatures in Fahrenheit: {'New York': 69.8, 'London': 64.4, 'Tokyo': 78.8, 'Sydney': 71.6, 'Moscow': 57.2}
Categorized temperatures: {'New York': 'Moderate', 'London': 'Moderate', 'Tokyo': 'Warm', 'Sydney': 'Moderate', 'Moscow': 'Cool'}
Cities grouped by temperature category:
Cool: Moscow
Moderate: New York, London, Sydney
Warm: TokyoEn este ejemplo:
reduce() con una lambda para agrupar las ciudades por categoría de temperatura.Estas técnicas demuestran cómo las funciones lambda pueden hacer que las operaciones complejas de diccionarios sean más concisas y legibles. Como puede ver, la combinación de funciones lambda con las funciones integradas de Python y las operaciones de diccionario proporciona herramientas poderosas para la manipulación de datos.
En este tutorial, ha aprendido a usar funciones lambda para actualizar los valores de los diccionarios en Python. Cubrimos:
map(), filter() y reduce()Estas técnicas le ayudarán a escribir código más conciso y legible cuando trabaje con diccionarios en Python. A medida que continúe su viaje en Python, descubrirá que las funciones lambda se convierten en una herramienta cada vez más valiosa en su conjunto de herramientas de programación, especialmente para tareas de manipulación de datos.
Recuerde que, si bien las funciones lambda son poderosas, funcionan mejor para operaciones simples. Para una lógica más compleja, considere usar funciones con nombre regulares para mantener la legibilidad y el mantenimiento del código.
