Pydantic: Pengakhiran pengesahan manual! ✨

Pydantic ialah perpustakaan pengurusan pengesahan data dan tetapan untuk Python. Ia menggunakan pembayang jenis Python untuk mengesahkan dan menghuraikan data, memastikan kod anda berfungsi dengan data berstruktur dan ditaip dengan betul. Dengan memanfaatkan struktur model seperti kelas data Python, Pydantic memudahkan untuk menentukan skema untuk data kompleks dan secara automatik mengesahkan serta mensiri/menyahserialisasikan data dengan cara Pythonic yang bersih. Mari terokai ciri utama:

Pengesahan Data

Sahkan data input secara automatik terhadap skema menggunakan pembayang jenis 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)

Apabila anda ingin menentukan model data, gunakan pydantic.BaseModel!

Pengesahan Fungsi

Pydantic menyediakan alatan berkuasa untuk mengesahkan bukan sahaja model data tetapi juga input dan output fungsi. Ini dicapai menggunakan penghias @validate_call, membolehkan anda menguatkuasakan pengesahan data yang ketat untuk hujah fungsi dan nilai pulangan. Jika argumen atau jenis pulangan yang disediakan tidak sepadan dengan jenis yang dijangkakan, Ralat Pengesahan akan dibangkitkan.

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)

Dengan mendayakan bendera validate_return dalam @validate_call, Pydantic juga akan mengesahkan nilai pulangan fungsi terhadap jenis pulangan beranotasinya. Ini memastikan fungsi mematuhi skema output yang dijangkakan.

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)

Menghuraikan

Pydantic boleh menghuraikan struktur bersarang yang kompleks, termasuk data JSON, ke dalam objek model.

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

Serialisasi dan Deserialisasi

Model Pydantic boleh disirikan ke dalam JSON atau kamus dan dibina semula.

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)

Pengesahan Fleksibel

Pengesahan data bukan pengesahan jenis paksa. Contohnya, jika anda mentakrifkan model dengan medan id, tarikh_terima dan keutamaan jenis int, bool dan datetime, anda boleh lulus:

• rentetan berangka sebagai id
• ISO-8601, UTC atau rentetan format tarikh lain sebagai tarikh_masa tamat
• 'ya'/'tidak', 'hidup'/'mati', 'benar'/'salah', 1/0 dsb. sebagai keutamaan

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)

Pengesahan Tersuai

Anda juga boleh menentukan logik pengesahan tersuai dalam model anda menggunakan pengesah. Mereka membenarkan anda menggunakan peraturan pengesahan yang lebih kompleks yang tidak boleh dinyatakan dengan mudah menggunakan jenis terbina dalam atau kekangan medan. Validator ditakrifkan melalui penghias field_validator atau objek Field. Anda boleh menghantar satu atau lebih nama medan kepada field_validator, untuk menentukan medan yang akan menggunakan validator ini atau '*' untuk menggunakan validator bagi setiap medan.

daripada menaip import Mana-mana
daripada Medan import pydantic, field_validator, EmailStr, BaseModel

Pengguna kelas(BaseModel):
    id: int
    nama pengguna: str = Medan(corak=r'^w $')
    e-mel: EmailStr
    umur: int = Medan(18, ge=14)
    is_active: bool = Benar
    peranan: senarai[str]

    # Tentukan pengesah yang dilaksanakan 'sebelum' penghuraian dalaman
    @field_validator('peranan', mod='sebelum')
    def _validate_roles(cls, value: Any):
        pulangkan value.split(',') jika nilai isinstance(value, str) else

pengguna = Pengguna(id=1, nama pengguna='john', e-mel='john@example.com', roles='pelajar,penyanyi')
cetak(pengguna) #>



<h2>
  
  
  Projek sumber terbuka
</h2>

<p>Terdapat banyak projek sumber terbuka yang dikuasakan oleh Pydantic. Mari teroka yang terbaik daripada mereka:</p>

<h3>
  
  
  FastAPI
</h3>

<p>Salah satu kes penggunaan Pydantic yang paling menonjol ialah dalam FastAPI, rangka kerja web moden untuk membina API dengan Python. FastAPI menggunakan model Pydantic secara meluas untuk pengesahan kandungan permintaan, parameter pertanyaan dan skema respons.</p>

• Sumber: https://github.com/fastapi/fastapi
• Dokumen: https://fastapi.tiangolo.com

Sensei

Walaupun FastAPI direka untuk membina API, Sensei direka untuk membungkus API ini dengan cepat dan mudah. Klien API yang dikuasakan oleh Sensei memastikan pengguna mereka akan mendapat model data yang berkaitan dan tidak akan mendapat ralat yang mengelirukan.

• Sumber: https://github.com/CrocoFactory/sensei
• Dokumen: https://sensei.crocofactory.dev

SQLModel dan Typer

SQLModel dan Typer ialah dua projek luar biasa yang dibangunkan oleh Sebastián Ramírez, pencipta FastAPI.

SQLModel ialah perpustakaan yang direka untuk menyelaraskan interaksi pangkalan data dalam aplikasi Python. Dibina di atas SQLAlchemy dan Pydantic, SQLModel menggabungkan kuasa ORM dengan kemudahan pengesahan dan siri data.

• Sumber: https://github.com/fastapi/sqlmodel
• Dokumen: https://sqlmodel.tiangolo.com

Typer ialah rangka kerja untuk mencipta aplikasi antara muka baris perintah (CLI) menggunakan Python. Ia memudahkan proses dengan menggunakan pembayang jenis Python untuk menjana arahan CLI dan teks bantuan yang mesra pengguna secara automatik.

• Sumber: https://github.com/fastapi/typer
• Dokumen: https://typer.tiangolo.com

Atas ialah kandungan terperinci Pydantic: Pengakhiran pengesahan manual! ✨. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!