Exemples pratiques de fonctions lambda
Scénarios d'annotation de type pour les fonctions lambda dans le monde réel
from typing import List, Callable
def transformer_données(
données: List[int],
transformateur: Callable[[int], float]
) -> List[float]:
return list(map(transformateur, données))
## Fonction lambda avec des indications de type pour la mise à l'échelle des données
mettre_a_l_echelle = lambda x: int -> float: x * 1.5
nombres = [1, 2, 3, 4, 5]
nombres_mis_a_l_echelle = transformer_données(nombres, mettre_a_l_echelle)
Filtrer et valider
from typing import List, Callable, Optional
def filtrer_données(
éléments: List[int],
condition: Callable[[int], bool]
) -> List[int]:
return list(filter(condition, éléments))
## Fonction lambda pour filtrer les nombres pairs
est_pair = lambda x: int -> bool: x % 2 == 0
nombres = [1, 2, 3, 4, 5, 6]
nombres_pairs = filtrer_données(nombres, est_pair)
Trier avec des comparateurs personnalisés
from typing import List, Tuple, Callable
def tri_custom(
données: List[Tuple[str, int]],
fonction_clé: Callable[[Tuple[str, int]], int]
) -> List[Tuple[str, int]]:
return sorted(données, key=fonction_clé)
## Fonction lambda pour trier par le deuxième élément
trier_par_âge = lambda x: Tuple[str, int] -> int: x[1]
personnes = [('Alice', 30), ('Bob', 25), ('Charlie', 35)]
personnes_triées = tri_custom(personnes, trier_par_âge)
Modèles d'annotation de type pour les fonctions lambda
| Modèle |
Cas d'utilisation |
Exemple |
| Transformation simple |
Conversion de données |
lambda x: int -> float |
| Filtrer |
Vérification de condition |
lambda x: int -> bool |
| Clé de tri |
Comparaison personnalisée |
lambda x: Tuple[str, int] -> int |
| Validation |
Vérification d'entrée |
lambda x: str -> bool |
Gestion d'erreurs avec des indications de type
from typing import Optional, Callable
def division_sécurisée(
a: float,
b: float,
gestionnaire_erreur: Optional[Callable[[Exception], float]] = None
) -> float:
try:
return a / b
except ZeroDivisionError as e:
if gestionnaire_erreur:
return gestionnaire_erreur(e)
raise
## Gestionnaire d'erreur lambda
erreur_par_défaut = lambda e: Exception -> float: 0.0
résultat = division_sécurisée(10, 0, erreur_par_défaut)
Composition de fonctions lambda
from typing import Callable, TypeVar
T = TypeVar('T')
U = TypeVar('U')
V = TypeVar('V')
def composer(
f: Callable[[U], V],
g: Callable[[T], U]
) -> Callable[[T], V]:
return lambda x: T -> V: f(g(x))
## Exemple de composition de fonctions
doubler = lambda x: int -> int: x * 2
incrementer = lambda x: int -> int: x + 1
doubler_puis_incrementer = composer(incrementer, doubler)
Flux de contrôle de type pour les fonctions lambda
graph TD
A[Définition de la fonction lambda] --> B[Annotation de type]
B --> C{Vérificateur de type}
C --> |Valider les types| D[Contrôle à la compilation]
D --> E[Exécution au moment de l'exécution]
C --> |Incompatibilité de type| F[Lancer une erreur de type]
Meilleures pratiques pour les annotations de type de fonctions lambda
- Garder les fonctions lambda simples et concentrées
- Utiliser des indications de type claires et précises
- Préférer les fonctions nommées pour une logique complexe
- Utiliser des vérificateurs de type comme mypy
En appliquant ces exemples pratiques, les développeurs peuvent utiliser efficacement les indications de type avec les fonctions lambda dans leurs projets Python LabEx, améliorant ainsi la qualité et la lisibilité du code.
