Python typing模块

def 函数名(参数: 数据类型) -> 返回值类型:
    pass

变量名: 数据类型 = 值

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# @author: A.L.Kun
# @file : test.py
# @time : 2022/5/13 16:54
from typing import Sequence

ConnectionOptions = dict[str, int]  # 表示字典中的键为字符串类型，值为整型
Address = tuple[str, int, ...]  # 表示元组的第一个数据为字符串，第二个数据为整型，里面只能存储两个数据，有省略号表示里面可以添加n个整型数据
Server = tuple[Address, ConnectionOptions]


def broadcast_message(message: str,
                      servers: Sequence[Server]  # 表示一个序列对象里面存储了[tuple[tuple[str, int], dict[str, int]]]
                      ) -> None:  # 返回值为空
    ...

broadcast_message("a", [(("a", 1, 2), {"a": 1})])

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# @author: A.L.Kun
# @file : test.py
# @time : 2022/5/13 16:54
from typing import NewType

UserId = NewType('UserId', int)  # 其不会创建一个新的类或引入其他内存，只是做一个约束作用


def name_by_id(user_id: UserId) -> str:
    ...


name_by_id(42)  # Fails type check
name_by_id(UserId(42))  # OK

num = UserId(5) + 1  # type: int，可以进行对应数据类型的操作

Callable[[Arg1Type, Arg2Type], ReturnType]

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# @author: A.L.Kun
# @file : test.py
# @time : 2022/5/13 16:54
from collections.abc import Callable  # 注意要使用Concatenate和ParamSpec就必须使用这个模块里面的Callable
from threading import Lock
from typing import TypeVar
from pip._vendor.typing_extensions import Concatenate, ParamSpec  # 导入typing的扩展

P = ParamSpec('P')  # 里面有args和kwargs参数
R = TypeVar('R')  # 自定义数据类型

my_lock = Lock()  # 创建一个互斥锁


def with_lock(f: Callable[Concatenate[Lock, P], R]) -> Callable[P, R]:
    '''一个提供互斥锁，使得线程安全的装饰器'''
    def inner(*args: P.args, **kwargs: P.kwargs) -> R:
        return f(my_lock, *args, **kwargs)
    return inner


@with_lock
def sum_threadsafe(lock: Lock, numbers: list[float]) -> float:
    '''Add a list of numbers together in a thread-safe manner.'''
    with lock:
        return sum(numbers)


# We don't need to pass in the lock ourselves thanks to the decorator.
print(sum_threadsafe([1.1, 2.2, 3.3]))

from typing import (
    List,  # list的泛型版本。用于注释返回类型。要注释参数，最好使用抽象集合类型，如Sequence或Iterable
    Set,  # set的泛型版本
    Dict  # dict 的泛型版本。对标注返回类型比较有用。如果要标注参数的话，使用如 Mapping 的抽象容器类型是更好的选择
    )

from typing import (
    Mapping,  # 要注释函数参数中的Key-Value类型时，推荐使用的抽象集合类型
    Sequence,  # 要注释函数参数中的序列例如列表类型时，推荐使用的抽象集合类型
    Iterable  # 要注释函数参数中的迭代类型时，推荐使用的抽象集合类型
    )

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# @author: A.L.Kun
# @file : test.py
# @time : 2022/5/13 16:54
from typing import (
    Sequence,
    TypeVar  # 限制多个变量为同一个数据类型
)

T = TypeVar('T')  # Can be anything 
A = TypeVar('A', str, bytes)  # Must be str or bytes 

def repeat(x: T, n: int) -> Sequence[T]:
    """Return a list containing n references to x."""
    return [x] * n

def longest(x: A, y: A) -> A:
    """Return the longest of two strings."""
    return x if len(x) >= len(y) else y

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# @author: A.L.Kun
# @file : test.py
# @time : 2022/5/13 16:54
from typing import (
    Any,
    NoReturn,  # 表示函数没有返回值
)

def test(s: Any) -> NoReturn:
    s.item()  # 不会检测s里面是否有item()属性

def test_(s: object) -> NoReturn:
    s.item()  # 会检测s里面是否有item属性

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# @author: A.L.Kun
# @file : test.py
# @time : 2022/5/13 16:54
from typing import (
    Type,
)


class User:
    ...


class BasicUser(User):
    ...

# Accepts User, BasicUser, ...

def make_new_user(user_class: Type[User]) -> User:
    return user_class()


print(make_new_user(User))

Union[int] == int  # The constructor actually returns int

Union[int, str, int] == Union[int, str]

Union[int, str] == Union[str, int]