def greet(name: str) -> str:
    return f"hello, {name}"

say = greet              # 赋值给另一个名字
print(say("destiny"))    # hello, destiny

funcs = [greet, str.upper]
print(funcs[0]("world"))  # hello, world

def shout(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result.upper()
    return wrapper

def hello(name):
    return f"hello, {name}"

hello = shout(hello)   # 关键一步：把原函数替换成 wrapper
print(hello("destiny"))  # HELLO, DESTINY

@shout
def hello(name):
    return f"hello, {name}"

# 等价于：def hello(...): ... 然后 hello = shout(hello)

from functools import wraps

def shout(func):
    @wraps(func)                       # ← 关键
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result.upper()
    return wrapper

@shout
def hello(name):
    """打招呼"""
    return f"hello, {name}"

print(hello.__name__)   # hello，而不是 wrapper
print(hello.__doc__)    # 打招呼

from functools import wraps

def repeat(times: int):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            result = None
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(times=3)
def ping():
    print("pong", end=" ")

ping()  # pong pong pong

class CountCalls:
    def __init__(self, func):
        self.func = func
        self.count = 0
        wraps(func)(self)   # 也可以保留元信息

    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"第 {self.count} 次调用")
        return self.func(*args, **kwargs)

@CountCalls
def task():
    print("do work")

task(); task(); task()

from functools import lru_cache, cached_property, wraps
from dataclasses import dataclass

@lru_cache(maxsize=128)            # 自动缓存返回值，按参数缓存
def fib(n: int) -> int:
    return n if n < 2 else fib(n-1) + fib(n-2)

@dataclass(slots=True)             # 自动生成 __init__/__repr__/__eq__
class Point:
    x: float
    y: float

class Image:
    @cached_property               # 第一次访问后缓存，后续直接返回
    def size(self) -> tuple[int, int]:
        # 假设这里读文件、做计算
        return (1920, 1080)

@staticmethod / @classmethod        # 方法类型控制
@property                          # getter

from functools import wraps
from time import monotonic
from typing import Callable, Any

def cached(ttl: float = 60.0):
    """带过期时间的缓存装饰器，单位秒。"""
    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
        store: dict[tuple, tuple[float, Any]] = {}
        hits = misses = 0

        @wraps(func)
        def wrapper(*args, **kwargs):
            nonlocal hits, misses
            key = (args, tuple(sorted(kwargs.items())))
            now = monotonic()

            if key in store:
                ts, val = store[key]
                if now - ts < ttl:
                    hits += 1
                    return val
                else:
                    del store[key]

            misses += 1
            val = func(*args, **kwargs)
            store[key] = (now, val)
            return val

        wrapper.cache_info = lambda: {"hits": hits, "misses": misses, "size": len(store)}  # type: ignore[attr-defined]
        return wrapper
    return decorator

@cached(ttl=0.5)
def slow_square(x: int) -> int:
    print(f"  computing {x}...")
    return x * x

print(slow_square(4))   # computing 4... → 16
print(slow_square(4))   # 直接返回 16（命中缓存）
print(slow_square.cache_info())  # {'hits': 1, 'misses': 1, 'size': 1}

def describe(point: tuple[int, int]) -> str:
    match point:
        case (0, 0):
            return "原点"
        case (x, 0):
            return f"在 x 轴上，x={x}"
        case (0, y):
            return f"在 y 轴上，y={y}"
        case (x, y):
            return f"普通点 ({x}, {y})"

print(describe((3, 0)))  # 在 x 轴上，x=3

import re

if (m := re.search(r"\d+", "订单号: 9527")) is not None:
    print(f"提取到数字：{m.group()}")  # 提取到数字：9527

def find_user(user_id: int) -> dict | None:
    if user_id == 1:
        return {"name": "destiny"}
    return None

# 等价于 Optional[dict] / Union[dict, None]

from dataclasses import dataclass

@dataclass(slots=True)
class Point:
    x: float
    y: float

p = Point(1.0, 2.0)
# p.z = 3.0  # AttributeError，防止手滑加错字段

user = {"name": "destiny", "level": 5}
width = 12

# 嵌套 f-string
print(f"{f"{user['name']:^{width}}"}")  #    destiny

# 调试语法 = 直接打印变量名和值
print(f"{user=}")  # user={'name': 'destiny', 'level': 5}

import asyncio

async def fetch(url: str) -> str:
    await asyncio.sleep(0.1)
    return f"data from {url}"

async def main() -> None:
    async with asyncio.TaskGroup() as tg:
        t1 = tg.create_task(fetch("api/a"))
        t2 = tg.create_task(fetch("api/b"))
    print(t1.result(), t2.result())

asyncio.run(main())

def risky(x: int) -> None:
    if x < 0:
        raise ValueError(f"负数：{x}")

try:
    risky(-1)
    risky(-2)
except* ValueError as eg:
    for e in eg.exceptions:
        print("处理：", e)

type Vector = list[float]
type Matrix[T] = list[list[T]]

def norm(v: Vector) -> float:
    return sum(x * x for x in v) ** 0.5

# 泛型别名
m: Matrix[int] = [[1, 2], [3, 4]]

from pathlib import Path

root = Path(".")
for dirpath, dirnames, filenames in root.walk():
    if "__pycache__" in dirnames:
        dirnames.remove("__pycache__")  # 剪枝，不再深入
    for name in filenames:
        if name.endswith(".py"):
            print(dirpath / name)

from typing import Self, override

class Shape:
    def scale(self, factor: float) -> Self:
        return self  # 子类调用会自动返回子类类型

class Circle(Shape):
    def __init__(self, r: float) -> None:
        self.r = r

    @override
    def scale(self, factor: float) -> Self:
        self.r *= factor
        return self

from dataclasses import dataclass, field

@dataclass(slots=True)
class Book:
    title: str
    author: str
    tags: list[str] = field(default_factory=list)

    def summary(self) -> str:
        return f"《{self.title}》—— {self.author}"

shelf = [Book("流畅的 Python", "Luciano Ramalho"), Book("Python Cookbook", "David Beazley")]
for book in shelf:
    print(book.summary())