Python で Pydantic を使用するためのベストプラクティス-Python チュートリアル-php.cn

Best Practices for Using Pydantic in Python

Pydantic は、型ヒントを使用してデータ検証を簡素化する Python ライブラリです。データの整合性を確保し、自動型チェックと検証を備えたデータモデルを簡単に作成する方法を提供します。

ソフトウェアアプリケーションでは、エラー、セキュリティ上の問題、予期しない動作を防ぐために、信頼性の高いデータ検証が非常に重要です。

このガイドでは、Python プロジェクトで Pydantic を使用するためのベストプラクティスを提供し、モデル定義、データ検証、エラー処理、パフォーマンスの最適化をカバーします。

Pydantic のインストール

Pydantic をインストールするには、Python パッケージインストーラーである pip を次のコマンドで使用します。

pip install pydantic

ログイン後にコピー

このコマンドは、Pydantic とその依存関係をインストールします。

基本的な使い方

BaseModel から継承するクラスを作成して、Pydantic モデルを作成します。 Python の型アノテーションを使用して各フィールドの型を指定します:

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str

ログイン後にコピー

Pydantic は、int、str、float、bool、list、dict などのさまざまなフィールドタイプをサポートしています。ネストされたモデルとカスタムタイプを定義することもできます:

from typing import List, Optional
from pydantic import BaseModel

class Address(BaseModel):
    street: str
    city: str
    zip_code: Optional[str] = None

class User(BaseModel):
    id: int
    name: str
    email: str
    age: Optional[int] = None
    addresses: List[Address]

ログイン後にコピー

Pydantic モデルを定義したら、必要なデータを指定してインスタンスを作成します。 Pydantic はデータを検証し、指定された要件を満たしていないフィールドがある場合はエラーを発生させます:

user = User(
    id=1,
    name="John Doe",
    email="john.doe@example.com",
    addresses=[{"street": "123 Main St", "city": "Anytown", "zip_code": "12345"}]
)

print(user)

# Output:
# id=1 name='John Doe' email='john.doe@example.com' age=None addresses=[Address(street='123 Main St', city='Anytown', zip_code='12345')]

ログイン後にコピー

Pydantic モデルの定義

Pydantic モデルは、Python の型アノテーションを使用してデータフィールドの型を定義します。

これらは、次のようなさまざまな組み込み型をサポートします。

プリミティブ型: str、int、float、bool
コレクションの種類: リスト、タプル、セット、辞書
オプションのタイプ: None にすることができるフィールドの入力モジュールからのオプション
共用体タイプ: フィールドを指定するための型付けモジュールからの共用体は、いくつかのタイプのいずれかになります

例:

from typing import List, Dict, Optional, Union
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    tags: List[str]
    metadata: Dict[str, Union[str, int, float]]

class Order(BaseModel):
    order_id: int
    items: List[Item]
    discount: Optional[float] = None

ログイン後にコピー

カスタムタイプ

組み込み型に加えて、Pydantic の conint、constr、およびその他の制約関数を使用してカスタム型を定義できます。

これらにより、文字列の長さの制限や整数の値の範囲など、追加の検証ルールを追加できます。

例:

from pydantic import BaseModel, conint, constr

class Product(BaseModel):
    name: constr(min_length=2, max_length=50)
    quantity: conint(gt=0, le=1000)
    price: float

product = Product(name="Laptop", quantity=5, price=999.99)

ログイン後にコピー

必須フィールドとオプションフィールド

デフォルトでは、明示的にオプションとしてマークされていない限り、Pydantic モデルのフィールドは必須です。

モデルのインスタンス化中に必須フィールドが欠落している場合、Pydantic は ValidationError を発生させます。

例:

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str

user = User(id=1, name="John Doe")


# Output
#  Field required [type=missing, input_value={'id': 1, 'name': 'John Doe'}, input_type=dict]

ログイン後にコピー

デフォルト値のあるオプションのフィールド

入力モジュールから Optional を使用し、デフォルト値を指定することで、フィールドをオプションにできます。

例:

from pydantic import BaseModel
from typing import Optional

class User(BaseModel):
    id: int
    name: str
    email: Optional[str] = None

user = User(id=1, name="John Doe")

ログイン後にコピー

この例では、電子メールはオプションであり、指定しない場合はデフォルトで「なし」になります。

入れ子になったモデル

Pydantic ではモデルを相互にネストできるため、複雑なデータ構造が可能になります。

ネストされたモデルは他のモデルのフィールドとして定義され、データの整合性と複数のレベルでの検証が保証されます。

例:

from pydantic import BaseModel
from typing import Optional, List


class Address(BaseModel):
    street: str
    city: str
    zip_code: Optional[str] = None

class User(BaseModel):
    id: int
    name: str
    email: str
    addresses: List[Address]

user = User(
    id=1,
    name="John Doe",
    email="john.doe@example.com",
    addresses=[{"street": "123 Main St", "city": "Anytown"}]
)

ログイン後にコピー

ネストされたデータを管理するためのベストプラクティス

ネストされたモデルを操作する場合、次のことが重要です:

各レベルでデータを検証する: 入れ子になったモデルごとに独自の検証ルールと制約があることを確認します。
明確で一貫した命名規則を使用します。これにより、データの構造がより読みやすく、保守しやすくなります。
モデルをシンプルに保ちます: 過度に複雑な入れ子構造を避けます。モデルが複雑すぎる場合は、より小さく、より管理しやすいコンポーネントに分割することを検討してください。

データの検証

Pydantic には、一般的なデータ検証タスクを自動的に処理する一連の組み込みバリデータが含まれています。

これらのバリデータには以下が含まれます:

型検証: フィールドが指定された型注釈 (例: int、str、list) と一致することを確認します。
範囲検証: conint、constr、confloat などの制約を使用して値の範囲と長さを強制します。
形式の検証: 電子メールアドレスを検証するための EmailStr などの特定の形式をチェックします。
コレクションの検証: コレクション内の要素 (リスト、辞書など) が指定された型と制約に準拠していることを確認します。

これらのバリデーターは、モデル内のデータの整合性と適合性を確保するプロセスを簡素化します。

組み込みバリデーターを示す例をいくつか示します:

pydantic import BaseModel、EmailStr、conint、constr から

class User(BaseModel):
    id: conint(gt=0)  # id must be greater than 0
    name: constr(min_length=2, max_length=50)  # name must be between 2 and 50 characters
    email: EmailStr  # email must be a valid email address
    age: conint(ge=18)  # age must be 18 or older

user = User(id=1, name="John Doe", email="john.doe@example.com", age=25)

ログイン後にコピー

この例では、User モデルは組み込みバリデータを使用して、ID が 0 より大きく、名前が 2 ～ 50 文字であること、電子メールが有効な電子メールアドレスであること、および年齢が 18 歳以上であることを確認します。
電子メール検証ツールを使用できるようにするには、pydantic に拡張機能をインストールする必要があります:

pip install pydantic[email]

ログイン後にコピー

Custom Validators

Pydantic allows you to define custom validators for more complex validation logic.

Custom validators are defined using the @field_validator decorator within your model class.

Example of a custom validator:

from pydantic import BaseModel, field_validator


class Product(BaseModel):
    name: str
    price: float

    @field_validator('price')
    def price_must_be_positive(cls, value):
        if value <= 0:
            raise ValueError('Price must be positive')
        return value

product = Product(name="Laptop", price=999.99)

ログイン後にコピー

Here, the price_must_be_positive validator ensures that the price field is a positive number.

Custom validators are registered automatically when you define them within a model using the @field_validator decorator. Validators can be applied to individual fields or across multiple fields.

Example of registering a validator for multiple fields:

from pydantic import BaseModel, field_validator


class Person(BaseModel):
    first_name: str
    last_name: str

    @field_validator('first_name', 'last_name')
    def names_cannot_be_empty(cls, value):
        if not value:
            raise ValueError('Name fields cannot be empty')
        return value

person = Person(first_name="John", last_name="Doe")

ログイン後にコピー

In this example, the names_cannot_be_empty validator ensures that both the first_name and last_name fields are not empty.

Using Config Classes

Pydantic models can be customized using an inner Config class.

This class allows you to set various configuration options that affect the model's behavior, such as validation rules, JSON serialization, and more.

Example of a Config class:

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str

    class Config:
        str_strip_whitespace = True  # Strip whitespace from strings
        str_min_length = 1  # Minimum length for any string field

user = User(id=1, name="  John Doe  ", email="john.doe@example.com")

print(user)

# Output:
# id=1 name='John Doe' email='john.doe@example.com'

ログイン後にコピー

In this example, the Config class is used to strip whitespace from string fields and enforce a minimum length of 1 for any string field.

Some common configuration options in Pydantic's Config class include:

str_strip_whitespace: Automatically strip leading and trailing whitespace from string fields.
str_min_length: Set a minimum length for any string field.
validate_default: Validate all fields, even those with default values.
validate_assignment: Enable validation on assignment to model attributes.
use_enum_values: Use the values of enums directly instead of the enum instances.
json_encoders: Define custom JSON encoders for specific types.

Error Handling

When Pydantic finds data that doesn't conform to the model's schema, it raises a ValidationError.

This error provides detailed information about the issue, including the field name, the incorrect value, and a description of the problem.

Here's an example of how default error messages are structured:

from pydantic import BaseModel, ValidationError, EmailStr

class User(BaseModel):
    id: int
    name: str
    email: EmailStr

try:
    user = User(id='one', name='John Doe', email='invalid-email')
except ValidationError as e:
    print(e.json())

# Output:
# [{"type":"int_parsing","loc":["id"],"msg":"Input should be a valid integer, unable to parse string as an integer","input":"one","url":"https://errors.pydantic.dev/2.8/v/int_parsing"},{"type":"value_error","loc":["email"],"msg":"value is not a valid email address: An email address must have an @-sign.","input":"invalid-email","ctx":{"reason":"An email address must have an @-sign."},"url":"https://errors.pydantic.dev/2.8/v/value_error"}]

ログイン後にコピー

In this example, the error message will indicate that id must be an integer and email must be a valid email address.

Customizing Error Messages

Pydantic allows you to customize error messages for specific fields by raising exceptions with custom messages in validators or by setting custom configurations.

Here’s an example of customizing error messages:

from pydantic import BaseModel, ValidationError, field_validator

class Product(BaseModel):
    name: str
    price: float

    @field_validator('price')
    def price_must_be_positive(cls, value):
        if value <= 0:
            raise ValueError('Price must be a positive number')
        return value

try:
    product = Product(name='Laptop', price=-1000)
except ValidationError as e:
    print(e.json())

# Output:
# [{"type":"value_error","loc":["price"],"msg":"Value error, Price must be a positive number","input":-1000,"ctx":{"error":"Price must be a positive number"},"url":"https://errors.pydantic.dev/2.8/v/value_error"}]

ログイン後にコピー

In this example, the error message for price is customized to indicate that it must be a positive number.

Best Practices for Error Reporting

Effective error reporting involves providing clear, concise, and actionable feedback to users or developers.

Here are some best practices:

Log errors: Use logging mechanisms to record validation errors for debugging and monitoring purposes.
Return user-friendly messages: When exposing errors to end-users, avoid technical jargon. Instead, provide clear instructions on how to correct the data.
Aggregate errors: When multiple fields are invalid, aggregate the errors into a single response to help users correct all issues at once.
Use consistent formats: Ensure that error messages follow a consistent format across the application for easier processing and understanding.

Examples of best practices in error reporting:

from pydantic import BaseModel, ValidationError, EmailStr
import logging

logging.basicConfig(level=logging.INFO)

class User(BaseModel):
    id: int
    name: str
    email: EmailStr

def create_user(data):
    try:
        user = User(**data)
        return user
    except ValidationError as e:
        logging.error("Validation error: %s", e.json())
        return {"error": "Invalid data provided", "details": e.errors()}

user_data = {'id': 'one', 'name': 'John Doe', 'email': 'invalid-email'}
response = create_user(user_data)
print(response)

# Output:
# ERROR:root:Validation error: [{"type":"int_parsing","loc":["id"],"msg":"Input should be a valid integer, unable to parse string as an integer","input":"one","url":"https://errors.pydantic.dev/2.8/v/int_parsing"},{"type":"value_error","loc":["email"],"msg":"value is not a valid email address: An email address must have an @-sign.","input":"invalid-email","ctx":{"reason":"An email address must have an @-sign."},"url":"https://errors.pydantic.dev/2.8/v/value_error"}]
# {'error': 'Invalid data provided', 'details': [{'type': 'int_parsing', 'loc': ('id',), 'msg': 'Input should be a valid integer, unable to parse string as an integer', 'input': 'one', 'url': 'https://errors.pydantic.dev/2.8/v/int_parsing'}, {'type': 'value_error', 'loc': ('email',), 'msg': 'value is not a valid email address: An email address must have an @-sign.', 'input': 'invalid-email', 'ctx': {'reason': 'An email address must have an @-sign.'}}]}

ログイン後にコピー

In this example, validation errors are logged, and a user-friendly error message is returned, helping maintain application stability and providing useful feedback to the user.

Performance Considerations

Lazy initialization is a technique that postpones the creation of an object until it is needed.

In Pydantic, this can be useful for models with fields that are costly to compute or fetch. By delaying the initialization of these fields, you can reduce the initial load time and improve performance.

Example of lazy initialization:

from pydantic import BaseModel
from functools import lru_cache

class DataModel(BaseModel):
    name: str
    expensive_computation: str = None

    @property
    @lru_cache(maxsize=1)
    def expensive_computation(self):
        # Simulate an expensive computation
        result = "Computed Value"
        return result

data_model = DataModel(name="Test")
print(data_model.expensive_computation)

ログイン後にコピー

In this example, the expensive_computation field is computed only when accessed for the first time, reducing unnecessary computations during model initialization.

Redundant Validation

Pydantic models automatically validate data during initialization.

However, if you know that certain data has already been validated or if validation is not necessary in some contexts, you can disable validation to improve performance.

This can be done using the model_construct method, which bypasses validation:

Example of avoiding redundant validation:

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str

# Constructing a User instance without validation
data = {'id': 1, 'name': 'John Doe', 'email': 'john.doe@example.com'}
user = User.model_construct(**data)

ログイン後にコピー

In this example, User.model_construct is used to create a User instance without triggering validation, which can be useful in performance-critical sections of your code.

Efficient Data Parsing

When dealing with large datasets or high-throughput systems, efficiently parsing raw data becomes critical.

Pydantic provides the model_validate_json method, which can be used to parse JSON or other serialized data formats directly into Pydantic models.

Example of efficient data parsing:

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str

json_data = '{"id": 1, "name": "John Doe", "email": "john.doe@example.com"}'
user = User.model_validate_json(json_data)
print(user)

ログイン後にコピー

In this example, model_validate_json is used to parse JSON data into a User model directly, providing a more efficient way to handle serialized data.

Controlling Validation

Pydantic models can be configured to validate data only when necessary.

The validate_default and validate_assignment options in the Config class control when validation occurs, which can help improve performance:

validate_default: When set to False, only fields that are set during initialization are validated.
validate_assignment: When set to True, validation is performed on field assignment after the model is created.

Example configuration:

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str

    class Config:
        validate_default = False  # Only validate fields set during initialization
        validate_assignment = True  # Validate fields on assignment

user = User(id=1, name="John Doe", email="john.doe@example.com")
user.email = "new.email@example.com"  # This assignment will trigger validation

ログイン後にコピー

In this example, validate_default is set to False to avoid unnecessary validation during initialization, and validate_assignment is set to True to ensure that fields are validated when they are updated.

Settings Management

Pydantic's BaseSettings class is designed for managing application settings, supporting environment variable loading and type validation.

This helps in configuring applications for different environments (e.g., development, testing, production).

Consider this .env file:

database_url=db
secret_key=sk
debug=False

ログイン後にコピー

Example of using BaseSettings:

from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    database_url: str
    secret_key: str
    debug: bool = False

    class Config:
        env_file = ".env"

settings = Settings()
print(settings.model_dump())

# Output:
# {'database_url': 'db', 'secret_key': 'sk', 'debug': False}

ログイン後にコピー

In this example, settings are loaded from environment variables, and the Config class specifies that variables can be loaded from a .env file.

For using BaseSettings you will need to install an additional package:

pip install pydantic-settings

ログイン後にコピー

Managing settings effectively involves a few best practices:

Use environment variables: Store configuration values in environment variables to keep sensitive data out of your codebase.
Provide defaults: Define sensible default values for configuration settings to ensure the application runs with minimal configuration.
Separate environments: Use different configuration files or environment variables for different environments (e.g., .env.development, .env.production).
Validate settings: Use Pydantic's validation features to ensure all settings are correctly typed and within acceptable ranges.

Common Pitfalls and How to Avoid Them

One common mistake when using Pydantic is misapplying type annotations, which can lead to validation errors or unexpected behavior.

Here are a few typical mistakes and their solutions:

Misusing Union Types: Using Union incorrectly can complicate type validation and handling.
Optional Fields without Default Values: Forgetting to provide a default value for optional fields can lead to None values causing errors in your application.
Incorrect Type Annotations: Assigning incorrect types to fields can cause validation to fail. For example, using str for a field that should be an int.

Ignoring Performance Implications

Ignoring performance implications when using Pydantic can lead to slow applications, especially when dealing with large datasets or frequent model instantiations.

Here are some strategies to avoid performance bottlenecks:

Leverage Configuration Options: Use Pydantic's configuration options like validate_default and validate_assignment to control when validation occurs.
Optimize Nested Models: When working with nested models, ensure that you are not over-validating or duplicating validation logic.
Use Efficient Parsing Methods: Utilize model_validate_json and model_validate for efficient data parsing.
Avoid Unnecessary Validation: Use the model_construct method to create models without validation when the data is already known to be valid.