Pydantic est une bibliothèque de validation de données et de gestion des paramètres pour Python. Il utilise des indices de type Python pour valider et analyser les données, garantissant ainsi que votre code fonctionne avec des données correctement structurées et typées. En tirant parti de la structure de modèle de type classe de données de Python, Pydantic facilite la définition de schémas pour les données complexes et valide et sérialise/désérialise automatiquement les données d'une manière Pythonique propre. Explorons les principales fonctionnalités :
Validez automatiquement les données d'entrée par rapport à un schéma à l'aide des astuces de type Python.
from pydantic import BaseModel, ValidationError
class User(BaseModel):
id: int
name: str
email: str
# Valid input
user = User(id=1, name="John Doe", email="john@example.com")
print(user)
# Invalid input
try:
user = User(id="not-an-integer", name="Jane", email="jane@example.com")
except ValidationError as err:
print(err)
Chaque fois que vous souhaitez définir un modèle de données, utilisez pydantic.BaseModel !
Pydantic fournit des outils puissants pour valider non seulement les modèles de données, mais également les entrées et sorties des fonctions. Ceci est réalisé à l'aide du décorateur @validate_call, vous permettant d'appliquer une validation stricte des données pour les arguments de fonction et les valeurs de retour. Si les arguments fournis ou le type de retour ne correspondent pas aux types attendus, une ValidationError est levée.
from pydantic import validate_call
@validate_call
def greet(name: str, age: int) -> str:
return f"Hello {name}, you are {age} years old."
# Valid input
print(greet("Alice", 30)) # Output: Hello Alice, you are 30 years old.
# Invalid input
try:
greet("Bob", "not-a-number")
except Exception as e:
print(e)
En activant l'indicateur validate_return dans @validate_call, Pydantic validera également la valeur de retour de la fonction par rapport à son type de retour annoté. Cela garantit que la fonction adhère au schéma de sortie attendu.
from pydantic import validate_call
@validate_call(validate_return=True)
def calculate_square(number: int) -> int:
return number ** 2 # Correct return type
# Valid input and return
print(calculate_square(4)) # Output: 16
# Invalid return value
@validate_call(validate_return=True)
def broken_square(number: int) -> int:
return str(number ** 2) # Incorrect return type
try:
broken_square(4)
except Exception as e:
print(e)
Pydantic peut analyser des structures imbriquées complexes, y compris des données JSON, dans des objets de modèle.
from pydantic import BaseModel
from typing import List
class Item(BaseModel):
name: str
price: float
class Order(BaseModel):
items: List[Item]
total: float
# JSON-like data
data = {
"items": [
{"name": "Apple", "price": 1.2},
{"name": "Banana", "price": 0.8}
],
"total": 2.0
}
order = Order(**data)
print(order) # items=[Item(name='Apple', price=1.2), Item(name='Banana', price=0.8)] total=2.0
Les modèles Pydantic peuvent être sérialisés en JSON ou dans des dictionnaires et reconstruits.
from pydantic import BaseModel
class User(BaseModel):
id: int
name: str
email: str
# Create a model instance
user = User(id=1, name="Alice", email="alice@example.com")
# Serialize to dictionary and JSON
user_dict = user.model_dump()
user_json = user.model_dump(mode='json')
print("Dictionary:", user_dict)
print("JSON:", user_json)
# Deserialize back to the model
new_user = User.model_validate(user_json)
print("Parsed User:", new_user)
La validation des données n'est pas une validation de type force. Par exemple, si vous définissez un modèle avec des champs id, due_date et priorité de types int, bool et datetime respectivement, vous pouvez transmettre :
from sensei import APIModel
from datetime import datetime
class Task(APIModel):
id: int
due_date: datetime
priority: bool
task = Task(due_date='2024-10-15T15:30:00',>
<p>The result will be<br>
</p>
<pre class="brush:php;toolbar:false">Task(id=1, due_date=datetime.datetime(2024, 10, 15, 15, 30), priority=True)
Vous pouvez également définir une logique de validation personnalisée dans votre modèle à l'aide de validateurs. Ils vous permettent d'appliquer des règles de validation plus complexes qui ne peuvent pas être facilement exprimées à l'aide des types intégrés ou des contraintes de champ. Le validateur est défini via le décorateur field_validator ou l'objet Field. Vous pouvez transmettre un ou plusieurs noms de champs à field_validator, pour déterminer quels champs utiliseront ce validateur, ou '*' pour appliquer le validateur à chaque champ.
en tapant import Any
à partir de l'importation pydantic Field, field_validator, EmailStr, BaseModel
Utilisateur de classe (BaseModel):
identifiant : int
nom d'utilisateur : str = Field(pattern=r'^w $')
email : EmailStr
âge : int = Champ (18, ge = 14)
is_active : bool = Vrai
rôles : liste[str]
# Définir le validateur exécuté 'avant' l'analyse interne
@field_validator('roles', mode='avant')
def _validate_roles (cls, valeur : Any) :
return value.split(',') si isinstance(value, str) sinon valeur
utilisateur = Utilisateur (id = 1, nom d'utilisateur = 'john', email = 'john@example.com', rôles = 'étudiant, chanteur')
imprimer (utilisateur) #>
<h2>
Projets open source
</h2>
<p>Il existe de nombreux projets open source alimentés par Pydantic. Explorons les meilleurs d'entre eux :</p>
<h3>
API rapide
</h3>
<p>L'un des cas d'utilisation les plus importants de Pydantic concerne FastAPI, un framework Web moderne permettant de créer des API avec Python. FastAPI utilise largement les modèles Pydantic pour la validation du corps de la requête, les paramètres de requête et les schémas de réponse.</p>
Alors que FastAPI est conçu pour créer des API, Sensei est conçu pour envelopper ces API rapidement et facilement. Les clients API alimentés par Sensei garantissent aux utilisateurs qu'ils obtiendront des modèles de données pertinents et n'obtiendront pas d'erreurs déroutantes.
SQLModel et Typer sont deux projets remarquables développés par Sebastián Ramírez, le créateur de FastAPI.
SQLModel est une bibliothèque conçue pour rationaliser les interactions avec les bases de données dans les applications Python. Construit sur SQLAlchemy et Pydantic, SQLModel combine la puissance d'un ORM avec la commodité de la validation et de la sérialisation des données.
Typer est un framework permettant de créer des applications d'interface de ligne de commande (CLI) à l'aide de Python. Il simplifie le processus en utilisant les astuces de type Python pour générer automatiquement des commandes CLI conviviales et un texte d'aide.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Code écran bleu de l'ordinateur 0xc0000225
Trois formes d'instructions conditionnelles
Collection de codes d'images HTML
Quelles sont les différences entre le pool de threads Spring et le pool de threads JDK ?
Vérificateur de compatibilité
Comment utiliser la fonction de tri
Comment obtenir l'heure actuelle en JAVA
Récupérer les données du disque dur mobile
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
