标签: python-typing

如何创建一个 TypedDict 类，该类支持包含连字符或字符串中支持的其他字符的键，例如下面示例中的“justify-content”。

from typing import TypedDict, Literal
from typing_extensions import NotRequired

class Attributes(TypedDict):
    width: NotRequired[str]
    height: NotRequired[str]
    direction: NotRequired[Literal["row", "column"]]
    justify-content: NotRequired[Literal["start", "end", "center", "equally-spaced"]]

我有一组不相关的类（一些是导入的），它们都有一个a类型为 的公共属性（或属性） dict[str, Any]。

其中akey 下应该有另一个字典"b"，我想将其作为属性公开在任何这些类上b以简化inst.a.get("b", {})[some_key]为inst.b[some_key]。

我已将以下子类工厂用作本地类的类装饰器和导入类的函数。

但到目前为止，我未能cls正确键入提示其参数并返回值。

from functools import wraps

def access_b(cls):
    @wraps(cls, updated=())
    class Wrapper(cls):
        @property
        def b(self) -> dict[str, bool]:
            return self.a.get("b", {})
    return Wrapper

我最近一次打字尝试的 MRE（有mypy 0.971错误）：

from functools import wraps
from typing import Any, Protocol, TypeVar

class AProtocol(Protocol):
    a: dict[str, Any]

class BProtocol(AProtocol, Protocol):
    b: dict[str, bool]

T_a = TypeVar("T_a", bound=AProtocol)
T_b = TypeVar("T_b", bound=BProtocol)

def …

我有一个排序的链表

class SortedLinkedList:
    # ...
    def insert(self, value: int):
        # ...
        if node.value > value:
            self.add_before(node, value)
        # ...

我想将 a 可以保存的值类型概括为Node从仅s 到通过实现魔术方法int重载运算符的任何对象。>__gt__()

在其他语言中，我会通过使用 来实现这一点Interface，但 Python 显然没有类似的东西。我已经看到通过使用抽象类来伪造接口的建议，例如

class Sortable(ABC):
    @abstractmethod
    def __gt__(self, other) -> bool:
        pass

class SortedLinkedList:
    # ...
    def insert(self, value: Sortable, node: Node):
        # ...

问题是这种方法需要扩展和使用 的子类，这意味着不能使用Sortable已经具有整数等功能的类型>

linkedlist.insert(5) # Pylance red squiggles

Argument of type "Literal[5]" cannot be assigned to
parameter "value" of type "Sortable" in …

我想为已知函数编写一个包装函数，例如

    def wrapper(*args, **kwargs)
         foo()
         return known_function(*args, **kwargs)

我如何添加类型注释wrapper，使其完全遵循类型注释known_function

我已经看过了ParamSpec，但它似乎只在包装函数是通用的并且将内部函数作为参数时才起作用。

    P = ParamSpec("P")
    T = TypeVar('T')
    def wrapper(func_arg_that_i_dont_want: Callable[P,T], *args: P.args, **kwargs: P.kwargs)
         foo()
         return known_function(*args, **kwargs)

我可以强制P只对 有效known_function，而不将其链接到Callable- 参数吗？

假设我们为回调定义一个类型，如下所示：

CallbackFn = Callable[[str, str, int, int], None]

当我想要实现回调函数并使用外部工具对其进行类型检查时CallbackFn，我必须显式注释类型：

def my_callback(s1: str, s2: str, i1: int, i2: int) -> None:
  ...

有什么方法可以使用定义的类型提示来CallbackFn注释函数（例如def my_callback(s1,s2,i1,i2) as CallbackFn:）以避免显式注释工作？

我无法正确获得以下类型提示。能否请你帮忙？

# example edited to make simpler (was async)
from typing import Any, Callable, ClassVar

class Base:
    def n_a(self) -> str:
        return 'N/A'

    meth1: ClassVar[Callable[[Base], str]] = n_a 
    # also meth2, meth3, ...

class Subclass(Base):
    def meth1(self) -> str:  # <-- line 11
        return 'yes'

错误是：

test.py:11: error: Signature of "meth1" incompatible with supertype "Base"  [override]
test.py:11: note:      Superclass:
test.py:11: note:          def (Base, /) -> str
test.py:11: note:      Subclass:
test.py:11: note:          def meth1(self) -> str

问题大概就在这里：

ClassVar[Callable[[Base], str]]
                  ^^^^^^

因为这是没有错误地接受的： …