Python 学习总结：核心知识体系回顾

# 1. 一切皆对象：函数也是对象，可以赋值、传参、存进字典
def theme_color(name: str) -> str:
    """返回歌姬的应援色。"""
    return {"初霜": "星空蓝", "南音": "月白"}.get(name, "默认白")

# 2. 函数对象赋给新名字，两个名字指向同一个函数对象
alias = theme_color
print(alias("初霜"))          # 星空蓝
print(type(alias).__name__)   # function

# 3. 变量是引用：b 与 a 指向同一个列表对象
a = ["星屑", "极光"]
b = a
b.append("回声")
print(a)                      # ['星屑', '极光', '回声']

# 1. 歌单与播放量：列表 + 字典的组合使用
playlist: list[str] = ["星屑", "回声", "极光", "回声"]
plays: dict[str, int] = {"星屑": 5200, "回声": 1314, "极光": 999}

# 2. 列表推导式：筛选人气过千的歌曲（含重复，保持原顺序）
hot: list[str] = [s for s in playlist if plays.get(s, 0) > 1000]
print(hot)                    # ['星屑', '回声', '回声']

# 3. 字典推导式 + set 去重：重建去重后的播放量表
unique: dict[str, int] = {s: plays.get(s, 0) for s in set(playlist)}
print(unique)                 # {'回声': 1314, '星屑': 5200, '极光': 999}

import functools
import time

# 1. 带参数的装饰器：三层结构，最外层接收装饰器参数
def timed(label: str):
    def decorator(func):
        @functools.wraps(func)          # 保留原函数的名字与文档
        def wrapper(*args, **kwargs):
            start = time.perf_counter()
            result = func(*args, **kwargs)
            cost = time.perf_counter() - start
            print(f"[{label}] {func.__name__} 耗时 {cost:.3f}s")
            return result
        return wrapper
    return decorator

# 2. @ 等价于 sing = timed("演出")(sing)
@timed("演出")
def sing(song: str, times: int = 1) -> str:
    """登台演唱若干遍。"""
    return f"《{song}》x{times}"

print(sing("极光"))

from dataclasses import dataclass, field

# 1. dataclass 自动生成 __init__ 与 __repr__
@dataclass
class Singer:
    name: str
    color: str = "默认白"
    songs: list[str] = field(default_factory=list)  # 可变默认值必须用工厂函数

    # 2. 魔术方法重载 + 号：合并两位歌姬组成合唱团
    def __add__(self, other: "Singer") -> "Singer":
        return Singer(
            name=f"{self.name}&{other.name}",
            color=self.color,
            songs=self.songs + other.songs,
        )

# 3. 实例化后可直接用运算符组合对象
a = Singer("初霜", "星空蓝", ["星屑"])
b = Singer("南音", "月白", ["回声"])
print(a + b)                  # Singer(name='初霜&南音', color='星空蓝', songs=[...])

# 1. 数据描述符：把"应援色必须合法"的校验逻辑封装成可复用组件
class ThemeColor:
    """定义了 __set__，属于数据描述符，优先级高于实例属性字典。"""

    def __set_name__(self, owner: type, name: str) -> None:
        self.slot = "_" + name          # 自动记录存储槽名

    def __get__(self, obj, objtype=None) -> str:
        return getattr(obj, self.slot, "#FFFFFF")

    def __set__(self, obj, value: str) -> None:
        if not value.startswith("#"):
            raise ValueError("应援色必须以 # 开头")
        setattr(obj, self.slot, value)

# 2. 挂上描述符后，实例赋值自动触发校验
class FanClub:
    color = ThemeColor()

fc = FanClub()
fc.color = "#FF66CC"        # 正常写入
print(fc.color)
# fc.color = "粉色"          # 抛出 ValueError，非法应援色被拦截

from typing import TypedDict

# 1. TypedDict 描述歌曲的结构化数据
class Song(TypedDict):
    title: str
    duration: float     # 时长（秒）

# 2. 函数签名即文档：入参与出值一目了然
def total_duration(songs: list[Song]) -> float:
    return sum(s["duration"] for s in songs)

# 3. mypy 会在静态检查期发现字段拼写或类型错误
album: list[Song] = [
    {"title": "星屑", "duration": 245.0},
    {"title": "极光", "duration": 198.5},
]
print(f"专辑总时长 {total_duration(album)} 秒")

import asyncio
from collections.abc import Iterator

# 1. 生成器函数：惰性产出演唱会门票，不占整块内存
def tickets(total: int) -> Iterator[int]:
    for no in range(1, total + 1):
        yield no

# 2. 协程：async def 声明，await 处让出事件循环
async def upload(song: str) -> str:
    await asyncio.sleep(0.1)            # 模拟网络等待
    return f"{song} 上传完成"

async def main() -> None:
    # 3. gather 并发执行多个协程，总耗时约等于最慢者
    results = await asyncio.gather(upload("星屑"), upload("极光"))
    print(*results, sep="\n")

asyncio.run(main())
print(sum(1 for _ in tickets(100)), "张票可售")

import concurrent.futures as cf
import time

# 1. IO 密集任务：抓取多场演唱会页面，线程池是顺手的选择
def fetch(city: str) -> str:
    time.sleep(0.1)                     # 模拟网络 IO，等待期间 GIL 释放
    return f"{city} 场次已抓取"

def main() -> None:
    cities = ["上海", "东京", "首尔"]

    # 2. 线程池并发：三个请求同时等待，总耗时接近单次请求
    with cf.ThreadPoolExecutor(max_workers=3) as pool:
        for msg in pool.map(fetch, cities):
            print(msg)

if __name__ == "__main__":
    main()
    # 3. CPU 密集任务请改用 ProcessPoolExecutor 实现真并行

# 1. 环境隔离是工程第一步：python -m venv .venv，激活后再安装依赖
# 2. 被测代码：根据点赞与转发计算应援指数
def support_index(likes: int, shares: int) -> int:
    """点赞计 2 分，转发计 3 分。"""
    return likes * 2 + shares * 3

# 3. pytest 参数化测试：一张表覆盖多组用例，命令 pytest 即可运行
import pytest

@pytest.mark.parametrize(
    ("likes", "shares", "want"),
    [(10, 0, 20), (0, 5, 15), (1, 1, 5)],
)
def test_support_index(likes: int, shares: int, want: int) -> None:
    assert support_index(likes, shares) == want

# 错误：第二次调用意外保留了第一次的结果
def add_song(song, playlist=[]):
    playlist.append(song)
    return playlist

print(add_song("星屑"))   # ['星屑']
print(add_song("极光"))   # ['星屑', '极光']

# 修正：用 None 作为哨兵，函数体内再创建新列表
def add_song(song, playlist=None):
    playlist = [] if playlist is None else playlist
    playlist.append(song)
    return playlist

# 错误：三个 lambda 打印的全是 歌姬2
funcs = [lambda: f"歌姬{i}" for i in range(3)]
print([f() for f in funcs])

# 修正：用默认参数在定义时固化当前值
funcs = [lambda i=i: f"歌姬{i}" for i in range(3)]
print([f() for f in funcs])   # ['歌姬0', '歌姬1', '歌姬2']

# 错误：“回响”被漏掉了，没有被检查
songs = ["星屑", "回声", "回响", "极光"]
for s in songs:
    if s.startswith("回"):
        songs.remove(s)
print(songs)              # ['星屑', '回响', '极光']

# 修正：基于原列表重建新列表，或遍历副本 songs[:]
songs = [s for s in songs if not s.startswith("回")]

# 错误：任何异常都被吞掉，票数悄悄变成未定义状态
try:
    votes = int(raw)
except Exception:
    pass

# 修正：只捕获预期的异常类型，并记录日志或给出兜底值
import logging

try:
    votes = int(raw)
except ValueError:
    logging.warning("票数格式非法: %r", raw)
    votes = 0

# 错误：纯计算任务用多线程，受 GIL 限制几乎无加速
import threading

def count():
    total = sum(range(10_000_000))

threads = [threading.Thread(target=count) for _ in range(4)]

# 修正：CPU 密集任务交给进程池，绕开 GIL 实现真并行
from concurrent.futures import ProcessPoolExecutor

def count(n: int) -> int:
    return sum(range(n))

if __name__ == "__main__":  # Windows 下多进程代码必须在入口保护内
    with ProcessPoolExecutor() as pool:
        results = list(pool.map(count, [10_000_000] * 4))

# 错误：backup 的内层列表与原对象共享
import copy

singer = {"name": "初霜", "songs": ["星屑"]}
backup = singer.copy()
backup["songs"].append("极光")
print(singer["songs"])    # ['星屑', '极光']，原数据被污染

# 修正：嵌套结构需要深拷贝
backup = copy.deepcopy(singer)