标签: python-typing

我正在尝试定义一个类，该类将另一个类作为属性_model并将实例化该类的对象。

from abc import ABC
from typing import Generic, TypeVar, Any, ClassVar, Type

Item = TypeVar("Item", bound=Any)


class SomeClass(Generic[Item], ABC):
    _model: ClassVar[Type[Item]]

    def _compose_item(self, **attrs: Any) -> Item:
        return self._model(**attrs)

self._model(**attrs)我认为返回 , 的实例应该是显而易见的Item，因为_model被显式声明为Type[Item]并被attrs声明为Dict[str, Any]。

但我从中得到的mypy 0.910是：

test.py: note: In member "_compose_item" of class "SomeClass":
test.py:11: error: Returning Any from function declared to return "Item"
            return self._model(**attrs)
            ^

我究竟做错了什么？

from types import ModuleType\nfrom typing import Any, Dict, Tuple, Type, TypeVar\n\nfrom . import default\n\n_T = TypeVar("_T", bound=type)\n\nclass settings_meta(type):\n    def __new__(\n        cls: Type[_T],\n        name: str,\n        bases: Tuple[type, ...],\n        namespace: Dict[str, Any],\n        settings: ModuleType,\n        **kwargs: Any,\n    ) -> _T:\n        from inspect import ismodule\n\n        namespace = {\n            key: val\n            for key, val in vars(settings).items()\n            if not key.startswith("__") and not ismodule(val)\n        }\n        namespace["__annotations__"] = {\n            key: val\n            for key, val in vars(settings)["__annotations__"].items()\n            if key in namespace.keys()\n        }\n        return type.__new__(cls, name, bases, namespace, **kwargs)\n\n    def …

考虑一对简单的泛型类：

T = TypeVar("T", str, int)

class Base(Generic[T]):
    def __init__(self, v: T):
        self.v: T = v

    @property
    def value(self) -> T:
        return self.v

class Child(Base[T]):
    def __init__(self, v: T):
        super().__init__(v)

x = Child(123)
reveal_type(x.value)

使用时T = TypeVar("T")效果符合预期。如图所示的限制TypeVar会产生以下错误：

error: Argument 1 to "__init__" of "Base" has incompatible type "str"; expected "T"
error: Argument 1 to "__init__" of "Base" has incompatible type "int"; expected "T"
note: Revealed type is 'builtins.int*'

请注意，这reveal_type仍然有效。

另一个区别是受限制的TypeVar需要类型注释来进行self.v赋值，而不受限制的则不需要。 …

我将代码分成多个包，这些包可以通过 PyPI 安装。然后这些包在子包中使用，我希望在其中充分使用“库”包中的类型信息。为了进行完整的类型检查，我想在本地和 CI 中使用 Pyright / pylance。

记录 python 库类型的推荐方法是什么？我目前正在源代码中部分注释类型。我必须提供存根吗？当在其他项目中使用我的库时，我会收到像Stub file not foundvscode 中一样的警告。

具体问题：

1. 如果我希望用户能够输入内容，那么 python 库必须有存根吗？
2. 如果存根都具有类型，那么存根是否优先于库的源代码？

当处理 Python 数据类时，我遇到了这个很容易重现的奇怪错误。

from __future__ import annotations

import dataclasses as dc
import typing

@dc.dataclass
class Test:
    foo: dc.InitVar[int]

print(typing.get_type_hints(Test))

运行它会得到以下结果：

Traceback (most recent call last):
  File "test.py", line 11, in <module>
    print(typing.get_type_hints(Test))
  File "C:\Program Files\Python310\lib\typing.py", line 1804, in get_type_hints
    value = _eval_type(value, base_globals, base_locals)
  File "C:\Program Files\Python310\lib\typing.py", line 324, in _eval_type
    return t._evaluate(globalns, localns, recursive_guard)
  File "C:\Program Files\Python310\lib\typing.py", line 687, in _evaluate
    type_ =_type_check(
  File "C:\Program Files\Python310\lib\typing.py", line 173, in _type_check
    raise TypeError(f"{msg} Got {arg!r:.100}.")
TypeError: Forward references must evaluate …

打开"python.analysis.typeCheckingMode": "strict"或时"python.analysis.typeCheckingMode": "basic"， .py包含其他模块导入的文件无法识别重新导入并以错误突出显示它们：

"Flow" is not exported from module "prefect"
  Import from "prefect.core" insteadPylancereportPrivateImportUsage

其中原始模块具有__init__.py但不包含__all__导出，但导入所有单个对象（在上面的情况下Flow）。有什么方法可以关闭该特定设置settings.json或处理消除错误噪音的问题吗？

我需要检查对象是否是打字的后代。Literal，我有这样的注释：

GameState: Literal['start', 'stop']

我需要检查GameState注释类型：

def parse_values(ann)
   if isinstance(ann, str):
       # do sth
   if isinstance(ann, int):
       # do sth
   if isinstance(ann, Literal):
       # do sth

但这会导致错误，所以我将最后一个交换为：

if type(ann) == Literal:
   # do sth

但它永远不会返回 True，所以有人知道解决方法吗？

在 python 中，如果我正在编写一个函数，这是输入提示字符串列表的最佳方式：

def sample_def(var:list[str]):

我有一个带有底层对象的代理类。我希望将代理对象传递给需要底层对象类型的函数。如何使代理类型与底层对象匹配？

class Proxy:
    def __init__(self, obj):
        self.obj = obj

    def __getattribute__(self, name):
        return getattr(self.obj, name)

    def __setattr__(self, name, value):
        setattr(self.obj, name, value)

def foo(bar: MyClass):
    ...

foo(Proxy(MyClass())) # Warning: expected 'MyClass', got 'Proxy' instead

我有一个自定义类型，我想启用它的值解包（元组解包等）。我知道在 Python 中执行此操作的最简单方法是实现__iter__. 这在运行时效果很好，但我想提供类型注释，以便为每个项目返回正确的类型，例如：

import typing as t
from dataclasses import dataclass

@dataclass
class Foo:
    a: str
    b: bool

    def __iter__(self) -> t.Iterable[str, bool]:
        yield self.a
        yield self.b

在运行时，这按预期工作：

string, bool = Foo("Hello", False)

但是，string以上bool内容均报告为Any类型。是否有一种合理的方法可以在保留类型的同时提供此用例？

现实世界的类型不容易转换为 NamedTuple 等。

类似于如何注释多个返回值的类型？