ชนิดข้อมูลและการตั้งค่าแบบกำหนดเอง
กำหนดชนิดข้อมูล Pydantic แบบกำหนดเอง และจัดการการตั้งค่าแอปพลิเคชันด้วย `BaseSettings` ของ Pydantic
ชนิดข้อมูลและการตั้งค่าแบบกำหนดเอง เป็นบทเรียน FastAPI Backend Development Bootcamp ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน FastAPI Backend Development Bootcamp และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส FastAPI Backend Development Bootcamp มีบทเรียนทั้งหมด 4 บทเรียน
บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ
Welcome to Custom Types!
Pydantic is great for validating data, but sometimes you need validation beyond its built-in types.
- Custom Data Types let you define your own rules for data.
- This ensures your data adheres to specific formats or business logic.
- Think of it as extending Pydantic's power for unique needs.
`Annotated` for Custom Validation
Pydantic v2 uses Python's typing.Annotated alongside validator functions to create custom types.
Annotated: Adds metadata to a type hint.BeforeValidator: Runs a function before Pydantic's standard validation.- This allows you to transform or validate input data before it's assigned.
Crafting a `CapitalizedString`
Let's create a custom type called CapitalizedString that ensures the first letter of a string is always uppercase.
Our validator function will check this rule. If the string isn't capitalized, it will raise an error.
Using Your Custom Type
Here's how to define and use our new CapitalizedString type in a Pydantic model. Try changing the name to start with a lowercase letter to see the validation error!
from typing import Annotated
from pydantic import BaseModel, BeforeValidator, ValidationError
def validate_capitalized(v: str) -> str:
if not isinstance(v, str):
raise TypeError("String required")
if v and not v[0].isupper():
raise ValueError("Must start with uppercase")
return v
CapitalizedString = Annotated[str, BeforeValidator(validate_capitalized)]
class Product(BaseModel):
name: CapitalizedString
price: float
if __name__ == "__main__":
try:
product1 = Product(name="Laptop", price=1200.50)
print(f"Product: {product1.name}")
# This will raise a ValidationError
# product2 = Product(name="keyboard", price=75.00)
except ValidationError as e:
print(f"Validation Error: {e}")Manage Settings with `BaseSettings`
Application settings (like database URLs, API keys) often change between development and production environments.
BaseSettings, from pydantic-settings, is designed to manage these configurations easily. It automatically loads settings from:
- Environment variables
.envfiles- Default values
Default Settings in Action
Define your settings as attributes in a class inheriting from BaseSettings. Pydantic handles the rest, providing default values if nothing else is specified.
from pydantic_settings import BaseSettings
class AppConfig(BaseSettings):
app_name: str = "My FastAPI App"
debug_mode: bool = False
version: str = "1.0.0"
if __name__ == "__main__":
settings = AppConfig()
print(f"App Name: {settings.app_name}")
print(f"Debug Mode: {settings.debug_mode}")
print(f"Version: {settings.version}")Loading from Environment Variables
BaseSettings automatically looks for environment variables that match your setting names (case-insensitive).
In this example, we temporarily set an environment variable to demonstrate how Pydantic picks it up, overriding the default.
import os
from pydantic_settings import BaseSettings
class AppConfig(BaseSettings):
app_name: str = "Default App"
database_url: str = "sqlite:///./test.db"
if __name__ == "__main__":
print("--- Without env var ---")
settings_default = AppConfig()
print(f"App Name: {settings_default.app_name}")
# Simulate setting an environment variable
os.environ["APP_NAME"] = "Production App"
os.environ["DATABASE_URL"] = "postgresql://user:pass@host:5432/db"
print("\n--- With env var ---")
settings_env = AppConfig()
print(f"App Name: {settings_env.app_name}")
print(f"DB URL: {settings_env.database_url}")
# Clean up the environment variable for subsequent runs
del os.environ["APP_NAME"]
del os.environ["DATABASE_URL"]Leveraging `.env` Files
For local development, it's common to store settings in a .env file (e.g., .env) in your project root.
You can configure BaseSettings to load from this file using SettingsConfigDict(env_file='.env') in your settings class.
Example .env content:APP_NAME="Dev App"
API_KEY="your_dev_api_key"
from pydantic_settings import BaseSettings, SettingsConfigDict
class ProjectSettings(BaseSettings):
model_config = SettingsConfigDict(env_file='.env', extra='ignore')
app_name: str = "Default Project"
api_key: str = "default_key"
# To make this runnable, you would need python-dotenv installed
# and an actual .env file in the same directory as the script.
# For this lesson, we show the setup.
# Example usage (if .env existed and python-dotenv was active):
# if __name__ == "__main__":
# settings = ProjectSettings()
# print(f"App Name: {settings.app_name}")
# print(f"API Key: {settings.api_key}")
Understanding Settings Priority
When BaseSettings looks for a value, it follows a specific order of precedence:
- Environment variables (highest priority)
.envfile variables- Default values defined in the
BaseSettingsclass (lowest priority)
This ensures that environment variables can always override local .env files and class defaults, which is crucial for deployment.
Test Your Knowledge!
Which of the following are true about Pydantic's BaseSettings and custom types?
Recap: Custom Types & Settings
Great job! You've learned how to create powerful custom data types with Annotated and BeforeValidator, extending Pydantic's validation.
You also mastered BaseSettings for robust application configuration, understanding how it loads values from defaults, .env files, and environment variables with clear priority rules.
These tools are essential for building flexible and maintainable FastAPI applications!
คำถามที่พบบ่อย
บทเรียน “ชนิดข้อมูลและการตั้งค่าแบบกำหนดเอง” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ชนิดข้อมูลและการตั้งค่าแบบกำหนดเอง” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส FastAPI Backend Development Bootcamp ให้อัปเกรดเป็น CoddyKit PRO คอร์ส FastAPI Backend Development Bootcamp มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ชนิดข้อมูลและการตั้งค่าแบบกำหนดเอง”
กำหนดชนิดข้อมูล Pydantic แบบกำหนดเอง และจัดการการตั้งค่าแอปพลิเคชันด้วย `BaseSettings` ของ Pydantic คุณปฏิบัติ FastAPI Backend Development Bootcamp ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน FastAPI Backend Development Bootcamp หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน FastAPI Backend Development Bootcamp บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน
บทเรียน “ชนิดข้อมูลและการตั้งค่าแบบกำหนดเอง” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน FastAPI Backend Development Bootcamp นี้ได้ไหม
ได้ บทเรียน FastAPI Backend Development Bootcamp ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การตรวจสอบฟิลด์และตัวตรวจสอบของ Pydantic
- ชนิดข้อมูลและการตั้งค่าแบบกำหนดเอง
- โมเดลซ้อนกันและโครงสร้างเวียนเกิด
- การทำให้เป็นอนุกรมด้วย model_dump และนามแฝง