Python 类型检查 ---- typing 模块

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Proto(Protocol):
    def meth(self) -> int:
        ...

class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from typing import TypeGuard

# 老写法
def is_str_list(val: List[object]) -> bool:
    """Determines whether all objects in the list are strings"""
    return all(isinstance(x, str) for x in val)

# 新写法
def is_str_list(val: List[object]) -> TypeGuard[List[str]]:
    """Determines whether all objects in the list are strings"""
    return all(isinstance(x, str) for x in val)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class Person(TypedDict):
    name: str
    age: int

def is_person(val: dict) -> "TypeGuard[Person]":
    try:
        return isinstance(val["name"], str) and isinstance(val["age"], int)
    except KeyError:
        return False

def print_age(val: dict):
    if is_person(val):
        print(f"Age: {val['age']}")
    else:
        print("Not a person!")

1
2
3

from typing import TypeAlias

Factors: TypeAlias = list[int]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

from collections.abc import Callable
from typing import TypeVar, ParamSpec
import logging

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

P = ParamSpec('P')
R = TypeVar('R')

my_lock = Lock()

def with_lock(f: Callable[Concatenate[Lock, P], R]) -> Callable[P, R]:
    '''A type-safe decorator which provides a lock.'''
    def inner(*args: P.args, **kwargs: P.kwargs) -> R:
        # Provide the lock as the first argument.
        return f(my_lock, *args, **kwargs)
    return inner

1

a = int

1
2
3
4
5
6
7
8
9

def validate_simple(data: Any) -> Literal[True]:  # always returns True
    ...

MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
    ...

open_helper('/some/path', 'r')  # Passes type check
open_helper('/other/path', 'typo')  # Error in type checker

1
2
3
4
5
6
7

class Starship:
    stats: ClassVar[dict[str, int]] = {} # class variable 标注为类变量
    damage: int = 10                     # instance variable 没有标注，是实例标量

enterprise_d = Starship(3000)
enterprise_d.stats = {}    # 禁止访问Error, setting class variable on instance
Starship.stats = {}        # This is OK

1
2
3
4
5
6
7
8

MAX_SIZE: Final = 9000 # 全局常量
MAX_SIZE += 1  # Error reported by type checker

class Connection:
    TIMEOUT: Final[int] = 10    # 类常量

class FastConnector(Connection):
    TIMEOUT = 1  # Error reported by type checker

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Base:
    @final                      # 禁止重写
    def done(self) -> None:
        ...
class Sub(Base):
    def done(self) -> None:     # Error reported by type checker
        ...

@final                          # 禁止被继承
class Leaf:
    ...
class Other(Leaf):              # Error reported by type checker
    ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

T1 = Annotated[int, ValueRange(-10, 5)]
T2 = Annotated[T1, ValueRange(-20, 3)]

Annotated[int, ValueRange(3, 10), ctype("char")] # 多个额外信息


# 嵌套模式
Annotated[Annotated[int, ValueRange(3, 10)], ctype("char")] == Annotated[
    int, ValueRange(3, 10), ctype("char")
]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Point2D(TypedDict):       # 类方式声明
    x: int
    y: int
    label: str

a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check

assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')

Point2D = TypedDict('Point2D', {'in': int, 'x-y': int}) # 函数方式声明

1
2

name: str = 3                   # type: ignore
name: str = 3                   # pyright: ignore