class Foo:
    def __new__(cls, *args, **kwargs):
        # 真正的"构造函数"：负责把内存造出来
        print("__new__ 分配实例")
        instance = super().__new__(cls)
        return instance           # 关键：必须返回实例，否则 __init__ 不会被调用

    def __init__(self, value):
        print("__init__ 初始化")
        self.value = value        # 只赋值，不要 return

    def __del__(self):
        print("__del__ 析构")      # 不可靠：调用时机不确定

f = Foo(10)
# 输出: __new__ 分配实例
#       __init__ 初始化

# 不可变类型（int/str/tuple）和需要"缓存/池化"的对象必须重写 __new__
class PositiveInt(int):
    def __new__(cls, value):
        # int 是不可变的，必须在创建时修正值，__init__ 无法修改已创建好的 int
        return super().__new__(cls, abs(value))

PositiveInt(-5)   # 5 —— 负数被转成绝对值

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        # 首选：能直接看到如何重建这个对象
        return f"Point(x={self.x}, y={self.y})"

    def __str__(self):
        # 给用户：简洁可读
        return f"({self.x}, {self.y})"

    def __format__(self, spec):
        # 支持 f"{p:.2f}" 之类
        if spec == ".2f":
            return f"({self.x:.2f}, {self.y:.2f})"
        return str(self)

p = Point(3.14159, 2.71828)
print(repr(p))        # Point(x=3.14159, y=2.71828)
print(str(p))         # (3.14159, 2.71828)
print(f"{p:.2f}")     # (3.14, 2.72)

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __add__(self, other):           # self + other
        return Vector(self.x + other.x, self.y + other.y)

    def __radd__(self, other):          # other + self（当 other 没有 __add__ 时反射调用）
        return Vector(other + self.x, other + self.y)

    def __iadd__(self, other):          # self += other（原地，应返回 self）
        self.x += other.x
        self.y += other.y
        return self

    def __eq__(self, other):            # ==
        return isinstance(other, Vector) and self.x == other.x and self.y == other.y

    def __hash__(self):                 # 与 __eq__ 配套
        return hash((self.x, self.y))

    def __lt__(self, other):            # <（排序用）
        return (self.x, self.y) < (other.x, other.y)

class MyList:
    def __init__(self, data):
        self._data = list(data)

    def __len__(self):                # len(obj)
        return len(self._data)

    def __getitem__(self, idx):       # obj[idx]，支持切片（idx 可能是 slice）
        return self._data[idx]

    def __setitem__(self, idx, val):  # obj[idx] = val
        self._data[idx] = val

    def __delitem__(self, idx):       # del obj[idx]
        del self._data[idx]

    def __contains__(self, val):      # val in obj
        return val in self._data

    def __iter__(self):               # for x in obj
        return iter(self._data)

    def __reversed__(self):           # reversed(obj)
        return reversed(self._data)

class CallableObj:
    def __call__(self, *args, **kwargs):
        print("被当作函数调用:", args)
        return sum(args)

f = CallableObj()
f(1, 2, 3)   # 被当作函数调用: (1, 2, 3) → 6

class Proxy:
    def __init__(self, target):
        self._target = target

    def __getattr__(self, name):
        # 只有找不到 name 时才走到这里（_target 自身属性不会触发）
        return getattr(self._target, name)

class Dangerous:
    def __getattribute__(self, name):
        # 每次访问属性都触发，包括读取 self._x 也会再触发 → 无限递归
        # 正确写法：
        return super().__getattribute__(name)

    def __setattr__(self, name, value):
        # 错误写法：self._data = value 又会触发 __setattr__ → 递归
        # 正确写法：
        super().__setattr__(name, value)

class Validated:
    def __init__(self, validator):
        self.validator = validator

    def __set_name__(self, owner, name):
        # Python 3.6+：描述符被赋给类属性时，自动得知自己的名字
        self.name = f"_{name}"

    def __get__(self, inst, owner):
        # inst 为实例；通过类访问时 inst 为 None
        if inst is None:
            return self
        return getattr(inst, self.name, None)

    def __set__(self, inst, value):
        if not self.validator(value):
            raise ValueError(f"校验失败: {self.name}")
        setattr(inst, self.name, value)

class User:
    name = Validated(str.isalpha)                 # 仅字母
    age  = Validated(lambda x: isinstance(x, int) and 0 < x < 150)

u = User()
u.name = "Alice"
u.age = 30
# u.age = -1      # ValueError: 校验失败
# u.name = "Bob1" # ValueError: 校验失败

class cached_property:
    def __init__(self, func):
        self.func = func
        self.name = func.__name__

    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, inst, owner):
        if inst is None:
            return self
        # 算一次后直接写进实例字典：下次查找步骤 2 命中，不再走描述符
        value = self.func(inst)
        inst.__dict__[self.name] = value
        return value

class Report:
    def __init__(self, data):
        self.data = data

    @cached_property
    def summary(self):
        print("计算一次...")
        return sum(self.data)

r = Report([1,2,3])
r.summary   # 计算一次... → 6
r.summary   # 直接读缓存 → 6

class Point:
    __slots__ = ('x', 'y')          # 只允许这两个属性
    def __init__(self, x, y):
        self.x, self.y = x, y

p = Point(1, 2)
# p.z = 3   # AttributeError: 'Point' object has no attribute 'z'

import sys, time, tracemalloc

class WithDict:
    def __init__(self, x, y): self.x, self.y = x, y

class WithSlots:
    __slots__ = ('x', 'y')
    def __init__(self, x, y): self.x, self.y = x, y

def bench(cls, n=1_000_000):
    tracemalloc.start()
    objs = [cls(i, i) for i in range(n)]
    cur, peak = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    return peak / 1024 / 1024

print(f"普通类: {bench(WithDict):.1f} MB")     # ~150 MB
print(f"slots:  {bench(WithSlots):.1f} MB")    # ~55 MB（约省 60%）

class Node:
    __slots__ = ('value', '__weakref__')   # 若要用 weakref.ref，需显式加入 __weakref__
    def __init__(self, v): self.value = v

def make_multiplier(factor):
    def multiply(x):
        return x * factor     # factor 是自由变量，被闭包捕获
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5), triple(5))   # 10  15
# make_multiplier 已返回，但 factor=2 / 3 仍被 double/triple 持有

print(double.__closure__[0].cell_contents)   # 2

import functools, time

def timer(func):
    @functools.wraps(func)           # 关键：保留原函数的 __name__/__doc__/__module__
    def wrapper(*args, **kwargs):
        t = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} 耗时 {time.perf_counter()-t:.4f}s")
        return result                # 必须原样返回原函数的返回值
    return wrapper

@timer
def add(a, b):
    """两数相加"""
    return a + b
# 等价于: add = timer(add)

add(3, 4)          # 打印耗时并返回 7
print(add.__name__)  # "add"（因为 @wraps）；否则会是 "wrapper"

import functools, time

def retry(max_attempts=3, delay=1):
    def decorator(func):                     # 第二层：真正的装饰器
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception:
                    if i == max_attempts - 1:
                        raise
                    time.sleep(delay)
        return wrapper
    return decorator                          # 第一层返回装饰器

@retry(max_attempts=5, delay=0.5)
def fetch_data():
    ...

import functools

class CountCalls:
    def __init__(self, func):
        functools.update_wrapper(self, func)   # 等价于 wraps
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        return self.func(*args, **kwargs)

@CountCalls
def greet(name):
    return f"hi {name}"

greet("A"); greet("B")
print(greet.count)   # 2

@a
@b
@c
def f(): ...
# 等价于: f = a(b(c(f)))   # c 先包，a 最后包；调用时 a→b→c→原函数的层层进入

from functools import partial

def power(base, exp):
    return base ** exp

square = partial(power, exp=2)    # 固定 exp=2
cube   = partial(power, exp=3)
print(square(5), cube(4))         # 25  64

# 实战：给回调预置参数（GUI/异步里非常常见）
on_click = partial(handle_click, button_id=7)

from functools import lru_cache

@lru_cache(maxsize=128)
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

print(fib(100))                 # 毫秒级（否则指数爆炸）
print(fib.cache_info())
# CacheInfo(hits=98, misses=101, maxsize=128, currsize=101)

from functools import singledispatch

@singledispatch
def process(data):
    raise NotImplementedError(f"不支持类型: {type(data)}")

@process.register
def _(data: int):
    return data * 2

@process.register
def _(data: str):
    return data.upper()

@process.register(list)
def _(data):                       # 也可写成 register(list)
    return [process(x) for x in data]

print(process(42))          # 84
print(process("hello"))     # HELLO
print(process([1, "a", 3])) # [2, 'A', 6]

from functools import reduce

product = reduce(lambda a, b: a * b, [1, 2, 3, 4])        # 24
max_val = reduce(lambda a, b: a if a > b else b, [3, 7, 2, 9])  # 9
# 可给初始值（避免空序列报错）：reduce(fn, seq, init)

class Countdown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):        # 返回迭代器（这里就是自己）
        return self

    def __next__(self):        # 每次调用推进一次
        if self.start <= 0:
            raise StopIteration
        self.start -= 1
        return self.start + 1

for n in Countdown(3):
    print(n)                   # 3 2 1

# 底层完全等价：
it = iter(Countdown(3))        # 调用 __iter__
while True:
    try:
        print(next(it))        # 调用 __next__
    except StopIteration:
        break

nums = [1, 2, 3]
it1 = iter(nums); it2 = iter(nums)
next(it1); next(it1)           # 1, 2
next(it2)                      # 1 —— 独立的迭代器，互不影响

import itertools

# --- 无限迭代器（务必配合 islice / 条件终止，否则死循环）---
itertools.count(10, 2)            # 10, 12, 14, 16, ...（从 10 起步长 2）
itertools.cycle("AB")             # A, B, A, B, A, B, ...（无限循环）
itertools.repeat("x", 3)          # x, x, x（有限次，可省略次数成无限）

# --- 组合迭代器 ---
itertools.product("AB", "12")     # 笛卡儿积
# ('A','1'), ('A','2'), ('B','1'), ('B','2')
itertools.permutations("AB", 2)   # 排列（有序）：('A','B'), ('B','A')
itertools.combinations("ABC", 2)  # 组合（无序）：('A','B'), ('A','C'), ('B','C')
itertools.combinations_with_replacement("AB", 2)  # 允许重复：('A','A'),('A','B'),('B','B')

# --- 终止迭代器 ---
list(itertools.accumulate([1, 2, 3, 4]))       # 前缀和: [1, 3, 6, 10]
list(itertools.chain([1, 2], "ab"))            # 拼接: [1, 2, 'a', 'b']
list(itertools.chain.from_iterable([[1,2],[3,4]]))  # 展平: [1, 2, 3, 4]
list(itertools.groupby("aaabbc"))              # 按键分组（注意：键必须已排序！）
# [('a', <g>), ('b', <g>), ('c', <g>)]  每个值是迭代器
list(itertools.islice(range(100), 5, 15))      # 切片（惰性）: [5..14]
list(itertools.zip_longest("AB", "123"))       # 不等长补 None: [('A','1'),('B','2'),(None,'3')]
list(itertools.pairwise([1, 2, 3, 4]))         # 3.10+ 滑动窗口: [(1,2),(2,3),(3,4)]

# 1) 分组前必须先排序（groupby 只连续归组）
data = sorted([("a",1),("b",2),("a",3)])
for key, grp in itertools.groupby(data, key=lambda x: x[0]):
    print(key, list(grp))
# a [('a',1),('a',3)]
# b [('b',2)]

# 2) 滑窗统计（如滚动平均）
def windowed(seq, n):
    iters = itertools.tee(seq, n)              # 复制 n 份迭代器
    for i, it in enumerate(iters):
        next(itertools.islice(it, i, i), None) # 各自偏移 i
    return zip(*iters)
list(windowed([1,2,3,4,5], 3))   # [(1,2,3),(2,3,4),(3,4,5)]

# 3) 生成器表达式（最 Pythonic 的惰性映射+过滤）
squares = (x*x for x in range(10) if x % 2 == 0)   # 不立即计算，省内存

import time

class Timer:
    def __enter__(self):
        self.t = time.perf_counter()
        return self                 # with ... as <val> 接收的就是它的返回值

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"耗时 {time.perf_counter()-self.t:.4f}s")
        return False                # False=不吞异常（向外传播）；True=吞掉异常

with Timer() as t:
    time.sleep(0.5)
# 输出: 耗时 0.50xx s
# sleep 中若抛异常，__exit__ 仍会被调用，且异常继续向外抛出（因返回 False）

from contextlib import contextmanager
import time, os

@contextmanager
def timer():
    t = time.perf_counter()
    yield                          # 这里的 yield 值 = as 接收的值（此处为 None）
    print(f"耗时 {time.perf_counter()-t:.4f}s")

@contextmanager
def temp_env(key, value):          # 临时修改环境变量，退出还原
    old = os.environ.get(key)
    os.environ[key] = value
    try:
        yield
    finally:                       # 即使块内异常，也确保还原
        if old is None:
            os.environ.pop(key, None)
        else:
            os.environ[key] = old

with temp_env("MODE", "prod"):
    print(os.environ["MODE"])      # prod
print(os.environ.get("MODE"))      # 恢复为 None

from contextlib import suppress, closing, ExitStack, nullcontext, redirect_stdout
import os, io, sys

with suppress(FileNotFoundError):   # 优雅忽略指定异常（不必写 try/except/pass）
    os.remove("nonexistent.txt")

with closing(open("f.txt")) as f:   # 确保 .close() 被调用（对象本身不支持 with 时）
    data = f.read()

with ExitStack() as stack:          # 动态管理数量不定的多个上下文
    files = [stack.enter_context(open(f"file{i}.txt")) for i in range(3)]
    # 退出时全部自动关闭，按逆序

with redirect_stdout(io.StringIO()) as buf:  # 临时重定向 stdout（测试很有用）
    print("hello")
captured = buf.getvalue()           # "hello\n"

with nullcontext() as c:            # 占位上下文（根据条件决定是否套真实上下文）
    pass

# 生成器表达式（惰性）
g = (x*x for x in range(10) if x % 2 == 0)
print(next(g), next(g))     # 0 4

# yield from：委托给子生成器（自动转发 yield/值，并收集子生成器 return 的值）
def chain(*iters):
    for it in iters:
        yield from it        # 等价于 for x in it: yield x
print(list(chain([1, 2], (3, 4))))   # [1, 2, 3, 4]

def accumulator():
    total = 0
    while True:
        x = yield total           # 暂停，把 total 交出去，等待 send 注入到 x
        if x is None:
            break
        total += x

acc = accumulator()
next(acc)            # 预激活：必须先 next() 或 send(None) 跑到第一个 yield
print(acc.send(10))  # 10  （total=10）
print(acc.send(5))   # 15  （total=15）
acc.send(None)       # 结束（break → StopIteration）
# acc.close()        # 也可主动关闭，触发 GeneratorExit

def sub():
    yield 1
    return "done"

def outer():
    result = yield from sub()     # result == "done"
    yield result

g = outer()
print(next(g))      # 1
print(next(g))      # "done"

import asyncio, time

async def fetch(i):
    await asyncio.sleep(1)        # 模拟 IO：此处让出控制权，不阻塞线程
    return i * 10

async def main():
    t = time.perf_counter()
    results = await asyncio.gather(fetch(1), fetch(2), fetch(3))
    print(results, f"用时 {time.perf_counter()-t:.2f}s")

asyncio.run(main())   # [10, 20, 30] 用时约 1.00s（而非 3s）

async def fetch(i):
    await asyncio.sleep(1)
    return i

# ❌ 错误：顺序 await → 退化成串行（总耗时 3s）
async def wrong():
    r1 = await fetch(1)
    r2 = await fetch(2)
    r3 = await fetch(3)

# ✅ 正确：先把协程变成 Task 并发调度
async def right():
    t1 = asyncio.create_task(fetch(1))
    t2 = asyncio.create_task(fetch(2))
    t3 = asyncio.create_task(fetch(3))
    results = await asyncio.gather(t1, t2, t3)   # 总耗时约 1s

# gather 也支持直接传协程（内部会自动 create_task）
results = await asyncio.gather(fetch(1), fetch(2), fetch(3))

import asyncio

async def worker(q, wid):
    while True:
        item = await q.get()
        if item is None:
            q.task_done()
            break
        await asyncio.sleep(0.1)         # 模拟处理
        print(f"worker {wid} 处理 {item}")
        q.task_done()

async def producer(q):
    for i in range(5):
        await asyncio.sleep(0.05)
        await q.put(i)
    for _ in range(3):                    # 发 3 个 None 让 3 个 worker 退出
        await q.put(None)

async def main():
    q = asyncio.Queue()
    workers = [asyncio.create_task(worker(q, i)) for i in range(3)]
    await asyncio.gather(producer(q), *workers)

asyncio.run(main())

import asyncio, concurrent.futures, requests

async def main():
    loop = asyncio.get_running_loop()
    # 把阻塞函数丢到线程池执行，await 等待其完成后不阻塞循环
    resp = await loop.run_in_executor(
        None, requests.get, "https://example.com"
    )
    # 或者用 asyncio.to_thread（Python 3.9+，语义相同，更简洁）
    data = await asyncio.to_thread(blocking_io_func, arg)

class A:
    def foo(self):
        print("A.foo")

class B(A):
    def foo(self):
        print("B.foo")
        super().foo()          # 沿 MRO 找 B 之后的下一个 foo（即 A.foo）

class C(A):
    def foo(self):
        print("C.foo")
        super().foo()

class D(B, C):
    def foo(self):
        print("D.foo")
        super().foo()

D().foo()
# 输出:
# D.foo
# B.foo
# C.foo
# A.foo

super()                       # 零参数：Python 3 自动填入当前类和 self
super(B, self)                # 显式：沿 B 在 self 的 MRO 之后的类查找
super(__class__, self)        # 函数内部用（避免硬编码类名）

class Base:
    def __init__(self, x, **kwargs):
        super().__init__(**kwargs)    # 把剩余 kwargs 传给下一个
        self.x = x

class Mixin:
    def __init__(self, y, **kwargs):
        super().__init__(**kwargs)
        self.y = y

class Derived(Base, Mixin):
    def __init__(self, z, **kwargs):
        super().__init__(**kwargs)    # 沿 MRO: Derived→Base→Mixin→object
        self.z = z

d = Derived(x=1, y=2, z=3)            # 三个 __init__ 都被正确调用

# 动态创建类的等价写法：
def say_hi(self):
    return f"hi from {self.name}"

Attrs = type("Attrs", (object,), {"name": "x", "say_hi": say_hi})
obj = Attrs()
print(obj.say_hi())   # hi from x

class LogMeta(type):
    def __new__(mcs, name, bases, ns):
        # __new__ 负责"造出类对象"
        print(f"正在创建类: {name}, 基类: {bases}")
        for k, v in ns.items():
            if callable(v) and not k.startswith("_"):
                ns[k] = debug_wrapper(v)      # 在类创建期改写方法
        return super().__new__(mcs, name, bases, ns)

    def __init__(cls, name, bases, ns):
        # __init__ 负责"初始化已造好的类对象"
        super().__init__(name, bases, ns)
        cls.__author__ = "meta"

class Base(metaclass=LogMeta):
    def foo(self): ...
    def bar(self): ...
# 打印: 正在创建类: Base, 基类: (<class 'object'>,)
# Base.foo / Base.bar 被自动包上日志；其所有子类也会经 LogMeta 创建

class PluginMeta(type):
    registry = {}

    def __new__(mcs, name, bases, ns):
        cls = super().__new__(mcs, name, bases, ns)
        if bases:                       # 跳过基类自身
            PluginMeta.registry[name.lower()] = cls
        return cls

class Plugin(metaclass=PluginMeta):
    pass

class JsonExporter(Plugin): ...
class CsvExporter(Plugin): ...

print(PluginMeta.registry)
# {'jsonexporter': <class ...>, 'csvexporter': <class ...>}

# 1) __init_subclass__（Python 3.6+）：子类创建时回调，无需元类
class Plugin:
    registry = {}
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        Plugin.registry[cls.__name__.lower()] = cls

# 2) __set_name__：描述符自动获知属性名（见第 3 节）

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass                        # 子类必须实现

    @property
    @abstractmethod
    def legs(self):                # 抽象属性
        pass

class Dog(Animal):
    legs = 4
    def speak(self):
        return "woof"

# Animal()        # TypeError: Can't instantiate abstract class Animal with abstract method speak
dog = Dog()       # OK

from collections.abc import Sized

class MyCollection:
    def __len__(self):
        return 42

Sized.register(MyCollection)             # 注册为虚拟子类
print(isinstance(MyCollection(), Sized))  # True（虽未继承 Sized）

from collections import namedtuple, deque, Counter, defaultdict, ChainMap, OrderedDict

# namedtuple：不可变数据记录（比 class 省内存，比 tuple 可读）
Point = namedtuple("Point", ["x", "y"])
p = Point(10, 20)
p.x, p[0]                 # 10, 10
p._asdict()               # {'x': 10, 'y': 20}
p._replace(x=99)          # Point(x=99, y=20) 返回新对象（不可变）
Point._fields             # ('x', 'y')
Point._make([1, 2])       # Point(x=1, y=2)

# deque：高效队列/栈（list 在头部插入是 O(n)，deque 两端都 O(1)）
dq = deque(maxlen=3)      # 定长：满了自动丢最旧
dq.extend([1, 2, 3, 4])   # deque([2, 3, 4])
dq.appendleft(0)
dq.popleft()

# Counter：统计神器
cnt = Counter("abracadabra")
cnt.most_common(2)        # [('a', 5), ('b', 2)]
cnt.elements()            # 展开成迭代器（按计数重复）
cnt.subtract("abra")      # 减法
Counter("aabb") + Counter("bbcc")   # Counter({'b':4,'a':2,'c':2})

# defaultdict：省去 "if key not in dd"
dd = defaultdict(list)
dd["users"].append("Alice")   # 不抛 KeyError
dd["score"]                   # []（默认工厂返回空列表）

# ChainMap：配置层层覆盖（不合并拷贝，查找按顺序）
defaults = {"host": "localhost", "port": 8080}
overrides = {"host": "prod"}
cm = ChainMap(overrides, defaults)
cm["host"]                    # 'prod'（先查 overrides）
cm["port"]                    # 8080（回退 defaults）
cm["host"] = "test"           # 只写入 overrides（第一个映射）

# OrderedDict：需依赖顺序语义时使用（如 LRU 实现）
od = OrderedDict()
od["a"] = 1; od["b"] = 2
od.move_to_end("a")           # 移到末尾

from dataclasses import dataclass, field

@dataclass
class User:
    name: str
    age: int = 0
    tags: list = field(default_factory=list)   # 可变默认值必须用 default_factory
    active: bool = True

    def greet(self):
        return f"Hi, {self.name}"

u = User("Alice", 30)
u2 = User("Bob")
print(u)                  # User(name='Alice', age=30, tags=[], active=True)
print(u == u2)            # False（自动 __eq__）
u.tags.append("vip")      # tags 是独立列表

from dataclasses import dataclass, field, asdict, astuple

@dataclass(frozen=True)          # 不可变：禁止赋值，自动生成 __hash__
class FrozenPoint:
    x: float
    y: float

@dataclass(order=True)           # 自动生成 __lt__/__le__/__gt__/__ge__（按字段顺序比较）
class Rank:
    score: int = field(compare=True)
    name: str = field(compare=False)   # 比较时忽略 name

@dataclass
class Config:
    items: list = field(default_factory=list, repr=False)   # repr 中隐藏
    _cache: dict = field(default_factory=dict, init=False)  # 不在 __init__ 中

    def __post_init__(self):
        # __init__ 之后自动调用：做额外校验/推导
        if not self.items:
            raise ValueError("items 不能为空")

c = Config([1, 2])
asdict(c)                        # {'items': [1, 2], '_cache': {}}  转成普通 dict
astuple(c)                       # ([1, 2], {})

@dataclass(slots=True)           # Python 3.10+：自动加 __slots__，省内存
class Efficient:
    x: int
    y: int

from typing import Optional, Union, List, Dict, Tuple, Callable, Any

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

def get_config(key: str) -> Optional[int]:   # int | None
    return config.get(key)

def process(data: Union[int, str]) -> str:   # int | str
    return str(data)

users: List[str] = ["Alice", "Bob"]          # 注意：仅注解，运行时不检查
scores: Dict[str, int] = {}
handler: Callable[[int, int], str] = lambda a, b: f"{a}+{b}"

from typing import TypeVar, Generic

T = TypeVar("T")
U = TypeVar("U", int, str)        # 约束：只能是 int 或 str
B = TypeVar("B", bound="Sequence") # 上界：必须是 Sequence 的子类

class Stack(Generic[T]):
    def __init__(self):
        self._items: list[T] = []
    def push(self, item: T) -> None:
        self._items.append(item)
    def pop(self) -> T:
        return self._items.pop()

s = Stack[int]()
s.push(1)

from typing import Protocol, TypedDict, Literal, NewType, cast, overload

# Protocol：鸭子类型的静态表达（运行时零开销，不需继承）
class Flyable(Protocol):
    def fly(self) -> None: ...

def takeoff(obj: Flyable) -> None:
    obj.fly()                    # mypy 只要对象有 fly() 就通过

# TypedDict：字典的结构化注解（字段名+类型）
class UserInfo(TypedDict):
    name: str
    age: int

u: UserInfo = {"name": "Alice", "age": 30}

# Literal：精确字面值集合
def set_mode(mode: Literal["read", "write", "append"]) -> None: ...

# NewType：创建"名义上不同"的类型（运行时是同一类型，仅静态区分）
UserId = NewType("UserId", int)
uid = UserId(42)

# @overload：为同一函数声明多种签名（实现里仍是单个函数）
@overload
def to_str(x: int) -> str: ...
@overload
def to_str(x: bytes) -> str: ...
def to_str(x):
    return x.decode() if isinstance(x, bytes) else str(x)

import typing
def f(a: "list[int]", b: int = 0): ...

typing.get_type_hints(f)          # 运行时读取注解（解析前向/字符串引用）
# 输出如 {'a': list[int], 'b': int} —— 注解被保留在 __annotations__

import threading, time

# threading —— IO 密集型（sleep/网络/磁盘等待会释放 GIL，其他线程能跑）
def io_work():
    time.sleep(1)                          # 释放 GIL
threads = [threading.Thread(target=io_work) for _ in range(10)]
[t.start() for t in threads]; [t.join() for t in threads]   # 约 1s

# multiprocessing —— CPU 密集型（多进程绕过 GIL，真并行）
import multiprocessing as mp
def compute():
    return sum(i*i for i in range(10**7))
with mp.Pool() as pool:
    pool.map(compute, range(4))            # 4 进程并行，约 1/4 时间

# asyncio —— 高并发 IO（单线程，协程协作式，开销最低）
import asyncio, aiohttp
async def fetch(url):
    async with aiohttp.ClientSession() as s:
        async with s.get(url) as r:
            return await r.text()

import threading
counter = 0
lock = threading.Lock()

def inc():
    global counter
    for _ in range(100000):
        with lock:                 # 不加锁会出现竞态，结果 < 100000*N
            counter += 1

ts = [threading.Thread(target=inc) for _ in range(4)]
[t.start() for t in ts]; [t.join() for t in ts]
# 有锁时 counter == 400000

import sys, gc
a = [1, 2, 3]
print(sys.getrefcount(a))       # 查看当前引用计数（调用本身会 +1）
print(gc.get_threshold())       # (700, 10, 10) 各代阈值
print(gc.get_stats())           # 各代回收统计
gc.collect()                    # 手动触发全量回收

import weakref
class Node:
    def __init__(self, val):
        self.val = val
        self.parent = None

n = Node(1)
r = weakref.ref(n)              # 弱引用
print(r() is n)                 # True（对象还活着）
del n
print(r() is None)              # True（对象被回收，弱引用失效）

a = [1, 2]; b = [1, 2]
print(a is b)        # False（不同对象）
print(a == b)        # True（值相等）
print(id(a))         # 对象内存地址（进程内唯一标识）

import timeit, cProfile, pstats

# timeit：微基准（多次运行取均值，自动屏蔽噪声）
timeit.timeit("sum(range(1000))", number=10000)

# cProfile：函数级剖析（谁最耗时、调用几次）
cProfile.run("sum(range(10**7))", sort="tottime")
# CLI: python -m cProfile -s tottime your_script.py

# 更细：line_profiler（逐行）、memory_profiler（逐行内存）、py-spy（采样，生产无侵入）

import math

# 1) 局部变量缓存：循环内反复访问的全局/属性函数，先绑定到局部变量
#    避免每次都走 LEGB 查找链
_abs = abs
for x in range(10**6):
    _abs(x)

# 2) 列表推导 vs 循环 append：列表推导在 C 层循环，无每次 append 的属性查找
data = [x*2 for x in range(1000)]          # 快

# 3) " ".join() vs += 拼接：join 预计算总长一次分配；+= 字符串不可变，反复拷贝
parts = ["a", "b", "c"]
result = "".join(parts)                     # 快一个数量级

# 4) set/dict 查找 O(1) ：成员检查用 set 而非 list
haystack = set(big_list)
if item in haystack: ...                    # 比 "item in big_list" 快 N 倍

# 5) @lru_cache：缓存重复/递归计算
from functools import lru_cache
@lru_cache(maxsize=256)
def expensive(n): ...

# 6) __slots__：大量实例时省内存（见第 4 节）

# 7) 用内置与 C 扩展：sum/min/max/sorted、NumPy 向量化远快于手写 Python 循环
total = sum(values)                          # 而非手写循环累加