如何动态测试一个值是否符合Python字面类型？

Question

我想了解如何动态测试一个值是否符合Python中的字面类型。假设我有以下代码：

from typing import Literal

PossibleValues = Literal["a", "b"]

x = input()

我想使用 isInstance ，但是这样做给了我一个类型：

>>> isinstance(x, PossibleValues)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/.../typing.py", line 720, in __instancecheck__
    return self.__subclasscheck__(type(obj))
  File "/.../typing.py", line 723, in __subclasscheck__
    raise TypeError("Subscripted generics cannot be used with"
TypeError: Subscripted generics cannot be used with class and instance checks

我发现我可以使用 get_args ，但是这种方法似乎似乎有点骇客。

>>> from typing import get_args
>>> x = input()
'c'
>>> x in get_args(PossibleValues)
False

有更好的方法吗？

Answer 1

来自在这里通过这样做的字面类型：

>>> from typing import Literal
>>> ATYPE = Literal["a", "b"]
>>> "a" in ATYPE.__args__
True
>>> "c" in ATYPE.__args__
False
>>>

使用 typing.get_args 而不是 __ args __ args __ 可能更有Pythonic。我必须使用它来解决mypy错误，同时将文字存储到 typealias 。

Answer 2

typing.get_args 在运行时完全可以接受，但这不会影响该类型Checker的类型（例如：Mypy和Pyright）。

typeform 在 typeform 使用 eNableExperimentionFeatures = true （ pr ）：

from __future__ import annotations  # Required as TypeForm is not yet released in typing_extensions

from typing import TYPE_CHECKING, Literal, TypeAliasType, TypeIs, assert_type, get_args, get_origin

if TYPE_CHECKING:  # Required as TypeForm is not yet released in typing_extensions
    from typing_extensions import TypeForm

type PossibleValues = Literal["a", "b"]


def is_literal_value[T](value: object, typx: TypeForm[T]) -> TypeIs[T]:
    if isinstance(typx, TypeAliasType):
        typx = typx.__value__
    if get_origin(typx) is Literal:
        return value in get_args(typx)
    return False


def check(x: str):
    if is_literal_value(x, PossibleValues):
        assert_type(x, PossibleValues)
        print(f"{x} is in PossibleValues")
    else:
        assert_type(x, str)
        print(f"{x} is not in PossibleValues")


check("a")
check("z")

这将返回：

$ python3 literal.py
a is in PossibleValues
z is not in PossibleValues

$ pyright literal.py
0 errors, 0 warnings, 0 informations

Answer 3

这是我刚刚想到，我对此感到非常满意。

"""
seems like hard coding is the only way to make literal type to accept anything to be literal
(which makes sense if you think about it)
"""

from typing import Any, Literal


my_literal_type = Literal["a", "b", "c"]


# I used `Any` type here but you could use `str` if you want to restrict the dynamic value's type to be `str` only
def guard_mlt(value: Any) -> my_literal_type:
    """
    only allow values in my_literal_type to pass
    and otherwise raise TypeError
    this requires hard coding the return values as it's explained at the top

    >>> guard_mlt('a')
    'a'
    >>> guard_mlt('b')
    'b'
    >>> guard_mlt('c')
    'c'
    >>> guard_mlt('d')
    Traceback (most recent call last):
        ...
    TypeError: d is not in typing.Literal['a', 'b', 'c']
    """
    match value:
        case "a":
            return "a"
        case "b":
            return "b"
        case "c":
            return "c"

    raise TypeError(f"{value} is not in {my_literal_type}")


if __name__ == "__main__":
    import doctest

    doctest.testmod()

（不可避免的）缺点是您需要为每种字面类型提出警卫功能。

Answer 4

您可以尝试访问 __ args __ ，但仍然不确定是否要明确调用魔术方法是一种方法。

get_args 似乎是正确的选择。

from typing import Literal, get_args

PossibleValues = Literal["a", "b"]

"c" in PossibleValues.__args__
"c" in get_args(PossibleValues)