Python typing使用

from typing importList, Dict, Tuple, Set, Optional, Union, Any

# 变量注解
name: str = "拾光"
age: int = 18
height: float = 1.75
is_student: bool = True
scores: list = [85, 90, 88]
detailed_scores: List[int] = [85, 90, 88] 


defgreet(name: str) -> str:
    returnf"Hello, {name}"

deflog_message(message: str) -> None:
    print(f"[LOG] {message}")

from typing importList, Dict, Tuple, Set, Sequence

names: List[str] = ["Alice", "Bob", "Charlie"]
matrix: List[List[int]] = [[1, 2], [3, 4]]

student: Dict[str, Union[str, int]] = {"name": "拾光", "age": 18}
config: Dict[str, Any] = {"host": "localhost", "port": 8080}

# 元组（固定长度和类型）
point: Tuple[float, float] = (10.5, 20.3)
person: Tuple[str, int, bool] = ("拾光", 18, True)

# 集合
unique_ids: Set[int] = {1, 2, 3, 4, 5}

# 序列（支持list、tuple等）
numbers: Sequence[int] = [1, 2, 3, 4]  # 也可以是 (1, 2, 3, 4)

from typing importOptional, Union

# Optional[T] 等价于 Union[T, None]
deffind_user(user_id: int) -> Optional[str]:
    users = {1: "拾光", 2: "拾光2"}
    return users.get(user_id)

# Union 表示有多个可能的类型
defprocess_data(data: Union[str, int, List[int]]) -> str:
    ifisinstance(data, str):
        returnf"字符串: {data}"
    elifisinstance(data, int):
        returnf"整数: {data}"
    else:
        returnf"列表: {data}"

# 类型别名
UserID = Union[int, str]
Response = Union[Dict[str, Any], List[Any], str, None]

from typing importAny, NoReturn


defaccept_anything(value: Any) -> Any:
    return value


defraise_error(message: str) -> NoReturn:
    raise ValueError(message)

definfinite_loop() -> NoReturn:
    whileTrue:
        print("Running...")

from typing importCallable, TypeVar

# 定义函数类型
MathOperation = Callable[[int, int], int]

defadd(a: int, b: int) -> int:
    return a + b

defmultiply(a: int, b: int) -> int:
    return a * b


defapply_operation(
    a: int, 
    b: int, 
    operation: Callable[[int, int], int]
) -> int:
    return operation(a, b)

result = apply_operation(5, 3, add)  # 返回 8

Processor = Callable[[str], List[str]]
Callback = Callable[[Dict[str, Any]], None]

from typing import TypeVar, Generic, List, Optional


T = TypeVar('T')  # 任意类型
Num = TypeVar('Num', int, float)  # 限制为数字类型


deffirst_item(items: List[T]) -> Optional[T]:
    return items[0] if items elseNone

# 泛型类
classStack(Generic[T]):
    def__init__(self) -> None:
        self.items: List[T] = []
    
    defpush(self, item: T) -> None:
        self.items.append(item)
    
    defpop(self) -> Optional[T]:
        returnself.items.pop() ifself.items elseNone


int_stack = Stack[int]()
int_stack.push(1)
int_stack.push(2)

str_stack = Stack[str]()
str_stack.push("hello")

from typing import TypedDict, List

# Python 3.8+
classUser(TypedDict):
    id: int
    name: str
    email: str
    age: Optional[int]
    tags: List[str]


user: User = {
    "id": 1,
    "name": "拾光",
    "age": 18,
    "tags": ["vip", "active"]
}


defprocess_user(user: User) -> None:
    print(f"Processing {user['name']}")

# 继承TypedDict
classAdminUser(User):
    permissions: List[str]
    is_superuser: bool

from typing import NamedTuple, Optional

classPoint(NamedTuple):
    x: float
    y: float
    z: Optional[float] = None

classPerson(NamedTuple):
    name: str
    age: int
    email: Optional[str] = None


p1 = Point(10.5, 20.3)
p2 = Point(5.0, 15.0, 3.0)
person = Person("拾光", 18, "zhangsan@example.com")

print(p1.x, p1.y)  # 10.5 20.3
print(person.name)  # 拾光

from dataclasses import dataclass, field
from typing import List, Optional, ClassVar
from datetime import datetime

@dataclass
class Product:
    # 实例变量
    id: int
    name: str
    price: float
    tags: List[str] = field(default_factory=list)
    created_at: datetime = field(default_factory=datetime.now)
    description: Optional[str] = None
    
    # 类变量
    currency: ClassVar[str] = "CNY"
    
    def display_price(self) -> str:
        return f"{self.currency}{self.price:.2f}"

# 使用
product = Product(
    id=1,
    name="笔记本电脑",
    price=5999.99,
    tags=["电子", "电脑"]
)