โมเดล Pydantic สำหรับเนื้อหาคำขอ

When you send data to an API, like creating a new user or an item, that data is often sent in the request body.

For example, a request to create a new product might include its name, price, and description. Ensuring this incoming data is correct and valid is crucial for your application's stability and security.

Validating incoming data is essential for several reasons:

• Data Integrity: Ensures your database receives only correctly formatted and meaningful information.
• Security: Prevents malicious or malformed data from causing errors or vulnerabilities.
• User Experience: Provides clear error messages to users when their input is incorrect.
• Code Reliability: Reduces bugs by guaranteeing that your application logic operates on expected data types.

Pydantic is a Python library that provides data validation and settings management using Python type hints. It's incredibly fast and integrates seamlessly with FastAPI.

FastAPI uses Pydantic behind the scenes to:

• Parse request bodies into Python objects.
• Validate data types and constraints.
• Generate clear error messages if validation fails.

To define a data structure for your request body, you create a class that inherits from Pydantic's BaseModel. You then declare fields using standard Python type hints.

This model acts as a schema, specifying what data your API expects.

Let's define a simple Item model. Notice how we specify name as a string and price as a float. We'll also show how it handles validation!

FastAPI automatically recognizes Pydantic BaseModel objects in your endpoint function parameters. When a request comes in, FastAPI:

• Reads the JSON request body.
• Uses your Pydantic model to parse and validate the data.
• Injects the validated data as an instance of your model into your function.

It's magic!

Here's how you define a POST endpoint in FastAPI that expects an Item in its request body. FastAPI handles all the parsing and validation for you!

If a client sends data that doesn't match your Pydantic model (e.g., missing a required field or wrong data type), FastAPI will automatically return a detailed 422 Unprocessable Entity error response.

This error message is automatically generated and very helpful for debugging both client-side and API issues.

Not all fields in your request body need to be mandatory. You can make fields optional or provide default values:

• Use field: str | None = None for optional fields that default to None.
• Use field: int = 0 to set a specific default value if the field is not provided.

This flexibility allows you to design robust and user-friendly API schemas.

You've learned how Pydantic models are fundamental for handling request bodies in FastAPI. They provide robust data validation, automatic parsing, and clear error messages, making your API development much smoother and more reliable.

Next, we'll explore how to define explicit response models and handle HTTP status codes for various API operations!