Pydantic ist eine Datenvalidierungs- und Einstellungsverwaltungsbibliothek für Python. Es verwendet Python-Typhinweise zum Validieren und Analysieren von Daten und stellt so sicher, dass Ihr Code mit ordnungsgem?? strukturierten und typisierten Daten funktioniert. Durch die Nutzung der datenklassen?hnlichen Modellstruktur von Python erleichtert Pydantic die Definition von Schemata für komplexe Daten und die automatische Validierung und Serialisierung/Deserialisierung von Daten auf saubere, pythonische Weise. Lassen Sie uns die Hauptfunktionen erkunden:

Datenvalidierung

Automatische Validierung von Eingabedaten anhand eines Schemas mithilfe der Typhinweise von 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)

Wenn Sie ein Datenmodell definieren m?chten, verwenden Sie pydantic.BaseModel!

Funktionsvalidierung

Pydantic bietet leistungsstarke Tools zur Validierung nicht nur von Datenmodellen, sondern auch der Eingabe und Ausgabe von Funktionen. Dies wird mithilfe des @validate_call-Dekorators erreicht, der es Ihnen erm?glicht, eine strikte Datenvalidierung für Funktionsargumente und Rückgabewerte zu erzwingen. Wenn die bereitgestellten Argumente oder der Rückgabetyp nicht mit den erwarteten Typen übereinstimmen, wird ein ValidationError ausgel?st.

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)

Durch die Aktivierung des Flags ?validate_return“ in @validate_call validiert Pydantic auch den Rückgabewert der Funktion anhand ihres annotierten Rückgabetyps. Dadurch wird sichergestellt, dass die Funktion dem erwarteten Ausgabeschema entspricht.

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)

Parsing

Pydantic kann komplexe verschachtelte Strukturen, einschlie?lich JSON-Daten, in Modellobjekte analysieren.

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

Serialisierung und Deserialisierung

Pydantische Modelle k?nnen in JSON oder W?rterbücher serialisiert und wieder rekonstruiert werden.

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)

Flexible Validierung

Die Datenvalidierung ist keine erzwungene Validierung. Wenn Sie beispielsweise ein Modell mit ID-, Due_Date- und Priority-Feldern der Typen int, bool bzw. datetime definieren, k?nnen Sie Folgendes übergeben:

• numerische Zeichenfolge als ID
• ISO-8601, UTC oder Zeichenfolgen der anderen Datumsformate als due_date
• 'ja'/'nein', 'an'/'aus', 'wahr'/'falsch', 1/0 usw. als Priorit?t

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)

Benutzerdefinierte Validierung

Sie k?nnen mithilfe von Validatoren auch eine benutzerdefinierte Validierungslogik in Ihrem Modell definieren. Sie erm?glichen Ihnen die Anwendung komplexerer Validierungsregeln, die mit den integrierten Typen oder Feldeinschr?nkungen nicht einfach ausgedrückt werden k?nnen. Der Validator wird über den Field_validator-Dekorator oder das Field-Objekt definiert. Sie k?nnen einen oder mehrere Feldnamen an field_validator übergeben, um zu bestimmen, welche Felder diesen Validator verwenden, oder ?*“, um den Validator für jedes Feld anzuwenden.

aus der Eingabe von import Any
aus pydantic import Field, field_validator, EmailStr, BaseModel

Klasse User(BaseModel):
    ID: int
    Benutzername: str = Field(pattern=r'^w $')
    E-Mail: EmailStr
    Alter: int = Field(18, ge=14)
    is_active: bool = True
    Rollen: list[str]

    # Definieren Sie den Validator, der ?vor“ der internen Analyse ausgeführt wird
    @field_validator('roles', mode='before')
    def _validate_roles(cls, Wert: Beliebig):
        Rückgabewert.split(',') wenn isinstance(value, str) else value

user = User(id=1, username='john', email='john@example.com', Roles='student,singer')
print(user) #>



<h2>
  
  
  Open-Source-Projekte
</h2>

<p>Es gibt viele Open-Source-Projekte, die von Pydantic unterstützt werden. Entdecken wir die besten davon:</p>

<h3>
  
  
  FastAPI
</h3>

<p>Einer der bekanntesten Anwendungsf?lle von Pydantic ist FastAPI, ein modernes Web-Framework zum Erstellen von APIs mit Python. FastAPI verwendet Pydantic-Modelle ausgiebig für die Validierung des Anforderungstexts, Abfrageparameter und Antwortschemata.</p>

• Quelle: https://github.com/fastapi/fastapi
• Dokumente: https://fastapi.tiangolo.com

Sensei

W?hrend FastAPI für die Erstellung von APIs konzipiert ist, ist Sensei dafür konzipiert, diese APIs schnell und einfach zu verpacken. Von Sensei betriebene API-Clients stellen sicher, dass Benutzer relevante Datenmodelle erhalten und keine verwirrenden Fehler erhalten.

• Quelle: https://github.com/CrocoFactory/sensei
• Dokumente: https://sensei.crocofactory.dev

SQLModel und Typer

SQLModel und Typer sind zwei bemerkenswerte Projekte, die von Sebastián Ramírez, dem Erfinder von FastAPI, entwickelt wurden.

SQLModel ist eine Bibliothek zur Optimierung von Datenbankinteraktionen in Python-Anwendungen. SQLModel basiert auf SQLAlchemy und Pydantic und kombiniert die Leistungsf?higkeit eines ORM mit dem Komfort der Datenvalidierung und Serialisierung.

• Quelle: https://github.com/fastapi/sqlmodel
• Dokumente: https://sqlmodel.tiangolo.com

Typer ist ein Framework zum Erstellen von Befehlszeilenschnittstellenanwendungen (CLI) mit Python. Es vereinfacht den Prozess, indem es die Typhinweise von Python verwendet, um automatisch benutzerfreundliche CLI-Befehle und Hilfetexte zu generieren.

• Quelle: https://github.com/fastapi/typer
• Dokumente: https://typer.tiangolo.com

Das obige ist der detaillierte Inhalt vonPydantic: Das Ende der manuellen Validierungen! ?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!