Validation pratique de type
Aperçu des techniques de validation de type
La validation de type garantit l'intégrité des données et prévient les erreurs à l'exécution en vérifiant systématiquement les types et les structures des entrées.
Stratégies de validation complètes
1. Validation de classe de données
from dataclasses import dataclass
from typing import List
import re
@dataclass
class User:
name: str
email: str
age: int
skills: List[str]
def __post_init__(self):
## Custom validation logic
if not re.match(r"[^@]+@[^@]+\.[^@]+", self.email):
raise ValueError("Invalid email format")
if self.age < 18:
raise ValueError("User must be 18 or older")
if len(self.skills) == 0:
raise ValueError("At least one skill is required")
## Example usage
try:
user = User(
name="LabEx Developer",
email="[email protected]",
age=25,
skills=["Python", "Data Science"]
)
except ValueError as e:
print(f"Validation Error: {e}")
2. Validation de modèle Pydantic
from pydantic import BaseModel, validator, EmailStr
from typing import List
class AdvancedUser(BaseModel):
name: str
email: EmailStr
age: int
skills: List[str]
@validator('age')
def validate_age(cls, age):
if age < 18:
raise ValueError("Must be 18 or older")
return age
@validator('skills')
def validate_skills(cls, skills):
if len(skills) < 1:
raise ValueError("At least one skill required")
return skills
## Validation example
try:
user = AdvancedUser(
name="LabEx Developer",
email="[email protected]",
age=25,
skills=["Python", "Machine Learning"]
)
except ValueError as e:
print(f"Validation Error: {e}")
Comparaison des techniques de validation
| Technique |
Avantages |
Inconvénients |
Cas d'utilisation |
| Validation manuelle |
Contrôle total |
Verbeux |
Scénarios simples |
| Classes de données |
Intégré à Python |
Validation limitée |
Données structurées |
| Pydantic |
Complet |
Dépendance externe |
Validation complexe |
Diagramme de flux de validation
graph TD
A[Input Data] --> B{Structural Check}
B --> |Pass| C{Type Check}
B --> |Fail| D[Reject Data]
C --> |Pass| E{Custom Validation}
C --> |Fail| F[Reject Data]
E --> |Pass| G[Accept Data]
E --> |Fail| H[Reject Data]
Modèles de validation avancés
Décorateur de validation personnalisé
from functools import wraps
from typing import Callable, Any
def validate_types(*type_args, **type_kwargs):
def decorator(func: Callable):
@wraps(func)
def wrapper(*args, **kwargs):
## Validate positional arguments
for arg, expected_type in zip(args, type_args):
if not isinstance(arg, expected_type):
raise TypeError(f"Expected {expected_type}, got {type(arg)}")
## Validate keyword arguments
for key, value in kwargs.items():
if key in type_kwargs:
expected_type = type_kwargs[key]
if not isinstance(value, expected_type):
raise TypeError(f"Expected {expected_type} for {key}, got {type(value)}")
return func(*args, **kwargs)
return wrapper
return decorator
@validate_types(str, int, name=str)
def create_profile(username: str, age: int, name: str):
return f"{name} (Age: {age})"
## Usage examples
try:
profile = create_profile("developer", 25, name="LabEx")
print(profile)
except TypeError as e:
print(f"Validation Error: {e}")
Bonnes pratiques pour la validation de type
- Utilisez les indications de type de manière cohérente
- Implémentez une logique de validation complète
- Fournissez des messages d'erreur clairs
- Équilibrez la stricte et la flexibilité
- Choisissez les techniques de validation appropriées
- Minimisez la complexité de la validation
- Utilisez des bibliothèques de validation efficaces
- Implémentez une validation paresseuse lorsque cela est possible
- Analysez et optimisez la logique de validation
En mettant en œuvre une validation de type robuste, les développeurs peuvent créer des applications Python plus fiables et auto-documentées avec une intégrité des données améliorée.
