如何（在运行时）在字典中键入提示/键入检查任意数量的任意键/值对？

Question

我对一个类的定义如下：

from numbers import Number
from typing import Dict

from typeguard import typechecked

Data = Dict[str, Number]

@typechecked
class Foo:
    def __init__(self, data: Data):
        self._data = dict(data)
    @property
    def data(self) -> Data:
        return self._data

我正在使用typeguard。我的意图是限制可以进入数据字典的类型。显然，typeguard会检查整个字典是否传递到函数中或从函数返回。如果字典是直接“公开”的，那么检查类型就成了字典的“责任”——显然，这不起作用：

bar = Foo({'x': 2, 'y': 3}) # ok

bar = Foo({'x': 2, 'y': 3, 'z': 'not allowed'}) # error as expected

bar.data['z'] = 'should also be not allowed but still is ...' # no error, but should cause one

PEP 589引入了类型化词典，但用于一组固定的键（类似于其他语言中类似struct的构造）。相比之下，我需要一个灵活数量的任意键

我最好的坏主意是走“老派”：对dict进行子分类，重新实现API的每一位，通过这些API，数据可以进入（或离开）字典，并向它们添加类型检查：

@typechecked
class TypedDict(dict): # just a sketch
    def __init__(
        self,
        other: Union[Data, None] = None,
        **kwargs: Number,
    ):
        pass # TODO
    def __setitem__(self, key: str, value: Number):
        pass # TODO
    # TODO

是否有一个有效的替代方案不需要“老派”方法

Answer 1

你的问题似乎有几个部分

（1）在运行时创建类型检查字典

As @juanpa.arrivillaga says in the comments，这与类型-检查有关，但似乎与类型-暗示无关。然而，设计自己的自定义类型检查数据结构是相当简单的。您可以使用^{}这样做：

from collections import UserDict
from numbers import Number

class StrNumberDict(UserDict):
    def __setitem__(self, key, value):
        if not isinstance(key, str):
            raise TypeError(
                f'Invalid type for dictionary key: '
                f'expected "str", got "{type(key).__name__}"'
            )
        if not isinstance(value, Number):
            raise TypeError(
                f'Invalid type for dictionary value: '
                f'expected "Number", got "{type(value).__name__}"'
            )
        super().__setitem__(key, value)

使用中：

>>> d = StrNumberDict()
>>> d['foo'] = 5
>>> d[5] = 6
Traceback (most recent call last):
  File "<string>", line 1, in <module>
  File "<string>", line 5, in __setitem__
TypeError: Invalid type for dictionary key: expected "str", got "int"
>>> d['bar'] = 'foo'
Traceback (most recent call last):
  File "<string>", line 1, in <module>
  File "<string>", line 10, in __setitem__
TypeError: Invalid type for dictionary value: expected "Number", got "str"

如果你想概括这类事情，你可以这样做：

from collections import UserDict

class TypeCheckedDict(UserDict):
    def __init__(self, key_type, value_type, initdict=None):
        self._key_type = key_type
        self._value_type = value_type
        super().__init__(initdict)

    def __setitem__(self, key, value):
        if not isinstance(key, self._key_type):
            raise TypeError(
                f'Invalid type for dictionary key: '
                f'expected "{self._key_type.__name__}", '
                f'got "{type(key).__name__}"'
            )
        if not isinstance(value, self._value_type):
            raise TypeError(
                f'Invalid type for dictionary value: '
                f'expected "{self._value_type.__name__}", '
                f'got "{type(value).__name__}"'
            )
        super().__setitem__(key, value)

使用中：

>>> from numbers import Number
>>> d = TypeCheckedDict(key_type=str, value_type=Number, initdict={'baz': 3.14})
>>> d['baz']
3.14
>>> d[5] = 5
Traceback (most recent call last):
  File "<string>", line 1, in <module>
  File "<string>", line 9, in __setitem__
TypeError: Invalid type for dictionary key: expected "str", got "int"
>>> d['foo'] = 'bar'
Traceback (most recent call last):
  File "<string>", line 1, in <module>
  File "<string>", line 15, in __setitem__
TypeError: Invalid type for dictionary value: expected "Number", got "str"
>>> d['foo'] = 5
>>> d['foo']
5

注意，您不需要对传递给super().__init__()的字典进行类型检查UserDict.__init__调用self.__setitem__，您已经覆盖了它，因此如果您将无效的字典传递给TypeCheckedDict.__init__，您会发现异常的引发方式与在构造字典后尝试向字典添加无效键或值的方式相同：

>>> from numbers import Number
>>> d = TypeCheckedDict(str, Number, {'foo': 'bar'})
Traceback (most recent call last):
  File "<string>", line 1, in <module>
  File "<string>", line 5, in __init__
  line 985, in __init__
    self.update(dict)
  line 842, in update
    self[key] = other[key]
  File "<string>", line 16, in __setitem__
TypeError: Invalid type for dictionary value: expected "Number", got "str"

UserDict是专门为方便以这种方式进行子类化而设计的，这就是为什么在这个实例中它是比dict更好的基类

如果要向TypeCheckedDict添加类型提示，可以这样做：

from collections import UserDict
from collections.abc import Mapping, Hashable
from typing import TypeVar, Optional

K = TypeVar('K', bound=Hashable)
V = TypeVar('V')

class TypeCheckedDict(UserDict[K, V]):
    def __init__(
        self, 
        key_type: type[K], 
        value_type: type[V], 
        initdict: Optional[Mapping[K, V]] = None
    ) -> None:
        self._key_type = key_type
        self._value_type = value_type
        super().__init__(initdict)

    def __setitem__(self, key: K, value: V) -> None:
        if not isinstance(key, self._key_type):
            raise TypeError(
                f'Invalid type for dictionary key: '
                f'expected "{self._key_type.__name__}", '
                f'got "{type(key).__name__}"'
            )
        if not isinstance(value, self._value_type):
            raise TypeError(
                f'Invalid type for dictionary value: '
                f'expected "{self._value_type.__name__}", '
                f'got "{type(value).__name__}"'
            )
        super().__setitem__(key, value)

（上文passes MyPy。）

但是，请注意，添加类型提示与此数据结构在运行时的工作方式完全无关

（2）类型提示词典“用于灵活数量的任意键”

我不太清楚这是什么意思，但如果希望MyPy在向字典添加字符串值时引发错误，则只希望有数值，you could do it like this：

from typing import SupportsFloat

d: dict[str, SupportsFloat] = {}
d['a'] = 5  # passes MyPy 
d['b'] = 4.67 # passes MyPy
d[5] = 6 # fails MyPy
d['baz'] = 'foo' # fails Mypy 

如果您想要MyPy静态检查和运行时检查，您最好（在我看来）使用上面的TypeCheckedDict类型提示版本：

d = TypeCheckedDict(str, SupportsFloat) # type: ignore[misc]
d['a'] = 5  # passes MyPy 
d['b'] = 4.67  # passes MyPy 
d[5] = 6  # fails Mypy 
d['baz'] = 'foo'  # fails Mypy

Mypy对我们将抽象类型作为参数传递给TypeCheckedDict.__init__不太满意，因此在实例化dict时必须添加一个# type: ignore[misc]（这对我来说就像是一个Mypy bug。）但是，除此之外，it works fine

（有关使用SupportsFloat提示数字类型的注意事项，请参见我的previous answer。如果使用Python<；=3.8，则使用typing.Dict而不是dict提示类型。）

（3）使用typeguard

由于您使用的是typeguard，因此可以稍微简化我的StrNumberDict类中的逻辑，如下所示：

from collections import UserDict
from typeguard import typechecked
from typing import SupportsFloat

class StrNumberDict(UserDict[str, SupportsFloat]):
    @typechecked
    def __setitem__(self, key: str, value: SupportsFloat) -> None:
        super().__setitem__(key, value)

但是，如果您想要一个更通用的TypeCheckedDict可以通过任意类型检查进行实例化，我认为没有办法通过typeguard实现这一点。以下不起作用：

### THIS DOES NOT WORK ###

from typing import TypeVar, SupportsFloat
from collections.abc import Hashable
from collections import UserDict
from typeguard import typechecked

K = TypeVar('K', bound=Hashable)
V = TypeVar('V')

class TypeCheckedDict(UserDict[K, V]):
    @typechecked
    def __setitem__(self, key: K, value: V) -> None:
        super().__setitem__(key, value)

d = TypeCheckedDict[str, SupportsFloat]()
d[5] = 'foo'  # typeguard raises no error here.

还值得注意的是，typeguard是not currently maintained，因此使用该特定库会涉及一定的风险