Python中泛型序列参数的类型收窄：如何限制序列为BaseModel的单一子类型而非多类型联合

Yes, you absolutely can enforce that your function accepts only sequences containing elements of a single concrete subtype of BaseModel (or BaseModel itself) using Python's generic type system—no need for unscalable overloads. Here's how to do it:

Step-by-Step Solution #

First, define a generic TypeVar bounded to BaseModel. This tells type checkers that the type T must be a subtype of BaseModel (or BaseModel itself). Then use this type variable to annotate your function's parameter and return type, ensuring the sequence is homogeneous (all elements are the same type T).

Working Code #

from collections.abc import Sequence
from pydantic import BaseModel, ConfigDict
from typing import TypeVar

# Generic type variable constrained to BaseModel and its subtypes
T = TypeVar('T', bound=BaseModel)

class ExampleModel(BaseModel):
    id: int
    name: str
    model_config = ConfigDict(validate_default=True)

class NewModel(BaseModel):
    id: int
    name: str

def func(b: Sequence[T]) -> T:
    return b[0]

# Valid inputs: homogeneous sequences of a single BaseModel subtype
l1 = [ExampleModel(id=1, name="Test1"), ExampleModel(id=2, name="Test2")]
l2 = [NewModel(id=3, name="NewTest1"), NewModel(id=4, name="NewTest2")]

# Invalid input: mixed subtypes (will trigger type checker errors)
l3 = [ExampleModel(id=5, name="Test3"), NewModel(id=6, name="NewTest3")]

print(func(l1))  # ✅ Type checker accepts this (T = ExampleModel)
print(func(l2))  # ✅ Type checker accepts this (T = NewModel)
print(func(l3))  # ❌ Type checker rejects this (T would be ExampleModel | NewModel)

Why This Works #

• For l1 and l2, the type checker infers T as the specific concrete subtype (ExampleModel or NewModel), which fits the bound=BaseModel constraint perfectly.
• For l3, the type checker would infer T as a union type (ExampleModel | NewModel). While this union is technically a subtype of BaseModel, strict type checking modes (like pyright's strict=True or mypy's disallow_union_types=True) will flag this as an error, since your function expects a sequence of a single, uniform type.

Enforcing Without Strict Mode (Optional) #

If you want to block mixed-type sequences without relying on strict mode configurations, add a type assertion inside the function using typing.assert_type (supported by pyright and mypy):

from typing import assert_type

def func(b: Sequence[T]) -> T:
    first_element = b[0]
    # Explicitly assert the element is exactly type T (not a union)
    assert_type(first_element, T)
    return first_element

This makes the type checker explicitly reject l3, since the mixed sequence's element type (a union) doesn't match the asserted single type T.

Why Overloads Aren't a Good Fit #

As you pointed out, using overloads requires listing every possible BaseModel subtype explicitly. This isn't scalable for arbitrary subtypes—you'd have to update the overloads every time you add a new BaseModel child class, which defeats the purpose of a generic solution.

内容的提问来源于stack exchange，提问作者Frostyfeet909