Praktische Lambda-Beispiele
Echte Szenarien für Lambda-Typanmerkungen
Datenumwandlung
from typing import List, Callable
def transform_data(
data: List[int],
transformer: Callable[[int], float]
) -> List[float]:
return list(map(transformer, data))
## Lambda mit Typhinweisen für die Datenskalierung
scale_data = lambda x: int -> float: x * 1.5
numbers = [1, 2, 3, 4, 5]
scaled_numbers = transform_data(numbers, scale_data)
Filtern und Validierung
from typing import List, Callable, Optional
def filter_data(
items: List[int],
condition: Callable[[int], bool]
) -> List[int]:
return list(filter(condition, items))
## Lambda für das Filtern von geraden Zahlen
is_even = lambda x: int -> bool: x % 2 == 0
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter_data(numbers, is_even)
Sortieren mit benutzerdefinierten Vergleichsfunktionen
from typing import List, Tuple, Callable
def custom_sort(
data: List[Tuple[str, int]],
key_func: Callable[[Tuple[str, int]], int]
) -> List[Tuple[str, int]]:
return sorted(data, key=key_func)
## Lambda für das Sortieren nach dem zweiten Element
sort_by_age = lambda x: Tuple[str, int] -> int: x[1]
people = [('Alice', 30), ('Bob', 25), ('Charlie', 35)]
sorted_people = custom_sort(people, sort_by_age)
Lambda-Typanmerkungsmuster
| Muster |
Anwendungsfall |
Beispiel |
| Einfache Transformation |
Datenkonvertierung |
lambda x: int -> float |
| Filtern |
Bedingungsprüfung |
lambda x: int -> bool |
| Sortier-Schlüssel |
Benutzerdefinierter Vergleich |
lambda x: Tuple[str, int] -> int |
| Validierung |
Eingabeverifikation |
lambda x: str -> bool |
Fehlerbehandlung mit Typhinweisen
from typing import Optional, Callable
def safe_divide(
a: float,
b: float,
error_handler: Optional[Callable[[Exception], float]] = None
) -> float:
try:
return a / b
except ZeroDivisionError as e:
if error_handler:
return error_handler(e)
raise
## Lambda-Fehlerbehandler
default_error = lambda e: Exception -> float: 0.0
result = safe_divide(10, 0, default_error)
Lambda-Zusammensetzung
from typing import Callable, TypeVar
T = TypeVar('T')
U = TypeVar('U')
V = TypeVar('V')
def compose(
f: Callable[[U], V],
g: Callable[[T], U]
) -> Callable[[T], V]:
return lambda x: T -> V: f(g(x))
## Beispiel für die Funktionszusammensetzung
double = lambda x: int -> int: x * 2
increment = lambda x: int -> int: x + 1
double_then_increment = compose(increment, double)
Lambda-Typüberprüfungsverfahren
graph TD
A[Lambda-Definition] --> B[Typanmerkung]
B --> C{Typüberprüfer}
C --> |Überprüfe Typen| D[Kompilierzeitprüfung]
D --> E[Laufzeitausführung]
C --> |Typenmismatch| F[Wirf Typfehler]
Best Practices für Lambda-Typanmerkungen
- Halten Sie Lambdas einfach und fokussiert.
- Verwenden Sie klare und präzise Typhinweisen.
- Wählen Sie für komplexe Logik benannte Funktionen.
- Nutzen Sie Typüberprüfer wie mypy.
Durch die Anwendung dieser praktischen Beispiele können Entwickler in ihren LabEx-Python-Projekten effektiv Typhinweisen mit Lambda-Funktionen verwenden und die Codequalität und -Lesbarkeit verbessern.
