Mypy:有什么方法可以实现'SelfType‘TypeVar吗？
Mypy是一个静态类型检查工具，它可以帮助开发者在编写Python代码时发现潜在的类型错误。在Mypy中，'SelfType'和'TypeVar'是两个不同的概念。
- SelfType: SelfType是一种特殊的类型注解，用于表示一个类方法的返回类型应该是该类的实例类型。在Python中，由于缺乏内置的SelfType支持，因此无法直接使用SelfType。然而，可以通过使用泛型来模拟SelfType的行为。
- 例如，假设有一个名为
MyClass的类，我们希望该类的某个方法返回的类型是该类的实例类型。可以使用TypeVar来定义一个泛型变量，然后将其作为方法的返回类型注解。示例代码如下： - 例如，假设有一个名为
MyClass的类，我们希望该类的某个方法返回的类型是该类的实例类型。可以使用TypeVar来定义一个泛型变量，然后将其作为方法的返回类型注解。示例代码如下： - 在上述示例中，我们使用TypeVar创建了一个泛型变量T，并将其约束为'MyClass'类型。然后，在
get_instance方法的返回类型注解中使用了T，表示该方法返回的类型应该是'MyClass'或其子类。 - TypeVar: TypeVar是Python中用于定义泛型变量的工具。它可以用于创建一个占位符类型，用于表示某个具体类型的未知。TypeVar通常与泛型类型注解一起使用，以增加代码的灵活性和可读性。
- 例如，假设我们有一个名为
Container的泛型类，我们希望该类的元素类型是未知的。可以使用TypeVar来定义一个泛型变量，并将其作为类的类型注解。示例代码如下： - 例如，假设我们有一个名为
Container的泛型类，我们希望该类的元素类型是未知的。可以使用TypeVar来定义一个泛型变量，并将其作为类的类型注解。示例代码如下： - 在上述示例中，我们使用TypeVar创建了一个泛型变量T。然后，在
Container类的构造函数中使用了List[T]作为参数类型注解，表示该类的元素类型是未知的。
总结：
- 'SelfType'在Python中无法直接实现，但可以通过使用泛型来模拟其行为。
- 'TypeVar'是Python中用于定义泛型变量的工具，用于表示某个具体类型的未知。
- Mypy是一个静态类型检查工具，可以帮助开发者发现Python代码中的类型错误。
相关·内容
为了说明这个问题，我定义了一个PositiveNumber类，它是一个Number类的子类。由于Python不支持类型转换，所以我将from_number定义为一种方便的方法，可以用来将一个实例强制转换到另一个实例。这个方法对于Number类的所有子类型都是通用的，所以我将它放入父类中。
from __future__ import annotations
from typing import Any, Dict
class Number:
def __init__(self, value: float, *args, **kwargs) -> None:
浏览 0提问于2022-01-07得票数 3
回答已采纳
2回答
假设我有一个接受Garthok、Iterable[Garthok]、Iterable[Iterable[Garthok]]等的函数。
def narfle_the_garthoks(arg):
if isinstance(arg, Iterable):
for value in arg:
narfle_the_garthoks(arg)
else:
arg.narfle()
是否有任何方式为arg指定类型提示，指示它接受任何级别的Iterables的Garthoks？我怀疑不是，但我想我应该检查一下我是不是漏了什么东西。
作为解决办法，我只是指定了几个深度
浏览 1提问于2018-12-19得票数 48
回答已采纳
1回答
我想创建一个具有抽象方法的抽象基类，该方法返回实现该接口的任何子类的实例。除了我在下面创建的内容之外，有没有更好的方法来实现这一点呢？
在我的代码示例中，我将Animal类设为泛型。子类可以从Animal继承，并将泛型参数指定为自己，但在我看来这似乎很笨拙和错误。我想我可能遗漏了一些明显的东西。
请注意，在下面的代码中，当我创建Animal子类时，类定义使用了类似于Dog(Animal["Dog"])的内容。在我看来，它看起来不太对劲，但它可以用于类型检查。有没有办法为抽象方法指明它必须返回与self相同的类型
import abc
from typing import Gen
浏览 9提问于2021-05-26得票数 0
回答已采纳
2回答
瓶路装潢器式暗示
、、、
我有一个简单的烧瓶应用程序，我用它添加了一个装饰器，以确保每个请求都有一个特定的标题。
import functools
from http import HTTPStatus
import flask
from flask.typing import ResponseReturnType
app = flask.Flask(__name__)
# What type hints should be added to this?
def requires_header(func):
@functools.wraps(func)
def check_headers(*ar
浏览 6提问于2021-10-06得票数 2
回答已采纳
我希望在运行具有以下内容的文件时，在运行MyPy之后会出现错误：
from typing import TypeVar
T = TypeVar('T')
def do_nothing(one_arg: T, other_arg: T) -> None:
return
do_nothing(1, 2)
do_nothing(1, "abc")
do_nothing(1, None)
do_nothing("abc", None)
do_nothing([1, 2, 3], { "a": "b"})
浏览 2提问于2022-07-25得票数 0
回答已采纳
考虑以下代码：
from typing import Callable, TypeVar
T = TypeVar('T')
def middle_man(
producer: Callable[[], T],
consumer: Callable[[T], None]
) -> None:
consumer(producer())
middle_man(
lambda: "HELLO",
lambda s: print(s.lower())
)
这段代码运行时没有出现错误，但是，mypy无法推断第二个lambd
浏览 1提问于2019-07-26得票数 9
1回答
稍微有点背景，我基本上需要定义一个int包装器类型，比如MyInt (以及其他一些类)，以及另一个可以接受MyInt对象以及其他类型对象的通用Interval类型。由于Interval所接受的类型不属于一个整洁的层次结构，我认为这将是实验Protocol的一个完美的用例，在我的例子中，它需要几个方法和几个@classmethod，所有的方法都返回一个“自我类型”，即MyInt.my_method返回一个MyInt。这是一个MCVE：
from dataclasses import dataclass
from typing import Union, ClassVar, TypeVar, Ge
浏览 0提问于2018-11-02得票数 8
回答已采纳
如果我想正确地使用类型注释来处理类型模块中的命名元组，那么：
from typing import NamedTuple, List
class Foo(NamedTuple):
my_list: List[int] = []
foo1 = Foo()
foo1.my_list.append(42)
foo2 = Foo()
print(foo2.my_list) # prints [42]
在Python中避免可变默认值痛苦的最好或最干净的方法是什么？我有一些想法，但似乎没有什么是好的。
使用None作为默认值
类Foo(NamedTuple)：my_list: Option
浏览 4提问于2021-08-06得票数 8
回答已采纳
1回答
我有用JSON创建的Python数据类(实际上很多)。我希望有一个从JSON创建类实例的方法。
我有这样的事情：
class FromJSONMixin:
@staticmethod
@abstractmethod
def from_json(json: Union[Dict, TypedDict], **kwargs):
raise NotImplementedError
class PatientJSON(TypedDict):
ID: str
Name: str
Description: str
BirthDat
浏览 3提问于2021-05-13得票数 5
回答已采纳
如何在类中定义函数，使函数的返回类型是“当前类”，而不是基类。例如：
Class Parent:
def set_common_properties_from_string( input : str ) -> <WHAT SHOULD BE HERE>
# Do some stuff you want to do in all classes
return self
Class Child( Parent ):
pass
def from_file( filename : str ) -> 'Child'
浏览 2提问于2017-02-21得票数 3
回答已采纳
我有两个数据处理器，它们实现了一个接口，它的方法"process“接管了处理部分，结果将被返回。结果应该是符合给定结构的字典。这就是为什么我为每个处理器结果定义TypedDict的原因。也许我还没有正确理解TypedDict，但我想实现这样的目标：
import abc
from typing import TypedDict
class AProcessorResult(TypedDict):
param1: str
param2: int
class BProcessorResult(TypedDict):
paramA: str
paramB: str
浏览 10提问于2022-02-25得票数 0
回答已采纳
from typing import Type, TypeVar
T = TypeVar('T', bound='A')
class A:
@classmethod
def create(cls: Type[T]) -> T:
return cls()
class B(A):
def do(self):
...
@classmethod
def create(cls):
obj = super().create()
obj.do()
浏览 3提问于2022-08-22得票数 0
我有个功能如下，
def run_the_f(f):
# run f function after some validation
在一定条件下，f函数的签名与f(1.0), f(1.0,2.0), f(1.0,2.0,3.0,..)类似。换句话说，输入参数的数量可以在f中变化，类似于。
我用的是mypy，我尝试了下面的失败，
def run_the_f(f: Callable[[*float],float]):
# run f after some validation
有人能支持什么填写可调用的？
浏览 17提问于2022-09-08得票数 0
2回答
我想在我的插件钩子规范中添加类型注释，这样就可以检查钩子实现。使用中的这个简化示例
import pluggy # type: ignore
hookspec = pluggy.HookspecMarker("myproject")
hookimpl = pluggy.HookimplMarker("myproject")
class MySpec(object):
"""A hook specification namespace."""
@hookspec
def myhook
浏览 0提问于2019-02-13得票数 1
回答已采纳
1回答
假设我试图为一个为用户定义的类型注册反序列化器的库函数编写类型提示:用户应该提供类型T和函数decode: str -> T。
用python的PEP-484类型提示编写这篇文章的最自然的方法是：
from typing import Callable, Type, TypeVar
T = TypeVar("T")
def register_decoder(type_: Type[T], decode: Callable[[str], T]):
...
不幸的是，Type[T]在T中是协变的，这意味着对解码函数的要求还不够严格:至少在pyright中，调用regi
浏览 15提问于2022-06-28得票数 3
1回答
假设我有一个具有多个生成器函数的程序，这些函数都具有返回类型Generator[<type>, <type2>, None]，并且我希望创建一个别名SimpleGenerator[<type>, <type2>]，然后将其扩展到前一个。
所以，例如
def my_generator() -> Generator[int, str, None]:
...
可以写
def my_generator() -> SimpleGenerator[int, str]:
...
我想这些代码可能看起来类似于(显然不正确的python
浏览 2提问于2022-08-04得票数 1
回答已采纳
2回答
我试图将类型注释添加到现有的包中，但显然我遗漏了一些重要的东西。我有一个抽象的超类和子类。超类应该是泛型的，而子类应该是特定类型的。这是一个简单的例子，如果我看到的话，也是我想看到的：
from typing import Generic, TypeVar
T = TypeVar("T")
class A(Generic[T]):
def method(self, arg: T):
...
class B(A[int]):
def method(self, arg):
reveal_locals()
期望的(或至少希望的)：
浏览 0提问于2019-08-16得票数 6
1回答
我已经创建了一个自定义的类似字典的类，以简化跨大型数据集合并评估指标。这个类实现了一个__add__方法来汇总各种指标。
下面是我正在编写的代码的简化版本：
from __future__ import annotations
from typing import TypeVar, Dict
T = TypeVar('T', int, float)
class AddableDict(Dict[str, T]):
def __add__(self, other: AddableDict[T]) -> AddableDict[T]:
if n
浏览 22提问于2020-07-31得票数 2
回答已采纳
我正在创建一个获得字典并创建给定类的实例的类。当前版本可以工作，但是您需要告诉类它应该将字典转换成哪种类型。
我可以去掉Generic，但是我想继续使用类型提示。
from typing import Dict, Generic, List, Type, TypeVar
T = TypeVar("T")
class DictsToObjectsParser(Generic[T]):
def __init__(self, object_type: Type[T]):
self.object_type = object_type
def try
浏览 12提问于2022-10-14得票数 1
假设我想用Python设计一个Array数据类型。它的目的是存放一个特定类型的固定大小列表。
T = typing.TypeVar('T')
class Array(typing.Generic[T]):
l: list[T]
s: int
所以类型提示应该是这样的：
fixed_size_array: Array[int]
我要做的是在类型提示中包括Array的长度，例如：
fixed_size_array_of_five_ints: Array[int, 5]
fixed_size_array_of_four_ints: Array[int, 4]
我可以将Arra
浏览 2提问于2021-05-14得票数 1
回答已采纳
2回答
和的类型是什么？
、、
我想表达的是，第一个参数是第二个参数的“列表”，并且结果具有与第二个参数相同的类型。
这个mysum (即。而不是标准的lib sum)，应该与int/float/str/list以及任何其他支持+=的类型工作得一样好。
天真地：
def mysum(lst: list[T], start: T) -> T:
x = start
for item in lst:
x += item
return x
它产生：
(dev311) go|c:\srv\tmp> mypy sumtype.py
sumtype.py:26: error: U
浏览 6提问于2022-07-29得票数 4
回答已采纳
2回答
我想静态地强制执行一个类的方法返回一个以某种抽象类型包装的值，而我对此一无所知：
例如，给定抽象类
F = ???
class ThingF(Generic[F]):
@abstractmethod
def action(self) -> F[Foo]:
...
我希望能够静态地检查这是否无效：
class ThingI(ThingF[List]):
def action(self) -> Foo:
...
因为action不返回List[Foo]。
但是，ThingF的上述声明甚至没有运行，因为Generic希望它
浏览 0提问于2018-09-07得票数 3
回答已采纳
我正在使用Python从磁盘中读取JSON，并试图确保我的类型提示在下游是正确的。例如，如下所示：
from typing import List
def verify_contains_ints(items: List[object]) -> List[int]:
for item in items:
if not isinstance(item, int):
raise TypeError("List contents must be all ints")
return items
我遇到的问题是，我不想为in
浏览 6提问于2020-02-10得票数 4
我有一份文件 它有一个类 和一个子类 ..。两者都有方法 ，它根据布尔值的值具有不同的返回类型。 ..。 下面是文件的完整代码： # t.py
from __future__ import annotations
from typing import TypeVar, Optional, overload, Literal
CatOrDog = TypeVar("CatOrDog", bound="Animal")
class Animal:
@overload
def foo(self: CatOrDog, inplace: Li
浏览 19提问于2021-03-02得票数 0
回答已采纳
2回答
使用以下示例：
from typing import Callable, Generic, Type, TypeVar
XType = TypeVar('XType', bound=int)
class C(Generic[XType]):
def f(self, x_init: XType) -> XType:
return x_init
def combinator(c_cls: Type[C[XType]]) -> Callable[[C[XType], XType], XType]:
old_f = c_cls.f
浏览 6提问于2020-04-19得票数 13
1回答
考虑有一个父类和几个继承自该父类的子级的情况。设置一个TypeVar，以便在传递或返回子对象时键入提示。为了简单和幻想，只有一个孩子被创造出来。
from typing import TypeVar
class Parent(object):
pass
class Child(Parent):
pass
T_co = TypeVar("T_co", bound=Parent)
根据应用的类型暗示位置，mypy的响应会有所不同。当应用于返回时，mypy将引发以下错误
def hint_return() -> T_co:
return Chil
浏览 0提问于2020-03-27得票数 0
回答已采纳
我有一个类似如下的BaseClass：
class BaseClass:
@classmethod
def create(cls, arg1: str) -> BaseClass:
instance = cls(arg1)
return instance
以及如下的派生类：
class DerivedClass(BaseClass):
def __init__(self, arg: str) -> None:
self.arg = arg
现在，当我这样做的时候
data: DerivedClass = De
浏览 0提问于2021-06-18得票数 3
我希望能够编写一个函数来检查字典是否符合我的TypedDict，但是我不能得到正确的泛型类型。因此，得到的函数应该类似于：
T = typing.Generic('T', bound=...) # This is `bound=...` something I want to find out
def check_typeddict(value: dict, to_type: typing.Type[T]) -> T:
# do some type checking
return typing.cast(T, value)
check_type(MyT
浏览 0提问于2018-10-11得票数 1
先发号施令，代码就在后面！
现在，我正在尝试为一个通用商店系统创建一个命令行接口模块，我可以在今后的任何项目中使用。我之所以使用MyPy，是因为坦率地说，我不相信自己会保持类型的直截了当，所以由于这个项目的尝试泛化，这导致我使用了一些我以前从未使用过的东西。我的目标是，只要他们有.name，我就可以让商店持有并出售我想要的任何物品。
无论如何，在编写函数以通过检查输入的名称从用户的购物车中删除项目时(例如，如果我的购物车中有一个名为“TypeVar”的项目，我会在输入中键入“移除剑”)，我意识到我没有办法缩小输入类型，这样我就可以确保TypeVar(我的TypeVar的名称)有一个.name。
浏览 2提问于2022-05-01得票数 0
回答已采纳
在中，multiprocessing.Event被明确声明为threading.Event的克隆，并且具有相同的接口。我想对变量和参数进行注释，以便它们能够接受这些类中的任何一个，而mypy将对它们进行类型检查。我尝试创建一个协议(我使用了multiprocessing.synchronize.Event，因为这是multiprocessing.Event返回的实际类)。
import multiprocessing
import threading
from typing import Optional, Type, Protocol
class Event(Protocol):
浏览 1提问于2020-01-16得票数 3
回答已采纳
1回答
我试图定义一个类，它将另一个类作为属性_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 se
浏览 4提问于2021-09-26得票数 6
回答已采纳
1回答
注释返回方法的返回类型
、、、、
我使用的是构建器模式，其中(大型)类上的大多数方法返回它们的标识(self)，并因此进行注释以返回它们所属的类的类型：
class TextBuilder:
parts: List[str] # omitted
render: Callable[[], str] # for brevity
def text(self, val: str) -> "TextBuilder":
self.parts.append(val)
return self
def bold(self, val:
浏览 2提问于2020-05-26得票数 1
回答已采纳
2回答
带有描述符的类型暗示
、、、、
在中，似乎添加了对描述符的类型暗示支持。
然而，它似乎没有最后确定的“正确”使用示例被发布，也没有任何文档被添加到或中。
看起来正确的用法类似于
from typing import TypeVar
T = TypeVar('T')
V = TypeVar('V')
class classproperty():
def __init__(self, getter: Callable[[Type[T]], V]) -> None:
self.getter = getter
def __get__(self, insta
浏览 0提问于2019-01-29得票数 12
3回答
递归类型注解
、、
在适用的情况下，我试图在我的代码库中引入静态类型注释。一种情况是在读取JSON时，生成的对象将是一个由字符串键组成的字典，其值为以下类型之一：
bool
str
float
int
list
dict
但是，上面的list和dict可以包含相同类型的字典，从而产生递归定义。这在Python3 3的类型结构中是有代表性的吗？
浏览 0提问于2018-12-05得票数 8
回答已采纳
2回答
当类型检查器(mypy)查看时，我需要创建一个类似于typing.Any的类型，但是它可以与typing.Any区别开来。
用例是一些非常“元”的代码，需要从一组可以用typing.Any注释的其他变量中找到用这种类型注释的变量。请注意，我永远不需要实际创建这个Type的实例，我只需要它作为数据类上下文中的类型注释。示例：
from dataclasses import dataclass, fields
from typing import Any
MyAny = ... # What to put here?
@dataclass()
class Test:
a: Any
浏览 4提问于2019-12-16得票数 3
回答已采纳
我试图注释一个作为类实现的装饰器，但mypy似乎要么丢失了注释，要么丢失了类型，并认为它是一个Any。我想要注释的是： class my_decorator:
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
return self.func(*args, **kwargs)
@my_decorator
def func():
return 2 我如何注释这个函数，以便在修饰之后检测到func返回一个int？我意识到上面的代码
浏览 17提问于2020-10-22得票数 0
回答已采纳
1回答
类装饰器上的Mypy注释
、、、
我在Python中使用类修饰器，无法确定给类提供哪种类型的注释，以使mypy高兴。
我的代码如下：
from typing import Type
from pprint import pformat
def betterrepr(cls:Type[object]):
"""Improve representation of a class"""
class improved_class(cls): # line 12
def __repr__(self) -> str:
re
浏览 1提问于2019-07-02得票数 5
回答已采纳
尽管我在、和上花费了大量的时间，但我还是很难理解什么时候使用，什么时候使用Union。
问题的简单版本：Numeric = TypeVar('Numeric', int, float)和Numeric = Union[int, float]的区别是什么？
下面是我遇到的一个更详细的例子：
"""example1.py
Use of Union to define "Numeric" type.
"""
from typing import Union, Sequence
Numeric = Union[int,
浏览 3提问于2020-09-16得票数 0
回答已采纳
1回答
至少根据mypy的说法，我在以下代码中遇到了问题： from multiprocessing import Pool
from typing import Tuple, TypeVar
T = TypeVar("T", int, str)
def do_something(a: T) -> Tuple[T, bool]:
# Something happening here...
return a, False
if __name__ == "__main__":
pool = Pool(processes=10)
浏览 17提问于2021-06-25得票数 1
回答已采纳
我们正试图在django (3.2)项目中添加类型提示。我们使用django-stub (1.12.0)。
我们有一个带有自定义BaseManager的BaseManager，用于几乎所有其他模型。在某些情况下，我们还扩展了自定义管理器。
示例：
class BaseManager(models.Manager):
# ...
class AbstractBaseModel(models.Model):
# ...
objects = BaseManager()
# ...
class MyManager(BaseManager):
# ...
c
浏览 3提问于2022-10-05得票数 0
在我们的代码中有一个典型的数据转换模式:当值为None时，我们让它通过。例如， def capitalize(value):
if value is None:
return None
return value.capitalize()
# usage example:
assert capitalize(None) is None
assert capitalize("hello world") == "Hello world" 我可以这样注释它： from typing import Optional
浏览 48提问于2021-10-20得票数 0
回答已采纳
1回答
我想创建一个类型注释T，它描述的类型必须是类A和类B的子类。
T = TypeVar('T', bound=A)只指定T必须是A的子类。
T = TypeVar('T', A, B)只指定T必须是A的子类或B的子类，但不一定两者兼而有之。
我实际上想要类似于T = TypeVar('T', bound=[A, B])的东西，这意味着T必须同时子类A和B。有什么标准的方法吗？
浏览 2提问于2020-07-08得票数 5
回答已采纳
我有一些类似以下的东西： from typing import TypeVar, Callable, Generic, Type, Union, Optional
T = TypeVar("T")
V = TypeVar("V")
class DescClass(Generic[T, V]):
"""A descriptor."""
def __init__(self, func: Callable[[T], V]) -> None:
self.func = func
浏览 17提问于2019-05-01得票数 9
回答已采纳
我有一个Python包，它基于collections.abc (映射、序列等)提供的ABC定义了各种集合。我想利用Python3.5中引入的类型暗示工具，但我怀疑什么才是最好的方法。
让我们以其中一个类为例；直到现在，我有一些类似于这样的东西：
from collections.abc import Mapping
class MyMapping(Mapping):
...
要将其转换为泛型类型，建议执行如下操作：
from typing import TypeVar, Hashable, Mapping
K = TypeVar("K", bound=Hashabl
浏览 3提问于2015-10-14得票数 13
1回答
对于下面的示例，mypy返回一个错误：
错误:赋值中不兼容的类型(表达式有"A“类型，变量有”A1“类型)
from typing import Type
class A:
pass
class A1(A):
pass
class A2(A):
pass
def fun(A_type: Type[A]) -> A:
if A_type == A1:
return A1()
else:
return A2()
a1: A1 = fun(A1)
理想情况下，我想做的是在fun签名中强制执行一个依赖项
浏览 1提问于2019-11-02得票数 2
回答已采纳
1回答
我稍微修改了，但得到了一个错误：
from typing import Generic, TypeVar, Union
T = TypeVar("T", bound=Union[int, float])
class Person(Generic[T]):
def __init__(self, salary: T) -> None:
self.salary: T = salary
def get_yearly_bonus(self, amount: T) -> None:
self.salary += amoun
浏览 12提问于2022-08-08得票数 1
回答已采纳
2回答
这不是什么大问题，但我只是想知道如何解决这个问题。由于我对Python上的函数注释并不熟悉，所以我对它并不熟悉。下面我有个问题。
当你做一个装潢师并且想要把注释放在上面的时候，你是怎么做的？
例如，下面这样的代码。
def decorator(func: Callable[[*args,**kwargs], <what type should be here?>]) -> <??>:
def new_func(*args, **kwargs):
return func(*args, **kwargs)
return new_func
浏览 3提问于2021-02-28得票数 5
回答已采纳
请考虑一下python3.5代码片段：
class Foo:
pass
class Bar(Foo):
pass
class AbstractSomething:
def get_foobinator_type(self):
return Foo
我想注释() get_foobinator_type方法的返回值：“它返回一个类型，或者是一个Foo或它的任何子类型”。
我在Python中找不到任何明智的方法来做这件事。以下是明显错误的方法：
def get_foobinator_type(self) -> Foo意味着此方法返回Foo的
浏览 4提问于2016-08-18得票数 1
回答已采纳
对于完整的上下文，我希望做一些能为测试做更好的静态分析的装饰器。在理想情况下，它的工作原理如下： class SomeTest(unittest.TestCase):
@login_decorate
def test_login(self):
reveal_type(self.user) # type: User
@anonymous_decorate
def test_anonymous(self):
reveal_type(self.user) # type: None 作为开始，我正在尝试创建一个如下所示的装饰器：
浏览 17提问于2019-12-19得票数 1
回答已采纳
我正在编写一个函数，它使用解析器列表(具有具体类型)来解析Union类型对象，并返回一个联合类型。然而，我发现我不能让Union与List generic一起正常工作。 from typing import List,Union,TypeVar
T=TypeVar("T")
T1=TypeVar("T1")
def union_list(l: List[Union[T,T1]] )-> Union[T,T1]:
return l[0]
test=[0,"_"]
result=union_list(test)
reveal_ty
浏览 26提问于2019-01-23得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
