本文由 大侠(AhcaoZhu)原创，转载请声明。
链接: https://blog.csdn.net/Ahcao2008

?摘要

• 全文介绍python的 typing_extensions 模块（允许在旧版Python上启用、实验新的类型系统特性）、函数、类及类的方法和属性。
• 它通过代码抓取并经AI智能翻译和人工校对。
• 是一部不可多得的权威字典类工具书。它是系列集的一部分。后续陆续发布、敬请关注。【原创：AhcaoZhu大侠】

?模块图

typing_extensions
	◆abc
	◆collections
	◆functools
	◆inspect
	◆operator
	◆sys
	◆types
	◆typing
	◆warnings

?类关系图

◆object
	◆dict
		typing_extensions.TypedDict
	◆list
		◆functools._HashedSeq
		typing_extensions.ParamSpec
		typing_extensions._ConcatenateGenericAlias
	◆type
		◆abc.ABCMeta
			typing_extensions._ProtocolMeta
		typing_extensions._AnyMeta
		typing_extensions._NamedTupleMeta
		typing_extensions._TypedDictMeta
	◆typing._Final
		◆typing._GenericAlias
			◆typing._VariadicGenericAlias
			typing_extensions._AnnotatedAlias
			typing_extensions._UnpackAlias
		◆typing._SpecialForm
			typing_extensions._ConcatenateForm
			typing_extensions._FinalForm
			typing_extensions._LiteralForm
			typing_extensions._RequiredForm
			typing_extensions._TypeAliasForm
			typing_extensions._TypeGuardForm
			typing_extensions._UnpackForm
		typing_extensions._SpecialForm
	typing_extensions.Annotated
	typing_extensions.NamedTuple
	typing_extensions.Protocol
		typing_extensions.SupportsIndex
	typing_extensions._DefaultMixin
		typing_extensions.TypeVarTuple
	typing_extensions._Immutable
		typing_extensions.ParamSpecArgs
		typing_extensions.ParamSpecKwargs
	typing_extensions.An

?模块全展开

☘️【typing_extensions】

typing_extensions, fullname=typing_extensions, file=typing_extensions.py

?统计

序号	类别	数量
2	bool	3
4	str	4
5	tuple	2
6	list	2
8	dict	1
9	module	10
10	class	32
11	function	36
13	residual	39
14	system	9
15	private	47
16	all	129

?常量

?bool

1 PEP_560 True
2 TYPE_CHECKING False
3 _TAKES_MODULE False

?tuple

4 _TYPEDDICT_TYPES (<class ‘typing_extensions._TypedDictMeta’>,)
5 _prohibited_namedtuple_fields (‘new’, ‘init’, ‘slots’, ‘getnewargs’, ‘_fields’, ‘_field_defaults’, ‘_field_types’, ‘_make’, ‘_replace’…

?list

6 _PROTO_WHITELIST [‘Callable’, ‘Awaitable’, ‘Iterable’, ‘Iterator’, ‘AsyncIterable’, ‘AsyncIterator’, ‘Hashable’, ‘Sized’, ‘Container’, 'C…

?模块

?7 abc

abc, fullname=abc, file=abc.py

?8 collections

collections, fullname=collections, file=collections_init_.py

?9 functools

functools, fullname=functools, file=functools.py

?10 inspect

inspect, fullname=inspect, file=inspect.py

?11 operator

operator, fullname=operator, file=operator.py

?12 sys

sys, fullname=sys, file=

?13 types

types, fullname=types, file=types.py

?14 typing

typing, fullname=typing, file=typing.py

?15 warnings

warnings, fullname=warnings, file=warnings.py

?16 types

types, fullname=types, file=types.py

?函数

?17 _check_generic(cls, parameters, elen=<object object at 0x000001F281BD6FF0>)

_check_generic(cls, parameters, elen=<object object at 0x000001F281BD6FF0>), module=typing_extensions, line:92 at site-packages yping_extensions.py

检查泛型cls(内部助手)参数的正确计数。在计数不匹配的情况下，这会给出一个很好的错误消息。

?18 _should_collect_from_parameters(t)

_should_collect_from_parameters(t), module=typing_extensions, line:122 at site-packages yping_extensions.py

?19 _collect_type_vars(types, typevar_types=None)

_collect_type_vars(types, typevar_types=None), module=typing_extensions, line:126 at site-packages yping_extensions.py

按首次出现的顺序(字典顺序)收集类型中包含的所有类型变量。例如:
        _collect_type_vars((T, List[S, T])) == (T, S)

?20 final(f)

final(f), module=typing_extensions, line:227 at site-packages yping_extensions.py

此装饰器可用于向类型检查器指示不能重写已装饰的方法，并且不能对已装饰的类进行子类化。
    例如:
        class Base:
            @final
            def done(self) -> None:
                ...
        class Sub(Base):
            def done(self) -> None:  # 类型检查器报告的错误
                ...
        @final
        class Leaf:
            ...
        class Other(Leaf):  # 类型检查器报告的错误
            ...
    没有对这些属性进行运行时检查。装饰器将被装饰对象的 ``__final__`` 属性设置为``True``，以允许运行时自省。

?21 IntVar(name)

IntVar(name), module=typing_extensions, line:259 at site-packages yping_extensions.py

?22 _overload_dummy(*args, **kwds)

_overload_dummy(*args, **kwds), module=typing, line:1062 at typing.py

当@overload被调用时触发的Helper。

?23 overload(func)

overload(func), module=typing_extensions, line:304 at site-packages yping_extensions.py

    重载函数/方法的装饰器。

?24 get_overloads(func)

get_overloads(func), module=typing_extensions, line:344 at site-packages yping_extensions.py

将*func*的所有定义重载作为一个序列返回。

?25 clear_overloads()

clear_overloads(), module=typing_extensions, line:355 at site-packages yping_extensions.py

清除注册表中的所有过载。

?26 NewType(name, tp)

NewType(name, tp), module=typing, line:1455 at typing.py

NewType创建简单的唯一类型，运行时开销几乎为零。
    静态类型检查器认为NewType(name, tp)是tp的子类型。
    在运行时，NewType(name, tp)返回一个虚拟函数，该函数只返回其参数。
    用法:
        UserId = NewType('UserId', int)
        def name_by_id(user_id: UserId) -> str:
            ...
        UserId('user')          # Fails type check
        name_by_id(42)          # Fails type check
        name_by_id(UserId(42))  # OK
        num = UserId(5) + 1     # type: int

?27 _get_protocol_attrs(cls)

_get_protocol_attrs(cls), module=typing_extensions, line:397 at site-packages yping_extensions.py

?28 _is_callable_members_only(cls)

_is_callable_members_only(cls), module=typing_extensions, line:416 at site-packages yping_extensions.py

?29 _maybe_adjust_parameters(cls)

_maybe_adjust_parameters(cls), module=typing_extensions, line:420 at site-packages yping_extensions.py

协议中使用的Helper函数。
该函数的内容与在CPython主分支上创建子类 typing.Generic.__init_subclass__ 中的逻辑非常相似。

?30 _no_init(self, *args, **kwargs)

_no_init(self, *args, **kwargs), module=typing_extensions, line:466 at site-packages yping_extensions.py

?31 runtime_checkable(cls)

runtime_checkable(cls), module=typing_extensions, line:623 at site-packages yping_extensions.py

将协议类标记为运行时协议，以便它可以与isinstance()和issubclass()一起使用。
如果应用于非协议类，则引发TypeError。
这允许进行与集合中的一次性检查非常相似的简单结构检查。例如hashhable。

?32 runtime_checkable(cls)

runtime_checkable(cls), module=typing_extensions, line:623 at site-packages yping_extensions.py

将协议类标记为运行时协议，以便它可以与isinstance()和issubclass()一起使用。
如果应用于非协议类，则引发TypeError。
这允许进行与集合中的一次性检查非常相似的简单结构检查。例如hashhable。

?33 _check_fails(cls, other)

_check_fails(cls, other), module=typing_extensions, line:668 at site-packages yping_extensions.py

?34 _dict_new(*args, **kwargs)

_dict_new(*args, **kwargs), module=typing_extensions, line:679 at site-packages yping_extensions.py

?35 _typeddict_new(*args, total=True, **kwargs)

_typeddict_new(*args, total=True, **kwargs), module=typing_extensions, line:687 at site-packages yping_extensions.py

?36 is_typeddict(tp)

is_typeddict(tp), module=typing_extensions, line:838 at site-packages yping_extensions.py

检查注释是否为TypedDict类。
        例如:
            class Film(TypedDict):
                title: str
                year: int
            is_typeddict(Film)  # => True
            is_typeddict(Union[list, str])  # => False

?37 assert_type(__val, __typ)

assert_type(__val, __typ), module=typing_extensions, line:856 at site-packages yping_extensions.py

断言(对类型检查器)该值为给定类型。
    当类型检查器遇到对assert type()的调用时，如果值不是指定的类型，它会发出一个错误:
        def greet(name: str) -> None:
            assert_type(name, str)  # ok
            assert_type(name, int)  # type checker error
    #类型检查器错误在运行时，这将返回第一个参数不变，否则什么都不做。

?38 _strip_extras(t)

_strip_extras(t), module=typing_extensions, line:879 at site-packages yping_extensions.py

从给定类型中标注的、必需的和非必需的条带。

?39 get_type_hints(obj, globalns=None, localns=None, include_extras=False)

get_type_hints(obj, globalns=None, localns=None, include_extras=False), module=typing_extensions, line:903 at site-packages yping_extensions.py

返回对象的类型提示。
    这通常与obj.__annotations__相同。但它处理编码为字符串字面值的转发引用，如果设置了默认值为None，
    则添加Optional[t]并递归地替换所有的 'Annotated[T, ...]', 'Required[T]' 或 'NotRequired[T]' 带有 'T'(除非'include_extras=True')。
    参数可以是模块、类、方法或函数。注释作为字典返回。对于类，注释也包括继承的成员。
    如果参数不是可以包含注释的类型，则引发TypeError;如果不存在注释，则返回空字典。
    注意- globalns和localns的行为是违反直觉的(除非你熟悉eval()和exec()的工作方式)。搜索顺序是先本地搜索，再全局搜索。
    -如果没有传递dict参数，则尝试使用来自obj的全局变量(或相应模块的类的全局变量)，这些也被用作局部变量。如果对象没有全局变量，则使用空字典。
    -如果传入一个dict参数，它将同时用于全局变量和局部变量。
    -如果传递两个dict参数，它们分别指定全局变量和局部变量。

?40 get_origin(tp)

get_origin(tp), module=typing_extensions, line:1070 at site-packages yping_extensions.py

获取类型的未下标版本。
    它支持泛型类型，Callable, Tuple, Union, Literal, Final, ClassVar和Annotated。
    对于不支持的类型返回None。例如:
            get_origin(Literal[42]) is Literal
            get_origin(int) is None
            get_origin(ClassVar[int]) is ClassVar
            get_origin(Generic) is Generic
            get_origin(Generic[T]) is Generic
            get_origin(Union[T, int]) is Union
            get_origin(List[Tuple[T, T]][int]) == list
            get_origin(P.args) is P

?41 get_args(tp)

get_args(tp), module=typing_extensions, line:1094 at site-packages yping_extensions.py

获取已执行所有替换的类型参数。
    对于联合，执行联合构造函数使用的基本简化。
    示例:
            get_args(Dict[str, int]) == (str, int)
            get_args(int) == ()
            get_args(Union[int, Union[T, int], str][int]) == (int, str)
            get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
            get_args(Callable[[], T][int]) == ([], int)

?42 _concatenate_getitem(self, parameters)

_concatenate_getitem(self, parameters), module=typing_extensions, line:248 at typing.py

?43 _is_unpack(obj)

_is_unpack(obj), module=typing_extensions, line:1850 at site-packages yping_extensions.py

?44 reveal_type(__obj: ~T) -> ~T

reveal_type(__obj: ~T) -> ~T, module=typing_extensions, line:1957 at site-packages yping_extensions.py

显示变量的推断类型。
    当静态类型检查器遇到对 ``reveal_type()`` 的调用时，它将发出参数的推断类型:
            x: int = 1
            reveal_type(x)
    在本例中运行静态类型检查器(例如 ``mypy``)将产生类似于'Revealed type is "builtins.int"'的输出。
    在运行时，该函数打印实参的运行时类型并原样返回。

?45 assert_never(__arg: typing_extensions.Never) -> typing_extensions.Never

assert_never(__arg: typing_extensions.Never) -> typing_extensions.Never, module=typing_extensions, line:1980 at site-packages yping_extensions.py

向类型检查器断言一行代码不可达。
    示例:
        def int_or_str(arg: int | str) -> None:
            match arg:
                case int():
                    print("It's an int")
                case str():
                    print("It's a str")
                case _:
                    assert_never(arg)
    如果类型检查器发现assert_never()的调用是可达的，它将发出一个错误。
    在运行时，这将在调用时抛出异常。

?46 dataclass_transform(*, eq_default: bool = True, order_default: bool = False, kw_only_default: bool = False, frozen_default: bool = False, field_specifiers: Tuple[Union[Type[Any], Callable[…, Any]], …] = (), **kwargs: Any) -> Callable[[~T], ~T]

dataclass_transform(*, eq_default: bool = True, order_default: bool = False, kw_only_default: bool = False, frozen_default: bool = False, field_specifiers: Tuple[Union[Type[Any], Callable[…, Any]], …] = (), **kwargs: Any) -> Callable[[~T], ~T], module=typing_extensions, line:2007 at site-packages yping_extensions.py

将函数、类或元类标记为提供类似数据类的行为的修饰符。
    示例:
            from typing_extensions import dataclass_transform
            _T = TypeVar("_T")
            # Used on a decorator function
            @dataclass_transform()
            def create_model(cls: type[_T]) -> type[_T]:
                ...
                return cls
            @create_model
            class CustomerModel:
                id: int
                name: str
            # Used on a base class
            @dataclass_transform()
            class ModelBase: ...

            class CustomerModel(ModelBase):
                id: int
                name: str

            # Used on a metaclass
            @dataclass_transform()
            class ModelMeta(type): ...

            class ModelBase(metaclass=ModelMeta): ...

            class CustomerModel(ModelBase):
                id: int
                name: str
        在这个例子中定义的每个 ``CustomerModel``  类现在的行为类似于用``@dataclasses.dataclass``装饰。
        例如，类型检查器将合成一个``__init__``方法。
        这个装饰器的参数可以用来自定义这个行为:
            - ``eq_default``指示如果调用者省略``eq``参数，则假设``eq``参数为True还是False。
            - ``order_default`` 指示如果调用者省略 ``order`` 参数，则该参数是假定为True还是False。
            - ``kw_only_default`` 表示如果调用者省略 ``kw_only`` 参数，则该参数是假定为True还是False。
            - ``frozen_default`` 指示如果调用者省略 ``frozen`` 参数，则该参数是假定为True还是False。
            - ``field_specifiers`` 指定描述字段的支持类或函数的静态列表，类似于 ``dataclasses.field()``。
        在运行时，此装饰器将其参数记录在被装饰对象的 ``__dataclass_transform__`` 属性中。
        请参阅PEP 681了解详细信息。

?47 override(__arg: ~_F) -> ~_F

override(__arg: ~_F) -> ~_F, module=typing_extensions, line:2098 at site-packages yping_extensions.py

指示一个方法打算覆盖基类中的一个方法。
        用法:
            class Base:
                def method(self) -> None: ...
                    pass
            class Child(Base):
                @override
                def method(self) -> None:
                    super().method()
        当这个装饰器应用于一个方法时，类型检查器将验证它是否覆盖了基类上同名的方法。
        这有助于防止在没有对子类进行等效更改的情况下更改基类时可能发生的错误。
        没有对这些属性进行运行时检查。装饰器将被装饰对象上的 ``__override__`` 属性设置为``True``，以允许运行时自省。
        请参阅PEP 698了解详细信息。

?48 deprecated(__msg: str, *, category: Union[Type[Warning], NoneType] = <class ‘DeprecationWarning’>, stacklevel: int = 1) -> Callable[[~_T], ~_T]

deprecated(__msg: str, *, category: Union[Type[Warning], NoneType] = <class ‘DeprecationWarning’>, stacklevel: int = 1) -> Callable[[~_T], ~_T], module=typing_extensions, line:2139 at site-packages yping_extensions.py

表明类、函数或重载已弃用。
用法:
            @deprecated("Use B instead")
            class A:
                pass
            @deprecated("Use g instead")
            def f():
                pass
            @overload
            @deprecated("int support is deprecated")
            def g(x: int) -> int: ...
            @overload
            def g(x: str) -> int: ...
        当此装饰器应用于对象时，类型检查器将生成关于已弃用对象使用情况的诊断。
        没有发出运行时警告。装饰器设置了 ``__deprecated__`` 属性设置为传递给装饰器的弃用消息。
        如果应用于重载，该装饰器必须位于 ``@overload`` 装饰器之后，才能使该属性存在于由``get_overloads()``返回的重载中。
        参见PEP 702了解详细信息。

?49 _caller()

_caller(), module=typing_extensions, line:2232 at site-packages yping_extensions.py

?50 _make_nmtuple(name, types, module, defaults=())

_make_nmtuple(name, types, module, defaults=()), module=typing_extensions, line:2238 at site-packages yping_extensions.py

?51 NamedTuple(__typename, __fields=None, **kwargs)

NamedTuple(__typename, __fields=None, **kwargs), module=typing_extensions, line:2291 at site-packages yping_extensions.py

namedtuple的类型化版本。
    Python版本>= 3.6中的用法:
        class Employee(NamedTuple):
            name: str
            id: int
    这相当于:
        Employee = collections.namedtuple('Employee', ['name', 'id'])
    结果类具有额外的 __annotations__ 和 _field_types 属性，给出了将字段名称映射到类型的有序字典。
    应该优先使用注释，而保留字段类型以保持PEP 526之前的兼容性。
    (字段名在fields属性中，它是namedtuple API的一部分。)
        Employee = NamedTuple('Employee', name=str, id=int)
    在Python版本<= 3.5中使用:
        Employee = NamedTuple('Employee', [('name', str), ('id', int)])

?52 _namedtuple_mro_entries(bases)

_namedtuple_mro_entries(bases), module=typing_extensions, line:2308 at site-packages yping_extensions.py

?类

?53 type

type, type, module=builtins

type(object_or_name, bases, dict)
type(object) -> 对象的类型
type(name, bases, dict) -> a new type

method

1 mro()

kind=method class=type objtype=method_descriptor

返回类型的方法解析顺序。

?54 typing_extensions._AnyMeta

_AnyMeta, typing_extensions._AnyMeta, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?55 typing_extensions.An

Any, typing_extensions.An, module=typing_extensions, line:-1 at site-packages yping_extensions.py

指示非约束类型的特殊类型。
    —Any与所有类型兼容。
    -任何被认为拥有所有方法的人。
    -所有值都假定为Any的实例。
    请注意，从静态类型检查器的角度来看，上述所有语句都是正确的。在运行时，Any不应与实例检查一起使用。

?56 typing_extensions._FinalForm

_FinalForm, typing_extensions._FinalForm, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?57 typing_extensions._LiteralForm

_LiteralForm, typing_extensions._LiteralForm, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?58 str

str, str, module=builtins

?59 typing_extensions._ProtocolMeta

_ProtocolMeta, typing_extensions._ProtocolMeta, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?60 typing_extensions.Protocol

Protocol, typing_extensions.Protocol, module=typing_extensions, line:-1 at site-packages yping_extensions.py

协议类的基类。
    协议类定义为:
            class Proto(Protocol):
                def meth(self) -> int:
                    ...
        此类类主要用于识别结构子类型(静态duck-typing)的静态类型检查器，例如:
            class C:
                def meth(self) -> int:
                    return 0
            def func(x: Proto) -> int:
                return x.meth()
            func(C())  # 通过静态类型检查
        请参阅PEP 544了解详细信息。
        装饰的协议类 @typing_extensions.runtime作为一种简单的运行时协议，只检查给定属性的存在，忽略它们的类型签名。
        协议类可以是泛型的，它们定义为:
            class GenProto(Protocol[T]):
                def meth(self) -> T:
                    ...

?61 typing_extensions.SupportsIndex

SupportsIndex, typing_extensions.SupportsIndex, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?62 typing_extensions._TypedDictMeta

_TypedDictMeta, typing_extensions._TypedDictMeta, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?63 typing_extensions.TypedDict

TypedDict, typing_extensions.TypedDict, module=typing_extensions, line:-1 at site-packages yping_extensions.py

一个简单类型的名称空间。
    在运行时，它相当于一个普通的字典。
    TypedDict创建了一个字典类型，该类型期望它的所有实例都有一组键，每个键都与一个一致类型的值相关联。
    在运行时不检查此期望，而仅由类型检查器强制执行。
    用法：
            class Point2D(TypedDict):
                x: int
                y: int
                label: str
            a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
            b: Point2D = {'z': 3, 'label': 'bad'}           # 类型检查失败
            assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')
        类型信息可以通过 Point2D.__annotations__ 词典，Point2D.__required_keys__，Point2D.__optional_keys__ 访问。
        TypedDict支持两种额外的等价形式:
            Point2D = TypedDict('Point2D', x=int, y=int, label=str)
            Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
        类语法仅在Python 3.6+中支持，而其他两种语法形式适用于Python 2.7和3.2+。

?64 typing_extensions._AnnotatedAlias

_AnnotatedAlias, typing_extensions._AnnotatedAlias, module=typing_extensions, line:-1 at site-packages yping_extensions.py

带注释类型的运行时表示。
    其核心是 'Annotated[t, dec1, dec2, ...]' 是带有额外注释的类型't'的别名。
    别名的行为类似于普通的类型别名，实例化与实例化底层类型相同，将其绑定到类型也是相同的。

method

1 copy_with()

kind=method class=_AnnotatedAlias objtype=function

?65 typing_extensions.Annotated

Annotated, typing_extensions.Annotated, module=typing_extensions, line:-1 at site-packages yping_extensions.py

向类型添加特定于上下文的元数据。
    示例: Annotated[int, runtime_check.Unsigned]向假设的运行时检查模块表明此类型是无符号整型。
    此类型的所有其他消费者都可以忽略此元数据并将此类型视为int。
    Annotated的第一个参数必须是有效类型(并且将位于 __origin__ 字段中)，其余参数作为元组保存在 __extra__ 字段中。
    细节：
        - 使用少于两个参数调用 `Annotated` 是错误的。
        - 嵌套注释被平面化:
            Annotated[Annotated[T, Ann1, Ann2], Ann3] == Annotated[T, Ann1, Ann2, Ann3]
        - 实例化一个注释类型相当于实例化底层类型:
            Annotated[C, Ann1](5) == C(5)
        - Annotated可以用作泛型类型别名:
            Optimized = Annotated[T, runtime.Optimize()]
            Optimized[int] == Annotated[int, runtime.Optimize()]
            OptimizedList = Annotated[List[T], runtime.Optimize()]
            OptimizedList[int] == Annotated[List[int], runtime.Optimize()]

?66 typing._GenericAlias

_GenericAlias, typing._GenericAlias, module=typing, line:599 at typing.py

内部API的中心部分。
    这表示带有类型参数'params'的'origin'类型的泛型版本。
    这些别名有两种:用户定义的和特殊的。特殊的是围绕内置集合和collections.abc中的abc的包装。
    这些必须始终设置“name”。如果'inst'为False，则不能实例化别名，这是通过例如 typing.List 和 typing.Dict 来使用的。

method

1 copy_with(self, params)

kind=method class=_GenericAlias objtype=function line:638 at D…lib yping.py

?67 typing._GenericAlias

_GenericAlias, typing._GenericAlias, module=typing, line:599 at typing.py

内部API的中心部分。
    这表示带有类型参数'params'的'origin'类型的泛型版本。
    这些别名有两种:用户定义的和特殊的。特殊的是围绕内置集合和collections.abc中的abc的包装。
    这些必须始终设置“name”。如果'inst'为False，则不能实例化别名，这是通过例如 typing.List 和 typing.Dict 来使用的。

method

1 copy_with(self, params)

kind=method class=_GenericAlias objtype=function line:638 at D…lib yping.py

?68 typing_extensions._TypeAliasForm

_TypeAliasForm, typing_extensions._TypeAliasForm, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?69 typing_extensions._DefaultMixin

_DefaultMixin, typing_extensions._DefaultMixin, module=typing_extensions, line:1158 at site-packages yping_extensions.py

Mixin for TypeVarLike默认值。

?70 typing.TypeVar

TypeVar, typing.TypeVar, module=typing, line:488 at typing.py

类型变量

?71 typing_extensions._Immutable

_Immutable, typing_extensions._Immutable, module=typing_extensions, line:-1 at site-packages yping_extensions.py

Mixin表示该对象不应该被复制。

?72 typing_extensions.ParamSpecArgs

ParamSpecArgs, typing_extensions.ParamSpecArgs, module=typing_extensions, line:-1 at site-packages yping_extensions.py

ParamSpec对象的参数。
    给定一个ParamSpec对象P, P.args 是ParamSpecArgs的一个实例。
    ParamSpecArgs对象有一个指向它们的ParamSpec:
        P.args.__origin__ is P
    此类型用于运行时自省，对静态类型检查器没有特殊意义。

?73 typing_extensions.ParamSpecKwargs

ParamSpecKwargs, typing_extensions.ParamSpecKwargs, module=typing_extensions, line:-1 at site-packages yping_extensions.py

ParamSpec对象的参数。
    给定一个ParamSpec对象P, P.kwargs是ParamSpecKwargs的一个实例。
    ParamSpecKwargs对象有一个指向它们的ParamSpec:
            P.kwargs.__origin__ is P
    此类型用于运行时自省，对静态类型检查器没有特殊意义。

?74 typing_extensions.ParamSpec

ParamSpec, typing_extensions.ParamSpec, module=typing_extensions, line:-1 at site-packages yping_extensions.py

参数规格变量。
    用法:
           P = ParamSpec('P')
    参数说明变量的存在主要是为了静态类型检查器的好处。
    它们用于将一个可调用对象的参数类型转发给另一个可调用对象，这是一种在高阶函数和装饰器中常见的模式。
    它们仅在 ``Concatenate`` 或 ``Callable`` 的第一个参数中使用时有效。
    在Python 3.10及更高版本中，它们也在运行时的用户定义泛型中得到支持。
    有关泛型类型的更多信息，请参阅泛型类。注释decorator的示例:
           T = TypeVar('T')
           P = ParamSpec('P')
           def add_logging(f: Callable[P, T]) -> Callable[P, T]:
               '''A type-safe decorator to add logging to a function.'''
               def inner(*args: P.args, **kwargs: P.kwargs) -> T:
                   logging.info(f'{f.__name__} was called')
                   return f(*args, **kwargs)
               return inner
           @add_logging
           def add_two(x: float, y: float) -> float:
               '''Add two numbers together.'''
               return x + y
        用covariant=True或contravant =True定义的参数说明变量可用于声明协变或逆变泛型类型。
        这些关键字参数是有效的，但它们的实际语义尚未确定。参见PEP 612了解详细信息。
        参数说明变量可以自省。例如:
           P.__name__ == 'T'
           P.__bound__ == None
           P.__covariant__ == False
           P.__contravariant__ == False
        注意，只有在全局作用域中定义的参数说明变量才能被pickle。

property

1 args=<property object at 0x000001F2826E9638> kind:property type:property class:<class ‘typing_extensions.ParamSpec’>
2 kwargs=<property object at 0x000001F2826E9688> kind:property type:property class:<class ‘typing_extensions.ParamSpec’>

?75 typing_extensions._ConcatenateGenericAlias

_ConcatenateGenericAlias, typing_extensions._ConcatenateGenericAlias, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?76 typing_extensions._ConcatenateForm

_ConcatenateForm, typing_extensions._ConcatenateForm, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?77 typing_extensions._TypeGuardForm

_TypeGuardForm, typing_extensions._TypeGuardForm, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?78 typing_extensions._SpecialForm

_SpecialForm, typing_extensions._SpecialForm, module=typing_extensions, line:1591 at site-packages yping_extensions.py

    <member '__doc__' of '_SpecialForm' objects>

?79 typing_extensions._RequiredForm

_RequiredForm, typing_extensions._RequiredForm, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?80 typing_extensions._UnpackAlias

_UnpackAlias, typing_extensions._UnpackAlias, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?81 typing_extensions._UnpackForm

_UnpackForm, typing_extensions._UnpackForm, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?82 typing_extensions.TypeVarTuple

TypeVarTuple, typing_extensions.TypeVarTuple, module=typing_extensions, line:-1 at site-packages yping_extensions.py

类型变量元组。
    用法:
            Ts = TypeVarTuple('Ts')
    就像普通类型变量是单个类型(如``int``)的替身一样，类型变量*tuple*是*元组*类型(如 ``Tuple[int, str]``)的替身。
    类型变量元组可以在“泛型”声明中使用。考虑下面的例子:
            class Array(Generic[*Ts]): ...
    这里的 ``Ts``  类型变量元组的行为类似于``tuple[T1, T2]``，其中 ``T1`` 和 ``T2`` 是类型变量。
    要使用这些类型变量作为 ``Array`` 的类型参数，我们必须使用星号操作符 ``*Ts`` 来 *unpack* 类型变量元组。
    然后，``Array`` 的签名就像我们简单地写了 ``class Array(Generic[T1, T2]): ...`` 一样。
    然而，与 ``Generic[T1, T2]`` 相反，``Generic[*Shape]`` 允许我们使用任意数量的类型参数对类进行参数化。
    类型变量元组可以用在普通的 ``TypeVar`` 可以用的任何地方。这包括如上所示的类定义，以及函数签名和变量注释:
            class Array(Generic[*Ts]):
                def __init__(self, shape: Tuple[*Ts]):
                    self._shape: Tuple[*Ts] = shape
                def get_shape(self) -> Tuple[*Ts]:
                    return self._shape
            shape = (Height(480), Width(640))
            x: Array[Height, Width] = Array(shape)
            y = abs(x)  # Inferred type is Array[Height, Width]
            z = x + x   #        ...    is Array[Height, Width]
            x.get_shape()  #     ...    is tuple[Height, Width]

?83 typing_extensions._NamedTupleMeta

_NamedTupleMeta, typing_extensions._NamedTupleMeta, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?84 typing_extensions.NamedTuple

NamedTuple, typing_extensions.NamedTuple, module=typing_extensions, line:-1 at site-packages yping_extensions.py

?私有或局部

85 _types <module ‘types’ from ‘…lib ypes.py’>
86 _marker <object object at 0x000001F281BD6FF0>
87 _check_generic <function _check_generic at 0x000001F282683678>
88 _should_collect_from_parameters <function _should_collect_from_parameters at 0x000001F2826834C8>
89 _collect_type_vars <function _collect_type_vars at 0x000001F2826E00D8>
90 _AnyMeta <class ‘typing_extensions._AnyMeta’>
91 _FinalForm <class ‘typing_extensions._FinalForm’>
92 _LiteralForm <class ‘typing_extensions._LiteralForm’>
93 _overload_dummy <function _overload_dummy at 0x000001F28001B558>
94 _overload_registry defaultdict(…, {})
95 _PROTO_WHITELIST [‘Callable’, ‘Awaitable’, ‘Iterable’, ‘Iterator’, ‘AsyncIterable’, ‘AsyncIterator’, ‘Hashable’, ‘Sized’, ‘Container’, 'C…
96 _get_protocol_attrs <function _get_protocol_attrs at 0x000001F2826E0828>
97 _is_callable_members_only <function _is_callable_members_only at 0x000001F2826E08B8>
98 _maybe_adjust_parameters <function _maybe_adjust_parameters at 0x000001F2826E0948>
99 _no_init <function _no_init at 0x000001F2826E09D8>
100 _ProtocolMeta <class ‘typing_extensions._ProtocolMeta’>
101 _check_fails <function _check_fails at 0x000001F2826E0DC8>
102 _dict_new <function _dict_new at 0x000001F2826E0F78>
103 _typeddict_new <function _typeddict_new at 0x000001F2826E5048>
104 _TAKES_MODULE False
105 _TypedDictMeta <class ‘typing_extensions._TypedDictMeta’>
106 _TYPEDDICT_TYPES (<class ‘typing_extensions._TypedDictMeta’>,)
107 _strip_extras <function _strip_extras at 0x000001F2826E5318>
108 _AnnotatedAlias <class ‘typing_extensions._AnnotatedAlias’>
109 _BaseGenericAlias <class ‘typing._GenericAlias’>
110 _typing_GenericAlias <class ‘typing._GenericAlias’>
111 _TypeAliasForm <class ‘typing_extensions._TypeAliasForm’>
112 _DefaultMixin <class ‘typing_extensions._DefaultMixin’>
113 _Immutable <class ‘typing_extensions._Immutable’>
114 _ConcatenateGenericAlias <class ‘typing_extensions._ConcatenateGenericAlias’>
115 _concatenate_getitem <function _concatenate_getitem at 0x000001F2826EB948>
116 _ConcatenateForm <class ‘typing_extensions._ConcatenateForm’>
117 _TypeGuardForm <class ‘typing_extensions._TypeGuardForm’>
118 _SpecialForm <class ‘typing_extensions._SpecialForm’>
119 _RequiredForm <class ‘typing_extensions._RequiredForm’>
120 _UnpackAlias <class ‘typing_extensions._UnpackAlias’>
121 _UnpackForm <class ‘typing_extensions._UnpackForm’>
122 _is_unpack <function _is_unpack at 0x000001F2826ED4C8>
123 _F ~_F
124 _T ~_T
125 _caller <function _caller at 0x000001F280011678>
126 _make_nmtuple <function _make_nmtuple at 0x000001F280011558>
127 _prohibited_namedtuple_fields (‘new’, ‘init’, ‘slots’, ‘getnewargs’, ‘_fields’, ‘_field_defaults’, ‘_field_types’, ‘_make’, ‘_replace’…
128 _special_namedtuple_fields frozenset({‘name’, ‘module’, ‘annotations’})
129 _NamedTupleMeta <class ‘typing_extensions._NamedTupleMeta’>
130 _NamedTuple <class ‘typing_extensions.NamedTuple’>
131 _namedtuple_mro_entries <function _namedtuple_mro_entries at 0x000001F280040AF8>

?剩余

132 doc
133 loader <_frozen_importlib_external.SourceFileLoader object at 0x000001F2FF945408>
134 spec ModuleSpec(name=‘typing_extensions’, loader=<_frozen_importlib_external.SourceFileLoader object at 0x000001F2FF945408>, origin=‘…libsite-packages yping_extensions.py’)
135 _marker <object object at 0x000001F281BD6FF0>
136 NoReturn typing.NoReturn
137 T ~T
138 KT ~KT
139 VT ~VT
140 T_co +T_co
141 T_contra -T_contra
142 ClassVar typing.ClassVar
143 Final typing_extensions.Final
144 Literal typing_extensions.Literal
145 _overload_registry defaultdict(…, {})
146 Type typing.Type
147 Awaitable typing.Awaitable
148 Coroutine typing.Coroutine
149 AsyncIterable typing.AsyncIterable
150 AsyncIterator typing.AsyncIterator
151 Deque typing.Deque
152 ContextManager typing.AbstractContextManager
153 AsyncContextManager typing.AbstractAsyncContextManager
154 DefaultDict typing.DefaultDict
155 OrderedDict typing.OrderedDict
156 Counter typing.Counter
157 ChainMap typing.ChainMap
158 AsyncGenerator typing.AsyncGenerator
159 TypeAlias typing_extensions.TypeAlias
160 Concatenate typing_extensions.Concatenate
161 TypeGuard typing_extensions.TypeGuard
162 LiteralString typing_extensions.LiteralString
163 Self typing_extensions.Self
164 Never typing_extensions.Never
165 Required typing_extensions.Required
166 NotRequired typing_extensions.NotRequired
167 Unpack typing_extensions.Unpack
168 _F ~_F
169 _T ~_T
170 _special_namedtuple_fields frozenset({‘name’, ‘module’, ‘annotations’})

☘️【abc】

abc, fullname=abc, file=abc.py

☘️【collections】

collections, fullname=collections, file=collections_init_.py

☘️【functools】

functools, fullname=functools, file=functools.py

☘️【inspect】

inspect, fullname=inspect, file=inspect.py

☘️【operator】

operator, fullname=operator, file=operator.py

☘️【sys】

sys, fullname=sys, file=

☘️【types】

types, fullname=types, file=types.py

☘️【typing】

typing, fullname=typing, file=typing.py

☘️【warnings】

warnings, fullname=warnings, file=warnings.py