FastAPI Backend Development Bootcamp · 강의

Pydantic 필드 검증 및 검증기

고급 필드 검증 옵션을 살펴보고 복잡한 비즈니스 규칙을 위한 사용자 지정 검증기를 만듭니다.

Pydantic 필드 검증 및 검증기은(는) CoddyKit의 무료 FastAPI Backend Development Bootcamp 강의입니다. 이것은 4개 중 1번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 FastAPI Backend Development Bootcamp 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. FastAPI Backend Development Bootcamp 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Why Validate with Pydantic?

Pydantic automatically validates data types in your models. But sometimes, you need more specific rules, like a minimum length for a username or a positive age.

This is where field validation and custom validators come in! They ensure your data meets all your application's business rules, making your APIs more reliable.

Using Pydantic's `Field` Function

Pydantic's Field function allows you to add extra validation rules and metadata to model fields. It's imported from pydantic. Let's see how to enforce a minimum and maximum length for a string.

from pydantic import BaseModel, Field

class User(BaseModel):
    username: str = Field(min_length=3, max_length=15)
    age: int

# Valid
try:
    user1 = User(username="coddy", age=25)
    print(f"Valid username: {user1.username}")
except Exception as e:
    print(e)

# Invalid username (too short)
try:
    user2 = User(username="c", age=30)
except Exception as e:
    print(f"Error: {e}")

Numeric Field Rules

For numbers, Field offers powerful comparison validators:

gt (greater than)
lt (less than)
ge (greater than or equal to)
le (less than or equal to)

Use them to define valid ranges for numeric data, ensuring values are always within expected bounds.

from pydantic import BaseModel, Field

class Product(BaseModel):
    name: str
    price: float = Field(gt=0, le=1000) # Price > 0 and <= 1000
    stock: int = Field(ge=0) # Stock >= 0

# Valid
try:
    product1 = Product(name="Book", price=19.99, stock=100)
    print(f"{product1.name} price: {product1.price}")
except Exception as e:
    print(e)

# Invalid price (negative)
try:
    product2 = Product(name="Pen", price=-5.0, stock=50)
except Exception as e:
    print(f"Error: {e}")

Regex for Field Validation

The pattern argument in Field allows you to validate string fields against a regular expression. This is great for enforcing specific formats, like product codes, serial numbers, or complex identifiers.

from pydantic import BaseModel, Field

class ItemCode(BaseModel):
    # Code must be three uppercase letters, a hyphen, then four digits
    code: str = Field(pattern=r"^[A-Z]{3}-\d{4}$") # e.g., ABC-1234

# Valid
try:
    item1 = ItemCode(code="XYZ-9876")
    print(f"Valid code: {item1.code}")
except Exception as e:
    print(f"Error: {e}")

# Invalid format (lowercase letters)
try:
    item2 = ItemCode(code="abc-1234")
except Exception as e:
    print(f"Error: {e}")

Crafting Custom Validators

While Field covers many common cases, sometimes you need more complex validation logic that involves custom Python code. This is where Pydantic's @validator decorator shines.

You can define a method within your BaseModel and decorate it with @validator('field_name') to apply custom logic to that specific field.

Custom Logic for Fields

Let's create a custom validator to ensure a password field meets specific complexity requirements, like containing at least one digit. The validator function receives the field's value as an argument.

from pydantic import BaseModel, validator
import re

class UserAuth(BaseModel):
    username: str
    password: str

    @validator('password')
    def password_has_digit(cls, v):
        if not re.search(r"\d", v):
            raise ValueError('password must contain at least one digit')
        return v

# Valid
try:
    user1 = UserAuth(username="coder", password="MySecureP@ss1")
    print(f"Password OK for {user1.username}")
except Exception as e:
    print(f"Error: {e}")

# Invalid password (no digits)
try:
    user2 = UserAuth(username="test", password="NoDigitsHere!")
except Exception as e:
    print(f"Error: {e}")

Data Transformation with `pre=True`

Sometimes, you need to transform or clean incoming data before Pydantic's standard type validation or other validators run. For this, use @validator('field_name', pre=True).

A common use case is stripping whitespace or converting case before validating the content, ensuring consistency.

from pydantic import BaseModel, validator

class SearchQuery(BaseModel):
    query: str

    @validator('query', pre=True)
    def strip_whitespace(cls, v):
        if isinstance(v, str):
            return v.strip()
        return v # Pydantic will handle type validation later

# Input with leading/trailing spaces
query1 = SearchQuery(query="   python tutorial   ")
print(f"Cleaned query: '{query1.query}'")

# Input without spaces
query2 = SearchQuery(query="fastapi")
print(f"Cleaned query: '{query2.query}'")

Stacking Field Validators

You can apply multiple @validator decorators to a single field. They will execute in the order they are defined. This allows you to chain validation logic, making your models robust.

For list fields, use each_item=True to apply the validator to every element in the list.

from pydantic import BaseModel, validator

class TagList(BaseModel):
    tags: list[str]

    @validator('tags', each_item=True)
    def tag_must_be_lowercase(cls, v):
        if v != v.lower():
            raise ValueError('tag must be lowercase')
        return v

    @validator('tags', each_item=True)
    def tag_min_length(cls, v):
        if len(v) < 2:
            raise ValueError('tag must be at least 2 chars')
        return v

# Valid
try:
    tags1 = TagList(tags=["python", "fastapi"])
    print(f"Tags OK: {tags1.tags}")
except Exception as e:
    print(f"Error: {e}")

# Invalid (uppercase and too short)
try:
    tags2 = TagList(tags=["PY", "a"])
except Exception as e:
    print(f"Error: {e}")

Cross-Field Validation with Root Validators

Sometimes, the validity of one field depends on the value of another field (or multiple others). This is called cross-field validation. Pydantic's @root_validator allows you to validate the entire model's data dictionary at once.

It's useful for scenarios like ensuring a start_date is before an end_date, or that password and confirm_password match.

Root Validator in Action

The @root_validator receives the entire model's data as a dictionary. You can use pre=True or pre=False (default) to run before or after field-specific validation. Post-validation (default) is usually preferred for cross-field checks.

from pydantic import BaseModel, root_validator, ValidationError

class Registration(BaseModel):
    email: str
    password: str
    password_confirm: str

    @root_validator()
    def passwords_match(cls, values):
        pw1, pw2 = values.get('password'), values.get('password_confirm')
        if pw1 is not None and pw2 is not None and pw1 != pw2:
            raise ValueError('passwords do not match')
        return values

# Valid
try:
    reg1 = Registration(email="a@b.com", password="P@ssword1", password_confirm="P@ssword1")
    print("Registration valid!")
except ValidationError as e:
    print(f"Error: {e}")

# Invalid (passwords don't match)
try:
    reg2 = Registration(email="x@y.com", password="P@ssword1", password_confirm="P@ssword2")
except ValidationError as e:
    print(f"Error: {e}")

Validation Checkpoint

Consider the following Pydantic model for a user profile:

from pydantic import BaseModel, Field, validator
import re

class UserProfile(BaseModel):
    username: str = Field(min_length=5, max_length=20)
    email: str
    age: int = Field(gt=18)
    bio: str = ""

    @validator('email')
    def validate_email_format(cls, v):
        if not re.match(r"[^@]+@[^@]+\.[^@]+", v):
            raise ValueError('Invalid email format')
        return v

Which of the following JSON inputs would be valid for UserProfile?

Recap: Mastering Validation

You've learned how to make your data models truly robust!

Field: For built-in rules like min/max length, numeric ranges, and regex patterns.
@validator: To implement custom logic for individual fields, with pre=True for early transformation.
@root_validator: For complex cross-field validation that depends on multiple fields.

These tools empower you to define precise rules, ensuring data integrity in your FastAPI applications. Keep practicing to build even more reliable APIs!

자주 묻는 질문

“Pydantic 필드 검증 및 검증기” 강의는 무료인가요?

네 — “Pydantic 필드 검증 및 검증기” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 FastAPI Backend Development Bootcamp 강의 전체를 잠금 해제할 수 있습니다. FastAPI Backend Development Bootcamp 강의에는 총 4개의 강의가 포함되어 있습니다.

“Pydantic 필드 검증 및 검증기”에서 뭘 배우나요?

고급 필드 검증 옵션을 살펴보고 복잡한 비즈니스 규칙을 위한 사용자 지정 검증기를 만듭니다. 브라우저에서 직접 실행하는 실습 코드로 FastAPI Backend Development Bootcamp을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

FastAPI Backend Development Bootcamp을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 FastAPI Backend Development Bootcamp은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 1번째 강의입니다.

“Pydantic 필드 검증 및 검증기” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 FastAPI Backend Development Bootcamp 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 FastAPI Backend Development Bootcamp 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

← FastAPI Backend Development Bootcamp(으)로 돌아가기