0Pricing
FastAPI Backend Development Bootcamp · Pelajaran

Tipe Data dan Pengaturan Khusus

Tentukan tipe data Pydantic khusus dan kelola pengaturan aplikasi menggunakan `BaseSettings` milik Pydantic.

Tipe Data dan Pengaturan Khusus adalah pelajaran FastAPI Backend Development Bootcamp gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar FastAPI Backend Development Bootcamp, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus FastAPI Backend Development Bootcamp mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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
  • .env files
  • 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:

  1. Environment variables (highest priority)
  2. .env file variables
  3. Default values defined in the BaseSettings class (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!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Tipe Data dan Pengaturan Khusus” gratis?

Ya — teks lengkap “Tipe Data dan Pengaturan Khusus” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus FastAPI Backend Development Bootcamp, upgrade ke CoddyKit PRO. Kursus FastAPI Backend Development Bootcamp mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Tipe Data dan Pengaturan Khusus”?

Tentukan tipe data Pydantic khusus dan kelola pengaturan aplikasi menggunakan `BaseSettings` milik Pydantic. Kamu berlatih FastAPI Backend Development Bootcamp dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai FastAPI Backend Development Bootcamp?

Tidak diperlukan pengalaman sebelumnya. FastAPI Backend Development Bootcamp di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Tipe Data dan Pengaturan Khusus” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran FastAPI Backend Development Bootcamp ini?

Ya. Setiap pelajaran FastAPI Backend Development Bootcamp menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Validasi Field Pydantic dan Validator
  2. Tipe Data dan Pengaturan Khusus
  3. Model Bersarang dan Struktur Rekursif
  4. Serialisasi dengan model_dump dan Alias
← Kembali ke FastAPI Backend Development Bootcamp