Exemples pratiques d'annotation
Scénarios d'annotation de type dans le monde réel
Fonctions de traitement de données
from typing import List, Dict, Optional
def filter_valid_users(users: List[Dict[str, str]]) -> List[Dict[str, str]]:
return [user for user in users if user.get('email')]
def calculate_average(numbers: List[float]) -> Optional[float]:
return sum(numbers) / len(numbers) if numbers else None
Interaction API et réseau
from typing import Union, Dict, Any
def fetch_api_data(endpoint: str) -> Union[Dict[str, Any], None]:
try:
## Simulated API request
return {"status": "success", "data": [1, 2, 3]}
except Exception:
return None
Gestion des erreurs et annotations de type
from typing import Tuple, Union
def divide_numbers(a: float, b: float) -> Union[float, str]:
try:
return a / b
except ZeroDivisionError:
return "Division by zero error"
Comparaison des stratégies d'annotation
| Scénario |
Type de retour |
Stratégie d'annotation |
Complexité |
| Calcul simple |
Numérique |
Type direct |
Faible |
| Filtrage de données |
Liste |
Type générique |
Moyenne |
| Gestion des erreurs |
Union |
Plusieurs retours possibles |
Élevée |
Flux d'annotation de type
graph TD
A[Function Input] --> B{Process Data}
B --> C{Validate Return}
C --> |Valid Type| D[Return Annotated Result]
C --> |Type Mismatch| E[Raise Type Error]
Techniques d'annotation avancées
from typing import Callable, TypeVar
T = TypeVar('T')
R = TypeVar('R')
def apply_transform(
data: List[T],
transformer: Callable[[T], R]
) -> List[R]:
return [transformer(item) for item in data]
Annotations de type pour les décorateurs
from typing import Callable, Any
def log_return(func: Callable[..., Any]) -> Callable[..., Any]:
def wrapper(*args: Any, **kwargs: Any) -> Any:
result = func(*args, **kwargs)
print(f"Function returned: {result}")
return result
return wrapper
@log_return
def example_function(x: int) -> str:
return str(x * 2)
Bonnes pratiques
- Utilisez des annotations de type précises
- Gérez les cas limites potentiels
- Exploitez les capacités du module
typing
- Pensez à la validation de type à l'exécution
Conseil LabEx
Explorez des scénarios d'annotation de type complexes dans les environnements Python LabEx pour améliorer vos compétences en indication de type.
Défis courants
- Équilibrer la spécificité et la flexibilité des types
- Gérer les scénarios de type de retour complexes
- Maintenir la lisibilité des indices de type
- Intégrer avec les bases de code existantes
