标签: python-typing

我很难从文档中准确理解什么typing.Annotated是有好处的，并且更难在文档之外找到解释/示例。

或者它“对某事有好处”完全取决于您使用的第三方库吗？您会在什么（现实世界）环境中使用Annotated？

现在Python 3.10已经发布了，在指示参数或返回值可能是可选的（即可以是None. 那么什么是首选：

选项1：

def f(parameter: Optional[int]) -> Optional[str]:

选项2：

def f(parameter: int | None) -> str | None:

Type | None另外，和之间有什么偏好吗None | Type？

TypeVar并且NewType似乎相关，但我不确定何时应该使用每个或在运行时和静态时有什么区别。

例如：

def foo(bar: int = None):
    pass

当我检查barpycharm的类型/注释时，告诉我它是Optional[int].

bar: int = None看起来更干净bar: Optional[int] = None，尤其是当你有 10+ 个参数时。

那么我可以简单地省略Optional吗？像 mypy 或其他 linter 这样的工具是否会将这种情况突出显示为错误？

看起来python本身不喜欢这个想法：

In [1]: from typing import Optional
In [2]: from inspect import signature

In [3]: def foo(a: int = None): pass
In [4]: def bar(a: Optional[int] = None): pass

In [5]: signature(foo).parameters['a'].annotation
Out[5]: int

In [6]: signature(bar).parameters['a'].annotation
Out[6]: typing.Union[int, NoneType]

我正在尝试输入 Hint the function bar，但是Too few arguments当我运行 mypy.txt 时出现错误。

from typing import Callable, Optional

def foo(arg: int = 123) -> float:
    return arg+0.1

def bar(foo: Callable[[int], float], arg: Optional[int] = None) -> float:
    if arg:
        return foo(arg)
    return foo()

print(bar(foo))
print(bar(foo, 90))

我也尝试过：

• Callable[[], float]（出现Too many arguments错误）
• Callable[[Optional[int]], float]（又出现一个错误）

那么，我应该如何进行函数的类型提示呢bar？

我大量使用 python 3 中的 python 类型支持。

最近我试图将一个函数作为参数传递，但kwargs在typing.Callable签名中找不到任何帮助。

请检查下面的代码和评论。

import typing

# some function with singnature typing
def fn1_as_arg_with_kwargs(a: int, b: float) -> float:
    return a + b

# some function with singnature typing
def fn2_as_arg_with_kwargs(a: int, b: float) -> float:
    return a * b

# function that get callables as arg
# this works with typing
def function_executor(
        a: int, 
        b: float, 
        fn: typing.Callable[[int, float], float]):
    return fn(a, b)

# But what if I want to …

假设我想在Python中编写一个接受任何类型数字的函数，我可以将其注释如下：

from numbers import Number

def foo(bar: Number):
    print(bar)

将这个概念更进一步，我正在编写接受数字类型（即或intdtypes ）作为参数的函数。目前，我正在写：floatnumpy

from typing import Type

def foo(bar: Type):
    assert issubclass(bar, Number)
    print(bar)

我想我可以Type用类似的东西代替NumberType（类似于NotImplementedType和朋友，在Python 3.10中重新引入），因为所有数字类型都是以下的子类Number：

from numbers import Number
import numpy as np

assert issubclass(int, Number)
assert issubclass(np.uint8, Number)

事实证明（或者至少据我所知），NumberTypePython (3.9) 中不存在泛型这样的东西：

>>> type(Number)
abc.ABCMeta

是否有一种干净的方法（即没有运行时检查）来实现所需的注释类型？

目前，我正在尝试更多地使用 numpy 类型来使我的代码更清晰，但是我已经达到了目前无法覆盖的限制。

是否可以指定特定的形状以及相应的数据类型？例子：

Shape=(4,)
datatype= np.int32

到目前为止，我的尝试如下所示（但都只是抛出错误）：

第一次尝试：

import numpy as np

def foo(x: np.ndarray[(4,), np.dtype[np.int32]]):
...
result -> 'numpy._DTypeMeta' object is not subscriptable

第二次尝试：

import numpy as np
import numpy.typing as npt

def foo(x: npt.NDArray[(4,), np.int32]):
...
result -> Too many arguments for numpy.ndarray[typing.Any, numpy.dtype[+ScalarType]]

另外，不幸的是，我在文档中找不到有关它的任何信息，或者只有当我按照文档记录的方式实现它时才会出现错误。

我是 Python 新手，发现 swmmtoolbox 包出现以下错误。我非常感谢您的评论。谢谢

回溯（最近一次调用最后一次）：

File "C:\Users\Hydraulic Group\anaconda3\lib\site-packages\typic\compat.py", line 16, in <module>
    from typing import Final, TypedDict, Literal, Protocol, **TypeGuard**, get_origin, get_args  # type: ignore

ImportError: cannot import name 'TypeGuard' from 'typing' (C:\Users\Hydraulic Group\anaconda3\lib\typing.py)

在处理上述异常的过程中，又发生了一个异常：Traceback（最近一次调用最后）：

File "E:\VARS_Research\ostrich_swmm_master\ostrich_swmm\__main__.py", line 11, in <module>
    import extract

  File "E:\VARS_Research\ostrich_swmm_master\ostrich_swmm\extract.py", line 8, in <module>
    import swmmtoolbox.swmmtoolbox as swmmtoolbox

  File "C:\Users\Hydraulic Group\anaconda3\lib\site-packages\swmmtoolbox\swmmtoolbox.py", line 19, in <module>
    from tstoolbox import tsutils

  File "C:\Users\Hydraulic Group\anaconda3\lib\site-packages\tstoolbox\tsutils.py", line 24, in <module>
    import typic

  File "C:\Users\Hydraulic Group\anaconda3\lib\site-packages\typic\__init__.py", line 4, in …

我遇到了一个可以通过交叉类型轻松解决的问题（目前正在讨论但尚未实施），并且想知道最干净的解决方法是什么。

当前设置和问题

我当前的设置大致对应于以下动物的 ABC 层次结构。有许多动物“特征”（CanFly、CanSwim等）被定义为抽象子类（尽管它们也可以被定义为 mixin）。

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def name(self) -> str: ...  
    
class CanFly(Animal):
    @abstractmethod
    def fly(self) -> None: ...
    
class CanSwim(Animal):
    @abstractmethod
    def swim(self) -> None: ...

以此我定义了特定的动物类别，包括抽象的和具体的：

class Bird(CanFly):
    def fly(self) -> None:
        print("flap wings")
    
class Penguin(Bird, CanSwim):
    def name(self) -> str:
        return "penguin"
    def swim(self) -> None:
        print("paddle flippers")

我还定义了一个通用类来抚摸特定类型的动物：

from typing import Generic, TypeVar

T = TypeVar("T", bound=Animal, contravariant=True)

class Petter(Generic[T], ABC):

    @abstractmethod …