Python資料塑形與管理：Pydantic 與 SQLAlchemy 的完美結合：總結 (第5集)

– 11 分鐘閱讀

這篇文章涵蓋了 SQLAlchemy CRUD 操作的最佳實務、設計模式應用和效能最佳化技巧。透過掌握這些概念，你可以設計和實作高效能、可擴充套件與易於維護的資料函式庫應用程式。

  graph LR
    C[C]
    A[建立] --> B(讀取)
    B --> C{更新}
    C --> D[刪除]

內容解密： 這張圖表展示了 CRUD 操作的流程，從建立資料開始，接著可以讀取、更新，最後可以刪除資料。

  classDiagram
    class UserRepository {
        +create(username, email)
        +read(user_id)
        +update(user_id, data)
        +delete(user_id)
    }

內容解密： 這張圖表展示了 UserRepository 類別的結構，包含了 create、read、update 和 delete 方法，用於執行 CRUD 操作。

Pydantic 與 SQLAlchemy 的完美結合：開發高效能 Python 應用

在 Python 應用開發領域，Pydantic 和 SQLAlchemy 各自都是強大的工具。Pydantic 以其便捷的資料驗證和設定管理聞名，而 SQLAlchemy 則提供了完善的 SQL 工具包和物件關聯對映（ORM）功能。當兩者結合使用時，它們將發揮出更強大的 synergy，提升資料驅動應用的穩健性、效率和可維護性。我將探討 Pydantic 如何完善 SQLAlchemy，重點關注資料驗證和資料序列化兩個關鍵領域。

資料驗證：確保資料完整性

Pydantic 的核心優勢之一是能夠使用 Python 型別註解執行資料驗證。此功能與 SQLAlchemy 的 ORM 相得益彰，在資料到達資料函式庫層之前提供額外的驗證層，確保資料函式庫的資料一致性。

案例：使用者註冊

假設一個使用者註冊場景，我們需要在將使用者輸入的資料儲存到資料函式庫之前對其進行驗證。以下是如何結合使用 Pydantic 和 SQLAlchemy 的示例：

from pydantic import BaseModel, EmailStr, validator
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import declarative_base
from sqlalchemy.orm.session import Session

# SQLAlchemy 模型
Base = declarative_base()

class UserORM(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, index=True)
    username = Column(String, unique=True, index=True)
    email = Column(String, unique=True, index=True)
    full_name = Column(String)

# Pydantic 模型
class UserCreate(BaseModel):
    username: str
    email: EmailStr
    full_name: str

    @validator('username')
    def username_alphanumeric(cls, v):
        if not v.isalnum():
            raise ValueError('必須為字母數字')
        return v

# 建立使用者函式
def create_user(db: Session, user: UserCreate):
    db_user = UserORM(**user.dict())
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

# 使用範例
user_data = {
    "username": "johndoe123",
    "email": "john@example.com",
    "full_name": "John Doe"
}

user = UserCreate(**user_data)
db_user = create_user(db_session, user)

內容解密：

這段程式碼定義了 SQLAlchemy 的 UserORM 模型，用於資料函式庫表格對映，以及 Pydantic 的 UserCreate 模型，用於資料驗證。create_user 函式接收使用者資料並使用 Pydantic 模型驗證後，再將資料儲存到資料函式庫。@validator 裝飾器用於自定義驗證規則，確保使用者名稱只能包含字母和數字。

在這個例子中，Pydantic 的 UserCreate 模型提供了以下好處：

  1. 使用 EmailStr 確保 email 地址有效。
  2. 使用 validator 確保使用者名稱符合特定格式要求。
  3. 提供了清晰的資料結構定義。

透過 Pydantic 的資料驗證，我們可以有效防止無效資料進入資料函式庫，提高應用程式的穩健性。

(後續內容待補充)

  graph LR
    A[使用者輸入] --> B{Pydantic 驗證}
    B -- 驗證透過 --> C[SQLAlchemy ORM]
    C --> D[資料函式庫]
    B -- 驗證失敗 --> E[錯誤回饋]

圖表說明: 此流程圖展示了 Pydantic 和 SQLAlchemy 如何協同工作以驗證使用者輸入並將其儲存到資料函式庫。

(此處僅處理了部分內容，後續內容將在下一階段處理)

SQLAlchemy 與 Pydantic 的完美搭配：開發高效能 Python 資料應用

在資料驅動的應用程式中，有效管理資料的驗證、序列化和資料函式庫互動至關重要。Python 的 SQLAlchemy 和 Pydantic 兩個函式庫能完美地解決這些問題。SQLAlchemy 提供了強大的資料函式庫互動功能，而 Pydantic 則擅長資料驗證和序列化。本文將探討如何結合 SQLAlchemy 和 Pydantic，開發兼具效能和可維護性的 Python 資料應用。

資料驗證：確保資料完整性

Pydantic 的核心功能之一是資料驗證。它允許開發者定義資料模型，並在資料進入應用程式時進行驗證，確保資料的正確性和一致性。這有效降低了資料函式庫層級錯誤的風險。

以下範例展示如何使用 Pydantic 驗證使用者名稱：

from pydantic import BaseModel, validator
from sqlalchemy.orm import Session
from typing import Optional

class User(BaseModel):
    id: int
    username: str
    email: str
    full_name: Optional[str]

    @validator('username')
    def username_alphanumeric(cls, v):
        assert v.isalnum(), 'username must be alphanumeric'
        return v

    class Config:
        orm_mode = True

# ... SQLAlchemy ORM model definition ...

def create_user(db: Session, user_data: dict):
    validated_user = User(**user_data)
    db_user = UserORM(**validated_user.dict()) # Assuming UserORM is your SQLAlchemy model
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

內容解密：

這段程式碼定義了一個 Pydantic 模型 User，並使用 @validator 裝飾器增加了對使用者名稱的字母數字驗證。在 create_user 函式中，我們先使用 Pydantic 驗證輸入資料，然後再將驗證後的資料傳遞給 SQLAlchemy 的 ORM 模型。

資料序列化：簡化 API 回應

Pydantic 也簡化了資料序列化的過程。它能輕鬆地將 SQLAlchemy 的 ORM 物件轉換為字典或 JSON 格式，方便 API 回應的建立。

class UserProfile(BaseModel):
    id: int
    username: str
    email: str
    full_name: Optional[str]

    class Config:
        orm_mode = True

def get_user_profile(db: Session, user_id: int):
    db_user = db.query(UserORM).filter(UserORM.id == user_id).first()
    if db_user:
        return UserProfile.from_orm(db_user)
    return None

# 使用範例
user_profile = get_user_profile(db_session, 1)
if user_profile:
    print(user_profile.json())

內容解密：

UserProfile 模型定義了要暴露的使用者資料結構。from_orm 方法能將 SQLAlchemy ORM 物件輕鬆轉換為 Pydantic 模型，而 json() 方法則提供內建的 JSON 序列化功能。

SQLAlchemy 如何強化 Pydantic

SQLAlchemy 的強大之處在於資料函式庫互動，它能增強 Pydantic 在資料持久化、複雜查詢和關係處理方面的功能。

動態資料生成

SQLAlchemy 能提供動態資料生成能力，與 Pydantic 的靜態型別檢查相輔相成。這在處理資料函式庫驅動的預設值或計算欄位時特別有用。

from sqlalchemy import Column, Integer, String, select, func
from sqlalchemy.orm import declarative_base, relationship, subqueryload
from sqlalchemy.ext.hybrid import hybrid_property

# ... (Previous code for UserORM and PostORM)

class UserProfile(BaseModel):
    # ... (other fields)
    post_count: int

    class Config:
        orm_mode = True

def get_user_profile(session, user_id: int) -> UserProfile:
    user = session.query(UserORM).options(subqueryload(UserORM.posts)).filter(UserORM.id == user_id).first()
    return UserProfile.from_orm(user)

內容解密：

我們使用 SQLAlchemy 的 hybrid_property 定義了 post_count 屬性，Pydantic 的 UserProfile 模型也包含此欄位。當我們從 UserORM 物件建立 UserProfile 例項時，post_count 會自動計算。

複雜查詢與過濾

SQLAlchemy 的強大查詢功能能根據複雜條件擷取資料，然後輕鬆轉換為 Pydantic 模型。

from typing import List, Optional
# ... (Previous code for UserORM and UserBase)

class UserFilter(BaseModel):
    is_active: Optional[bool] = None
    min_age: Optional[int] = None
    max_age: Optional[int] = None

def get_filtered_users(session: Session, filter: UserFilter) -> List[UserBase]:
    query = session.query(UserORM)
    if filter.is_active is not None:
        query = query.filter(UserORM.is_active == filter.is_active)
    if filter.min_age is not None:
        query = query.filter(UserORM.age >= filter.min_age)
    if filter.max_age is not None:
        query = query.filter(UserORM.age <= filter.max_age)
    users = query.all()
    return [UserBase.from_orm(user) for user in users]

內容解密：

此範例中，SQLAlchemy 根據過濾條件執行複雜查詢，而 Pydantic 模型 UserBase 和 UserFilter 則定義了輸出資料和輸入過濾器的結構。

透過結合 SQLAlchemy 和 Pydantic，我們可以建立更強健、型別安全與易於維護的程式碼函式庫。Pydantic 處理應用程式的「邊緣」——驗證輸入資料和格式化輸出資料——而 SQLAlchemy 管理核心資料函式庫操作。這種協同作用讓每個函式庫都能發揮其優勢，成為構建資料驅動應用程式的強大組合。

  graph LR
    B[B]
    C[C]
    E[E]
    F[F]
    A[Pydantic] --> B{資料驗證};
    A --> C{資料序列化};
    D[SQLAlchemy] --> E{動態資料};
    D --> F{複雜查詢};
    B --> G[資料函式庫];
    C --> G;
    E --> G;
    F --> G;

圖表說明: 此圖表展示了 Pydantic 和 SQLAlchemy 如何協同工作，共同管理資料函式庫操作和資料處理。Pydantic 負責資料驗證和序列化，而 SQLAlchemy 負責提供動態資料和執行複雜查詢。所有這些操作最終都與資料函式庫互動。

SQLAlchemy 與 Pydantic 的完美結合：開發高效能 Python 資料函式庫應用

在 Python 的世界裡，SQLAlchemy 以其強大的資料函式庫互動能力而聞名，而 Pydantic 則以其嚴謹的資料驗證和序列化功能而備受推崇。這兩個函式庫的結合，能為開發者帶來前所未有的效率提升，讓我得以輕鬆建構複雜與資料驅動的應用程式。

我發現，將 SQLAlchemy 與 Pydantic 結合使用主要有以下優點：

  • 型別安全與彈性兼具： Pydantic 確保資料模型的型別安全，而 SQLAlchemy 提供了靈活操作資料函式庫的途徑。
  • 職責分離： SQLAlchemy 負責處理資料函式庫互動，Pydantic 負責資料驗證和序列化，使架構更清晰。
  • 減少樣板程式碼： 兩者的結合減少了在資料函式庫記錄和 API 友好格式之間手動轉換資料的需求。
  • 可維護性提升： 使用 SQLAlchemy 進行資料函式庫操作，Pydantic 進行資料建模，使程式碼函式庫更易於維護。

透過 SQLAlchemy 和 Pydantic 的協同作用，我得以建構更可靠、更易於維護的應用程式。SQLAlchemy 處理複雜的查詢和關聯，Pydantic 則確保資料的有效性和易序列化性。

整合 Pydantic 與 SQLAlchemy：挑戰與解決方案

雖然 Pydantic 和 SQLAlchemy 各自都是優秀的函式庫，但整合它們也並非一帆風順。我曾經遇到以下挑戰：

  1. 模型定義重複： 通常需要將資料模型定義兩次——一次作為 SQLAlchemy 模型，一次作為 Pydantic 模型，可能導致程式碼重複和不一致。
  2. 型別不比對： SQLAlchemy 和 Pydantic 使用不同的型別系統。例如，SQLAlchemy 使用自己的 Column 型別，而 Pydantic 使用 Python 型別註解。協調這些差異可能很棘手。
  3. 驗證差異： Pydantic 的驗證發生在應用程式層級，而 SQLAlchemy 的約束在資料函式庫層級強制執行。確保這兩層的驗證一致性是一項挑戰。
  4. 效能負擔： 在 SQLAlchemy ORM 物件和 Pydantic 模型之間轉換可能會帶來額外的處理負擔，尤其是在處理大型資料集時。
  5. 關聯複雜性： 處理複雜關聯（例如多對多）以同時滿足 Pydantic 的驗證和 SQLAlchemy 的 ORM 功能可能很複雜。

SQLModel：Pydantic 與 SQLAlchemy 之間的橋樑

為瞭解決這些挑戰，社群開發了一些簡化 Pydantic 和 SQLAlchemy 整合的函式庫。其中最引人注目的是 FastAPI 的作者 Sebastián Ramírez 開發的 SQLModel。

SQLModel 將 SQLAlchemy 和 Pydantic 巧妙地結合在一起。它允許只定義一個模型類別，同時作為 Pydantic 模型和 SQLAlchemy 模型。這種方法顯著減少了程式碼重複，簡化了開發流程。

SQLModel 的主要功能包括：

  1. 單一模型定義： 只需定義一次模型，即可用於資料函式庫操作和資料驗證。
  2. 型別一致性： SQLModel 使用與 Pydantic 和 SQLAlchemy 相容的 Python 型別註解。
  3. 自動遷移： 它與 Alembic 良好整合，可實作自動資料函式庫遷移。
  4. FastAPI 整合： 由於與 FastAPI 的作者相同，它與 FastAPI 應用程式無縫整合。

簡單範例：使用 SQLModel

以下是如何使用 SQLModel 定義和使用模型的簡單範例：

from typing import Optional
from sqlmodel import Field, Session, SQLModel, create_engine

class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: Optional[int] = None

# 建立引擎
engine = create_engine("sqlite:///database.db")

# 建立表格
SQLModel.metadata.create_all(engine)

# 建立一個英雄
hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")

# 儲存到資料函式庫
with Session(engine) as session:
    session.add(hero_1)
    session.commit()
    session.refresh(hero_1)
    print(hero_1)

在這個範例中，我定義了一個 Hero 模型，它同時用作 Pydantic 模型（用於驗證）和 SQLAlchemy 模型（用於資料函式庫操作）。我可以建立此模型的例項，驗證它們（Pydantic 功能），並將它們儲存到資料函式庫（SQLAlchemy 功能），而無需任何額外程式碼。

複雜範例：關聯和查詢

現在，讓我們來看一個涉及關聯的更複雜的範例：

from typing import List, Optional
from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select

class Team(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    headquarters: str
    heroes: List["Hero"] = Relationship(back_populates="team")

class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: Optional[int] = None
    team_id: Optional[int] = Field(default=None, foreign_key="team.id")
    team: Optional[Team] = Relationship(back_populates="heroes")

# 建立引擎
engine = create_engine("sqlite:///database.db")

# 建立表格
SQLModel.metadata.create_all(engine)

# 建立團隊和英雄
team_avengers = Team(name="Revengers", headquarters="New York")
hero_1 = Hero(name="Metal Man", secret_name="Tiny Stork", team=team_avengers)
hero_2 = Hero(name="Blue Window", secret_name="Natasha Rommy", team=team_avengers)

# 儲存到資料函式庫
with Session(engine) as session:
    session.add(team_avengers)
    session.add(hero_1)
    session.add(hero_2)
    session.commit()

# 查詢資料函式庫
with Session(engine) as session:
    statement = select(Team).where(Team.name == "Revengers")
    result = session.exec(statement)
    team_avengers = result.one()
    print(f"Team: {team_avengers.name}")
    print("Heroes:")
    for hero in team_avengers.heroes:
        print(f"- {hero.name} ({hero.secret_name})")

在這個範例中，我定義了兩個相關的模型：Team 和 Hero。我可以建立這些模型的例項，在它們之間建立關聯，並執行複雜查詢，同時受益於 Pydantic 的驗證和 SQLAlchemy 的 ORM 功能。

這個方法透過以下方式簡化了程式碼：

  1. 統一的模型定義： 我只需定義一次資料結構，即可用於驗證和資料函式庫操作。
  2. 型別安全的關聯： 模型之間的關聯是型別安全的，並且可以輕鬆瀏覽。
  3. 簡化的查詢： 我可以使用 SQLModel 的查詢介面，它結合了 SQLAlchemy 的強大功能和 Pydantic 模型的簡潔性。
  4. 自動驗證： 在建立例項和從資料函式庫檢索資料時，都會根據模型定義自動驗證資料。

抽象層的挑戰

雖然像 SQLModel 這樣的函式庫極大地簡化了 Pydantic 和 SQLAlchemy 的整合，但它們確實引入了額外的抽象層，這也帶來了一些挑戰：

  1. 學習曲線： 除了理解 Pydantic 和 SQLAlchemy 之外，開發者還需要學習新函式庫的細節。

總而言之，SQLModel 提供了一個優雅的解決方案，有效地整合了 Pydantic 和 SQLAlchemy，讓資料函式庫應用開發更加便捷高效。 儘管額外的抽象層帶來了一些學習成本，但我認為其帶來的優勢遠大於挑戰。

  graph LR
    B[B]
    A[Pydantic] --> B{SQLModel}
    C[SQLAlchemy] --> B
    B --> D[Database]
    B --> E[API]

內容解密： 上面的 Mermaid 圖表展示了 Pydantic 和 SQLAlchemy 如何透過 SQLModel 協同工作。SQLModel 作為橋樑，連線了 Pydantic 的資料驗證和 SQLAlchemy 的資料函式庫互動，最終服務於資料函式庫和 API。

擺脫傳統 ORM 的束縛：SQLModel 的崛起

在 Python 的世界中，SQLAlchemy 和 Pydantic 分別扮演著資料管理和驗證的雙重角色。然而，它們各自推薦的模型定義方法卻常常導致專案結構的衝突。我曾經在多個專案中遇到這種困擾，本文將探討這些衝突，並提出一個整合方案，充分利用這兩個函式庫的優勢，同時避免常見的陷阱。

SQLAlchemy 的模型定義方法

SQLAlchemy 通常建議將模型定義儲存在一個名為 models.py 的檔案中。以下是一個簡單的例子：

# file: models.py (SQLAlchemy 方法)
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    username = Column(String(50), unique=True, nullable=False)
    email = Column(String(120), unique=True, nullable=False)

    def __repr__(self):
        return f"<User {self.username}>"

這種結構方便在整個應用程式中匯入和使用這些模型，尤其是在進行資料函式庫操作時。

Pydantic 的模型定義方法

Pydantic 也經常使用名為 models.py 的檔案來定義其資料驗證模式。以下是一個示例：

# file: models.py (Pydantic 方法)
from pydantic import BaseModel, EmailStr

class UserBase(BaseModel):
    username: str
    email: EmailStr

class UserCreate(UserBase):
    password: str

class User(UserBase):
    id: int

    class Config:
        orm_mode = True

這種方法可以清晰地定義資料驗證模式，這在構建 API 或處理外部資料來源時非常有用。

SQLModel：和諧統一之道

SQLModel 提供了一個優雅的解決方案，它將 SQLAlchemy 和 Pydantic 的模型統一起來，從而減少程式碼重複並簡化開發流程。

from typing import Optional

from sqlmodel import Field, SQLModel


class User(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: Optional[int] = Field(default=None, index=True)
    size: Optional[float] = Field(default=None, index=True)

整合的優勢與權衡

整合 SQLAlchemy 和 Pydantic 可以顯著增強 Python 專案，它結合了強大的資料驗證和 ORM 功能。然而，這種整合也伴隨著一些挑戰，主要圍繞模型定義重複和型別系統差異。

SQLModel 等函式庫透過提供統一的介面來應對這些挑戰，充分利用了 Pydantic 和 SQLAlchemy 的優勢。這種方法簡化了程式碼，減少了重複，並在整個應用程式中維護了型別安全。

然而，需要注意的是，這種額外的抽象層也帶來了一些權衡。雖然它簡化了許多常見使用案例，但在更復雜的場景中可能會引入限制，並與需要學習新的 API。

最終，是否使用 SQLModel 等整合函式庫應該根據專案的具體需求、團隊的專業知識以及資料模型的複雜性。對於許多專案，尤其是那些已經在使用 FastAPI 的專案，這種整合方法的好處可能會超過挑戰，從而帶來更易維護和更健壯的程式碼。

內容解密：SQLModel 示例

上述程式碼展示瞭如何使用 SQLModel 定義一個使用者模型。SQLModel 繼承自 table=True，表明這是一個資料函式庫表模型。各個欄位的型別宣告與 Pydantic 相同，並使用 Field 來定義資料函式庫相關的屬性，例如主鍵、索引等。

SQLModel 架構

  graph LR
    C[C]
    A[Python 程式碼] --> B(SQLModel)
    B --> C{資料函式庫}
    D[Pydantic] --> B
    E[SQLAlchemy] --> B

上圖展示了 SQLModel 如何橋接 Python 程式碼、Pydantic、SQLAlchemy 和資料函式庫。

最終，選擇哪種方案取決於專案的具體需求和團隊的偏好。對我而言，SQLModel 的簡潔性和型別安全更具吸引力，尤其是在快速開發 Web API 時。它讓我能夠專注於業務邏輯，而不是處理繁瑣的模型轉換和驗證。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。