闭包与装饰器：给函数增加边界明确的复用能力

from collections.abc import Callable


def make_counter() -> Callable[[], int]:
    count = 0

    def increase() -> int:
        nonlocal count
        count += 1
        return count

    return increase


counter = make_counter()
print(counter(), counter())

from collections.abc import Callable
from functools import wraps
from time import sleep
from typing import ParamSpec, TypeVar

P = ParamSpec("P")
R = TypeVar("R")


def retry(attempts: int, delay: float = 0.0) -> Callable[[Callable[P, R]], Callable[P, R]]:
    if attempts < 1:
        raise ValueError("attempts 必须大于 0")

    def decorate(func: Callable[P, R]) -> Callable[P, R]:
        @wraps(func)
        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
            for current in range(1, attempts + 1):
                try:
                    return func(*args, **kwargs)
                except TimeoutError:
                    if current == attempts:
                        raise
                    print(f"第 {current} 次超时，准备重试")
                    sleep(delay)
            raise RuntimeError("不可达分支")

        return wrapper

    return decorate


failures = 0


@retry(attempts=3, delay=0.1)
def fetch() -> str:
    global failures
    failures += 1
    if failures < 3:
        raise TimeoutError("temporary timeout")
    return "ok"


print(fetch())
print(fetch.__name__)

def mark(name):
    def decorate(func):
        def wrapper():
            print("enter", name)
            result = func()
            print("leave", name)
            return result
        return wrapper
    return decorate


@mark("outer")
@mark("inner")
def work():
    print("work")


work()