Dans ce tutoriel, nous allons explorer comment utiliser les fonctions lambda pour mettre à jour les valeurs des dictionnaires en Python. Les fonctions lambda sont des fonctions compactes et anonymes qui peuvent rendre votre code plus concis et lisible lorsque vous travaillez avec des dictionnaires. À la fin de ce guide, vous comprendrez comment utiliser ces outils puissants pour rationaliser les opérations sur les dictionnaires dans vos programmes Python.
Dans cette étape, nous allons apprendre ce que sont les fonctions lambda et comment les créer en Python.
Une fonction lambda est une petite fonction anonyme définie avec le mot-clé lambda. Contrairement aux fonctions régulières déclarées avec le mot-clé def, les fonctions lambda peuvent être écrites sur une seule ligne et n'ont pas besoin de nom. Elles sont parfaites pour les opérations simples que vous devez effectuer rapidement.
La syntaxe de base d'une fonction lambda est :
lambda arguments: expressionIci, arguments sont les entrées de la fonction, et expression est l'opération qui produit le résultat.
Créons une fonction lambda simple et voyons comment elle fonctionne. Ouvrez un nouveau fichier Python dans l'éditeur de code en cliquant sur "File" > "New File" dans la barre de menu supérieure. Nommez le fichier lambda_basics.py et enregistrez-le dans le répertoire /home/labex/project.
Ajoutez le code suivant au fichier :
## 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))Exécutez le code en ouvrant un terminal (s'il n'est pas déjà ouvert) et en exécutant :
python3 lambda_basics.pyVous devriez voir la sortie suivante :
Regular function result: 8
Lambda function result: 8Les deux fonctions effectuent la même opération, mais la version lambda est plus concise.
Les fonctions lambda sont les plus utiles dans les situations où :
Voyons un autre exemple. Ajoutez le code suivant à votre fichier 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)Exécutez à nouveau le fichier :
python3 lambda_basics.pyLa sortie inclura désormais :
Original numbers: [1, 2, 3, 4, 5]
Squared numbers: [1, 4, 9, 16, 25]
Even numbers: [2, 4]Dans cet exemple, nous avons utilisé des fonctions lambda avec les fonctions intégrées map et filter pour transformer et filtrer une liste de nombres. Ce type d'opérations sera utile lorsque nous travaillerons avec des dictionnaires dans les prochaines étapes.
Avant d'utiliser les fonctions lambda avec les dictionnaires, assurons-nous de bien comprendre comment les dictionnaires fonctionnent en Python.
Un dictionnaire est une collection de paires clé-valeur. Chaque clé est connectée à une valeur, ce qui vous permet d'accéder rapidement aux valeurs lorsque vous connaissez la clé. Les dictionnaires sont mutables, ce qui signifie que vous pouvez modifier, ajouter ou supprimer des éléments après la création du dictionnaire.
Créons un nouveau fichier appelé dictionary_basics.py dans le répertoire /home/labex/project et ajoutons le code suivant :
## 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}")Exécutez le fichier :
python3 dictionary_basics.pyVous devriez voir une sortie similaire à celle-ci :
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.75Les dictionnaires ont plusieurs méthodes utiles. Ajoutons le code suivant à notre fichier 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)Exécutez à nouveau le fichier :
python3 dictionary_basics.pyVous devriez voir la sortie supplémentaire :
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 availableMaintenant que nous comprenons à la fois les fonctions lambda et les dictionnaires, nous sommes prêts à les combiner dans l'étape suivante.
Maintenant que nous comprenons à la fois les fonctions lambda et les dictionnaires, voyons comment nous pouvons utiliser les fonctions lambda pour mettre à jour les valeurs des dictionnaires.
Créons un nouveau fichier appelé update_dictionaries.py dans le répertoire /home/labex/project et ajoutons le code suivant :
## 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)Exécutez le fichier :
python3 update_dictionaries.pyVous devriez voir une sortie similaire à :
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}Décomposons ce qui s'est passé :
apply_to_dict qui utilise map() et reconvertit le résultat en un dictionnaire.Maintenant, mettons à jour les valeurs de notre dictionnaire de manière conditionnelle. Ajoutez le code suivant à votre fichier 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)Exécutez à nouveau le fichier :
python3 update_dictionaries.pyVous devriez maintenant voir une sortie supplémentaire :
--- 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}Dans cet exemple :
Ces exemples montrent comment les fonctions lambda peuvent rendre les mises à jour de dictionnaires plus concises et lisibles, en particulier lorsqu'elles sont combinées avec les fonctions intégrées de Python comme map() et filter().
Explorons quelques applications plus avancées des fonctions lambda avec les dictionnaires, en nous concentrant sur le tri et la transformation des données des dictionnaires.
Les dictionnaires en Python ne sont pas ordonnés par défaut, mais nous avons parfois besoin de les traiter dans un ordre spécifique. Créons un nouveau fichier appelé advanced_dictionary_ops.py dans le répertoire /home/labex/project et ajoutons le code suivant :
## 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)Exécutez le fichier :
python3 advanced_dictionary_ops.pyVous devriez voir une sortie similaire à :
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}Dans cet exemple, nous avons utilisé la fonction sorted() avec des fonctions lambda pour trier le dictionnaire de différentes manières :
Nous avons également utilisé le slicing [:3] pour obtenir uniquement les 3 meilleurs étudiants après le tri.
Voyons maintenant comment nous pouvons transformer les valeurs d'un dictionnaire. Ajoutez le code suivant à votre fichier 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)}")Exécutez à nouveau le fichier :
python3 advanced_dictionary_ops.pyVous devriez maintenant voir une sortie supplémentaire :
--- 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: TokyoDans cet exemple :
reduce() avec une lambda pour regrouper les villes par catégorie de température.Ces techniques montrent comment les fonctions lambda peuvent rendre les opérations de dictionnaire complexes plus concises et lisibles. Comme vous pouvez le constater, la combinaison des fonctions lambda avec les fonctions intégrées de Python et les opérations de dictionnaire fournit des outils puissants pour la manipulation des données.
Dans ce tutoriel, vous avez appris à utiliser les fonctions lambda pour mettre à jour les valeurs des dictionnaires en Python. Nous avons couvert :
map(), filter() et reduce()Ces techniques vous aideront à écrire un code plus concis et lisible lorsque vous travaillez avec des dictionnaires en Python. Au fur et à mesure que vous poursuivrez votre parcours Python, vous constaterez que les fonctions lambda deviennent un outil de plus en plus précieux dans votre boîte à outils de programmation, en particulier pour les tâches de manipulation de données.
N'oubliez pas que bien que les fonctions lambda soient puissantes, elles fonctionnent mieux pour les opérations simples. Pour une logique plus complexe, envisagez d'utiliser des fonctions nommées régulières pour maintenir la lisibilité et la maintenabilité du code.
