Wie man Lambda-Funktionen verwendet, um Dictionary-Werte in Python zu aktualisieren

Einführung

In diesem Tutorial werden wir untersuchen, wie man Lambda-Funktionen verwendet, um Dictionary-Werte in Python zu aktualisieren. Lambda-Funktionen sind kompakte, anonyme Funktionen, die Ihren Code prägnanter und lesbarer machen können, wenn Sie mit Dictionaries arbeiten. Am Ende dieser Anleitung werden Sie verstehen, wie Sie diese leistungsstarken Werkzeuge einsetzen können, um Dictionary-Operationen in Ihren Python-Programmen zu optimieren.

Erste Schritte mit Lambda-Funktionen

In diesem Schritt werden wir lernen, was Lambda-Funktionen sind und wie man sie in Python erstellt.

Was ist eine Lambda-Funktion?

Eine Lambda-Funktion ist eine kleine, anonyme Funktion, die mit dem Schlüsselwort lambda definiert wird. Im Gegensatz zu regulären Funktionen, die mit dem Schlüsselwort def deklariert werden, können Lambda-Funktionen in einer einzigen Zeile geschrieben werden und benötigen keinen Namen. Sie sind perfekt für einfache Operationen, die Sie schnell ausführen müssen.

Die grundlegende Syntax einer Lambda-Funktion ist:

lambda arguments: expression

Hier sind arguments die Eingaben für die Funktion, und expression ist die Operation, die das Ergebnis erzeugt.

Erstellen Ihrer ersten Lambda-Funktion

Lassen Sie uns eine einfache Lambda-Funktion erstellen und sehen, wie sie funktioniert. Öffnen Sie eine neue Python-Datei im Code-Editor, indem Sie im oberen Menü auf "Datei" > "Neue Datei" klicken. Nennen Sie die Datei lambda_basics.py und speichern Sie sie im Verzeichnis /home/labex/project.

Fügen Sie der Datei den folgenden Code hinzu:

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

Führen Sie den Code aus, indem Sie ein Terminal öffnen (falls noch nicht geöffnet) und ausführen:

python3 lambda_basics.py

Sie sollten die folgende Ausgabe sehen:

Regular function result: 8
Lambda function result: 8

Beide Funktionen führen die gleiche Operation aus, aber die Lambda-Version ist prägnanter.

Wann man Lambda-Funktionen verwenden sollte

Lambda-Funktionen sind am nützlichsten in Situationen, in denen:

1. Sie eine einfache Funktion für einen kurzen Zeitraum benötigen
2. Sie eine Funktion als Argument an eine andere Funktion übergeben möchten
3. Sie eine einfache Operation auf Elemente in einer Sammlung anwenden müssen

Lassen Sie uns ein weiteres Beispiel betrachten. Fügen Sie Ihrer Datei lambda_basics.py den folgenden Code hinzu:

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

Führen Sie die Datei erneut aus:

python3 lambda_basics.py

Die Ausgabe enthält nun:

Original numbers: [1, 2, 3, 4, 5]
Squared numbers: [1, 4, 9, 16, 25]
Even numbers: [2, 4]

In diesem Beispiel haben wir Lambda-Funktionen mit den integrierten Funktionen map und filter verwendet, um eine Liste von Zahlen zu transformieren und zu filtern. Diese Art von Operationen wird nützlich sein, wenn wir in den nächsten Schritten mit Dictionaries arbeiten.

Grundlagen zu Dictionaries in Python

Bevor wir Lambda-Funktionen mit Dictionaries verwenden, wollen wir sicherstellen, dass wir verstehen, wie Dictionaries in Python funktionieren.

Was ist ein Dictionary?

Ein Dictionary ist eine Sammlung von Schlüssel-Wert-Paaren. Jeder Schlüssel ist mit einem Wert verbunden, wodurch Sie schnell auf Werte zugreifen können, wenn Sie den Schlüssel kennen. Dictionaries sind veränderbar (mutable), was bedeutet, dass Sie Elemente ändern, hinzufügen oder entfernen können, nachdem das Dictionary erstellt wurde.

Erstellen und Zugreifen auf Dictionaries

Lassen Sie uns eine neue Datei namens dictionary_basics.py im Verzeichnis /home/labex/project erstellen und den folgenden Code hinzufügen:

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

Führen Sie die Datei aus:

python3 dictionary_basics.py

Sie sollten eine Ausgabe ähnlich dieser sehen:

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.75

Verwenden von Dictionary-Methoden

Dictionaries haben mehrere nützliche Methoden. Fügen wir unserer Datei dictionary_basics.py den folgenden Code hinzu:

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

Führen Sie die Datei erneut aus:

python3 dictionary_basics.py

Sie sollten die zusätzliche Ausgabe sehen:

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 available

Nun, da wir sowohl Lambda-Funktionen als auch Dictionaries verstehen, sind wir bereit, sie im nächsten Schritt zu kombinieren.

Verwenden von Lambda-Funktionen zum Aktualisieren von Dictionary-Werten

Nachdem wir sowohl Lambda-Funktionen als auch Dictionaries verstehen, wollen wir sehen, wie wir Lambda-Funktionen verwenden können, um Dictionary-Werte zu aktualisieren.

Grundlegende Dictionary-Aktualisierungen mit Lambda

Lassen Sie uns eine neue Datei namens update_dictionaries.py im Verzeichnis /home/labex/project erstellen und den folgenden Code hinzufügen:

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

Führen Sie die Datei aus:

python3 update_dictionaries.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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}

Lassen Sie uns aufschlüsseln, was passiert ist:

1. Wir haben ein Dictionary mit Produktpreisen erstellt.
2. Wir haben eine Dictionary-Comprehension mit einer einfachen Berechnung verwendet, um einen Rabatt von 10 % anzuwenden.
3. Wir haben eine Hilfsfunktion apply_to_dict erstellt, die map() verwendet und das Ergebnis zurück in ein Dictionary konvertiert.
4. Wir haben diese Funktion mit einem Lambda verwendet, um eine Preiserhöhung von 20 % anzuwenden.

Bedingte Aktualisierungen mit Lambda-Funktionen

Lassen Sie uns nun unsere Dictionary-Werte bedingt aktualisieren. Fügen Sie Ihrer Datei update_dictionaries.py den folgenden Code hinzu:

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)

Führen Sie die Datei erneut aus:

python3 update_dictionaries.py

Sie sollten nun eine zusätzliche Ausgabe sehen:

--- 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}

In diesem Beispiel:

1. Wir haben einen bedingten Ausdruck in der Dictionary-Comprehension verwendet, um unterschiedliche Rabattprozentsätze basierend auf dem Preis anzuwenden.
2. Wir haben eine Funktion erstellt, die Elemente mithilfe einer Lambda-Funktion filtert und dann nur die gefilterten Elemente mit einer anderen Lambda-Funktion aktualisiert.
3. Wir haben diese Funktion angewendet, um einen Rabatt von 50 % nur auf Produkte zu gewähren, die mit dem Buchstaben 'a' beginnen.

Diese Beispiele zeigen, wie Lambda-Funktionen Dictionary-Aktualisierungen prägnanter und lesbarer machen können, insbesondere in Kombination mit den integrierten Funktionen von Python wie map() und filter().

Erweiterte Anwendungen: Sortieren und Transformieren von Dictionaries

Lassen Sie uns einige fortgeschrittenere Anwendungen von Lambda-Funktionen mit Dictionaries untersuchen, wobei wir uns auf das Sortieren und Transformieren von Dictionary-Daten konzentrieren.

Sortieren von Dictionaries mit Lambda-Funktionen

Dictionaries in Python sind standardmäßig nicht geordnet, aber manchmal müssen wir sie in einer bestimmten Reihenfolge verarbeiten. Lassen Sie uns eine neue Datei namens advanced_dictionary_ops.py im Verzeichnis /home/labex/project erstellen und den folgenden Code hinzufügen:

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

Führen Sie die Datei aus:

python3 advanced_dictionary_ops.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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}

In diesem Beispiel haben wir die Funktion sorted() mit Lambda-Funktionen verwendet, um das Dictionary auf verschiedene Arten zu sortieren:

• Nach Schlüssel (Schülername)
• Nach Wert (Punktzahl) in aufsteigender Reihenfolge
• Nach Wert (Punktzahl) in absteigender Reihenfolge

Wir haben auch Slicing [:3] verwendet, um nur die obersten 3 Schüler nach dem Sortieren zu erhalten.

Transformieren von Dictionary-Werten

Schauen wir uns nun an, wie wir die Werte in einem Dictionary transformieren können. Fügen Sie Ihrer Datei advanced_dictionary_ops.py den folgenden Code hinzu:

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)}")

Führen Sie die Datei erneut aus:

python3 advanced_dictionary_ops.py

Sie sollten nun eine zusätzliche Ausgabe sehen:

--- 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: Tokyo

In diesem Beispiel:

1. Wir haben Temperaturen von Celsius in Fahrenheit umgerechnet, indem wir eine Dictionary-Comprehension verwendet haben.
2. Wir haben Temperaturen als "Cool", "Moderate" oder "Warm" kategorisiert, indem wir eine Hilfsfunktion verwendet haben.
3. Wir haben die Funktion reduce() mit einem Lambda verwendet, um Städte nach Temperaturkategorie zu gruppieren.

Diese Techniken zeigen, wie Lambda-Funktionen komplexe Dictionary-Operationen prägnanter und lesbarer machen können. Wie Sie sehen, bietet die Kombination von Lambda-Funktionen mit den integrierten Funktionen von Python und Dictionary-Operationen leistungsstarke Werkzeuge für die Datenmanipulation.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie man Lambda-Funktionen verwendet, um Dictionary-Werte in Python zu aktualisieren. Wir haben Folgendes behandelt:

• Das Verständnis von Lambda-Funktionen und ihrer Syntax
• Arbeiten mit Dictionaries in Python
• Verwenden von Lambda-Funktionen, um Dictionary-Werte bedingt und unbedingt zu aktualisieren
• Erweiterte Anwendungen wie das Sortieren von Dictionaries und das Transformieren von Werten
• Kombinieren von Lambda-Funktionen mit den integrierten Funktionen von Python wie map(), filter() und reduce()

Diese Techniken helfen Ihnen, prägnanteren und lesbareren Code zu schreiben, wenn Sie mit Dictionaries in Python arbeiten. Auf Ihrem weiteren Weg mit Python werden Sie feststellen, dass Lambda-Funktionen zu einem immer wertvolleren Werkzeug in Ihrem Programmier-Toolkit werden, insbesondere für Aufgaben der Datenmanipulation.

Denken Sie daran, dass Lambda-Funktionen zwar leistungsstark sind, aber am besten für einfache Operationen geeignet sind. Für komplexere Logik sollten Sie in Erwägung ziehen, reguläre benannte Funktionen zu verwenden, um die Lesbarkeit und Wartbarkeit des Codes zu erhalten.