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]