from typing import NoReturn

def stop() -> NoReturn:
    raise RuntimeError('no way')

import sys
from typing import NoReturn

  def f(x: int) -> NoReturn:  # Error, f(0) implicitly returns None
      if x != 0:
          sys.exit(1)

# continue from first example
def g(x: int) -> int:
    if x > 0:
        return x
    stop()
    return 'whatever works'  # Error might be not reported by some checkers
                             # that ignore errors in unreachable blocks

from typing import List, NoReturn

# All of the following are errors
def bad1(x: NoReturn) -> int:
    ...
bad2 = None  # type: NoReturn
def bad3() -> List[NoReturn]:
    ...

类对象的类型（The type of class objects）

有时会涉及到类对象，特别是从某个类继承而来的类对象。类对象可被写为 Type[C]，这里的 C 是一个类。为了清楚起见，C 在用作类型注解时指的是类 C 的实例，Type[C] 指的是 C 的子类。这类似于对象和类型之间的区别。

例如，假设有以下类：

class User: ...  # Abstract base for User classes
class BasicUser(User): ...
class ProUser(User): ...
class TeamUser(User): ...

假设有一个函数，如果传一个类对象进去，就会创建出该类的一个实例：

def new_user(user_class):
    user = user_class()
    # (Here we could write the user object to a database)
    return user

若不用 Type[]，能给 new_user() 加上的最好的类型注解将会是：

def new_user(user_class: type) -> User:
    ...

但采用 Type[] 和带上界的类型变量，就可以注解得更好：

U = TypeVar('U', bound=User)
def new_user(user_class: Type[U]) -> U:
    ...

现在，若用 User 的某个子类做参数调用 new_user()，类型检查程序将能推断出结果的正确类型：

joe = new_user(BasicUser)  # Inferred type is BasicUser

Type[C] 对应的值必须是类型为 C 的子类型的类对象实体，而不是某个具体的类型。换句话说，在上述示例中，new_user(Union[BasicUser, ProUser]) 之类的调用将被类型检查程序拒绝（并且会运行失败，因为 union 无法实例化）。

请注意，用类的 union 作 Type[] 的参数是合法的，如下所示：

def new_non_team_user(user_class: Type[Union[BasicUser, ProUser]]):
    user = new_user(user_class)
    ...

但是，在运行时上例中传入的实际参数仍必须是具体的类对象：

new_non_team_user(ProUser)  # OK
new_non_team_user(TeamUser)  # Disallowed by type checker

Type[Any] 也是支持的，含义参见下文。

为类方法的第一个参数标注类型注解时，允许采用 Type[T]，这里的 T 是一个类型变量，具体请参阅相关章节。

任何其他的结构（如 Tuple 或 Callable）均不能用作 Type 的参数。

此特性存在一些问题：比如若 new_user() 要调用 user_class()，就意味着 User 的所有子类都必须在其构造函数的签名中支持该调用。不过并不是只有 Type[] 才会如此，类方法也有类似的问题。类型检查程序应该将违反这种假定的行为标记出来，但与所标明基类（如上例中的 User）的构造函数签名相符的构造函数，应该默认是允许调用的。如果程序中包含了比较复杂的或可扩展的类体系，也可以采用工厂类方法来作处理。本 PEP 的未来修订版本可能会引入更好的方法来解决这些问题。

当 Type 带有参数时，仅要求有一个参数。不带中括号的普通类型等效于 Type[Any]，也即等效于 type（Python 元类体系中的根类）。这种等效性也促成了其名称 Type，而没有采用 Class 或 SubType 这种名称，在讨论此特性时这些名称都被提出过，这有点类似 List 和 list 的关系。

关于 Type[Any]（或 Type、Type）的行为，如果要访问该类型变量的属性，则只提供了 type 定义的属性和方法（如 __repr__() 和 __mro__）。此类变量可以用任意参数进行调用，返回类型则为 Any。

Type 的参数是协变的，因为 Type[Derived] 是 Type[Base] 的子类型：

def new_pro_user(pro_user_class: Type[ProUser]):
    user = new_user(pro_user_class)  # OK
    ...