Python 语法盲区梳理

概述

本篇梳理在学习 MiniClaude 项目过程中，围绕 Python 语言语法与特性暴露的知识盲区。每条盲区包含：①原来的困惑/错误理解 ②正确解释 ③代码示例 ④延伸知识。用于复习速查。

学习者有 Java 基础，因此每条盲区尽量给出 Java 类比，帮助建立映射。本篇只覆盖"Python 语法/特性"层面，不含类型注解（mypy/Pydantic 校验）和 asyncio 并发相关内容。

盲区清单（速查表）

逐条详解

1. Literal 字面量类型

原来怎么理解的：不知道 Literal["2.0"] 是干什么的，以为是普通字符串注解。 正确解释：Literal 是 Python 字面量类型（typing 模块提供），用来限定某个变量的值只能是指定的几个字面量之一。MiniClaude 的 JSON-RPC 消息模型里 jsonrpc: Literal["2.0"] 表示这个字段的值只能是字符串 "2.0"，传 "1.0" 或 2.0（数字）都会被类型检查器拒绝。这是为了确保遵循 JSON-RPC 2.0 协议。 代码示例：

from typing import Literal
​
# jsonrpc 字段只能是字符串 "2.0"，不能是别的
def build_request(jsonrpc: Literal["2.0"] = "2.0"):
    ...
​
# 也可以限定多个值，类似枚举
def set_mode(mode: Literal["fast", "slow", "auto"]):
    ...

延伸：

• Java 类比：Java 没有直接对应，最接近的是 enum，但 Literal 更轻量——不用定义新类型，直接写字面量。

• 易错点：Literal["2.0"] 限定的是字符串 "2.0"，和数字 2.0 是两回事，类型检查器会区分。

• 与 str 注解的区别：str 允许任意字符串，Literal["2.0"] 只允许这一个具体字符串，约束更严格。

---

2. * 强制关键字参数分隔符

原来怎么理解的：看到函数签名里单独一个 * 或 *, 不知道是干什么的，以为是省略或占位。 正确解释：* 是 Python 函数参数的分隔符，叫"keyword-only arguments 分隔符"。* 后面的所有参数，调用时必须用 参数名=值 的方式传，不能按位置传。MiniClaude 的 AgentRunner.__init__ 和 TracingProvider.__init__ 都用了这个语法，强制 provider、runs_dir、include_payload 等参数必须用关键字传入。 代码示例：

# 定义：* 后面的参数都是 keyword-only
def __init__(self, inner, trace, *, include_payload: bool = True):
    ...
​
# 合法：include_payload 用关键字传
TracingProvider(inner, trace, include_payload=True)
​
# 非法！include_payload 按位置传会报 TypeError
TracingProvider(inner, trace, True)

延伸：

• Java 类比：Java 没有这个语法，要达到同样效果得用 Builder 模式——把参数都做成 builder 方法，强制命名。

• * 的两种含义：①在函数定义里作分隔符（本条）；②在函数调用里作解包（func(*args) 把列表展开成位置参数）。两者语境不同。

• 三大好处（原文总结）：①提高可读性（AgentRunner(provider=xxx, runs_dir=yyy) 一目了然）；②防止参数顺序错误；③未来加参数不破坏现有调用代码。

• MiniClaude 出现位置：S0 的 runner.py、S1 的 runner.py、S3 的 TracingProvider 都用了 *,。

---

3. nonlocal 关键字

原来怎么理解的：看到 nonlocal 关键字不认识，不知道和 global、普通赋值有什么区别。 正确解释：nonlocal 是 Python 关键字，用于在嵌套函数中声明"我要修改外层（非全局）函数的变量，而不是创建同名局部变量"。如果不写 nonlocal，在嵌套函数里对外层变量赋值会创建一个新的局部变量，外层变量不变。MiniClaude 的 _socket_loop 里定义的 on_event 嵌套函数没有用 nonlocal，因为它只是读取外层变量（self），没有赋值修改——读取不需要 nonlocal，只有赋值才需要。 代码示例：

def outer():
    count = 0
    def inner_read():
        # 只读取，不需要 nonlocal
        print(count)
    def inner_write():
        nonlocal count  # 声明：我要改外层的 count，不是新建局部变量
        count += 1
    inner_write()
    print(count)  # 输出 1

延伸：

• Java 类比：Java 没有这个关键字，因为 Java 闭包捕获的外层变量必须是 final（或 effectively final），根本不能改。Python 更灵活，用 nonlocal 显式声明"我要改"。

• 三个变量作用域关键字对比：

  • global x：声明 x 指向模块全局变量

  • nonlocal x：声明 x 指向最近一层外层函数的变量

  • 不声明直接赋值：创建当前函数局部变量

• 易错点：nonlocal 只能用在嵌套函数里，模块顶层不能用；它找的是"最近的外层函数作用域"，不会跳到全局。

---

4. field(default_factory=list) 防可变默认参数共享大坑

原来怎么理解的：不理解 messages: list = field(default_factory=list) 为什么不直接写 = []；以为 field 是"字段工厂"的意思。 正确解释：这是为了防止 Python 可变默认参数共享大坑。Python 函数/方法的默认参数只在定义时求值一次，所有调用共享同一个对象。如果直接写 messages: list = []，那么所有实例共享同一个 list，A 实例 append 的消息会污染 B 实例。field(default_factory=list) 的意思是：每次创建实例时，都调用一次 list() 生成一个全新的空列表，保证多个 agent run 的对话历史互不污染。 代码示例：

from dataclasses import dataclass, field
​
@dataclass
class ExecutionContext:
    # 正确：每次创建实例都调 list() 生成新空列表
    messages: list = field(default_factory=list)
​
# 错误写法（大坑！所有实例共享同一个 list）
@dataclass
class Bad:
    messages: list = []  # dataclass 直接禁止这样写，但普通函数允许且会踩坑

延伸：

• field 不是"字段工厂"，它是 @dataclass 的字段配置函数，default_factory 才是工厂。

• field(default=...) 和直接 = 的区别：99% 情况没区别，直接用 =。只有可变值（list/dict/set）必须用 field(default_factory=...)；想配置多个参数（compare=False、init=False 等）时也必须用 field(...)。

• 这个坑在普通函数里同样存在：

# 普通函数的可变默认参数大坑
def add_item(item, basket=[]):  # 错误！所有调用共享同一个 basket
    basket.append(item)
    return basket
add_item(1)  # [1]
add_item(2)  # [1, 2] —— 不是 [2]！

• Java 类比：Java 没有"默认参数"这个特性，方法重载代替，所以没有这个坑。

---

5. __post_init__ 钩子

原来怎么理解的：不知道 __post_init__ 什么时候被调用，也不知道这个名字是不是 dataclass 定死的。 正确解释：__post_init__ 是 @dataclass 硬编码的钩子方法名，不能改。它在 @dataclass 自动生成的 __init__ 执行完之后自动调用，用来插入"初始化后的自定义逻辑"。MiniClaude 的 ExecutionContext 用它把 goal 自动塞进 messages[0]，让调用方不用手动 append。 代码示例：

from dataclasses import dataclass, field
from typing import Any
​
@dataclass
class ExecutionContext:
    goal: str
    prefill_messages: list[dict[str, Any]] = field(default_factory=list)
    messages: list = field(default_factory=list)
​
    def __post_init__(self):
        # __init__ 跑完后自动调用
        # 优先回放 session 历史；否则把 goal 塞进 messages[0]
        if self.prefill_messages:
            self.messages = [dict(m) for m in self.prefill_messages]
        elif not self.messages:
            self.messages.append({"role": "user", "content": self.goal})
​
# 调用方只需传 goal，messages 自动初始化好
ctx = ExecutionContext(goal="帮我读 config.yaml")
print(ctx.messages)  # [{'role': 'user', 'content': '帮我读 config.yaml'}]

延伸：

• Java 类比：像开发商交房后自动启动的装修协议——构造函数（开发商）交付毛坯房，__post_init__（装修协议）自动跑一遍把精装做完。

• 与 __init__ 的区别：@dataclass 已经自动生成了 __init__（赋值所有字段），你不应该重写 __init__（会破坏 dataclass 机制），要加自定义初始化逻辑就写 __post_init__。

• 易错点：方法名必须完全等于 __post_init__（双下划线开头和结尾），写错不报错但不生效。

---

6. 三元表达式 X if 条件 else Y

原来怎么理解的：看不懂 last = self.messages[-1] if self.messages else None 这一行的结构。 正确解释：X if 条件 else Y 是 Python 的三元表达式（条件表达式）。逻辑是：条件为真返回 X，否则返回 Y。注意和 Java/Cpp 的 条件 ? X : Y 顺序相反——Python 把真分支放前面。MiniClaude 用它安全地取最后一条消息：self.messages 非空就取 [-1]，空就返回 None。 代码示例：

# Python 三元表达式：X if 条件 else Y
last = self.messages[-1] if self.messages else None
​
# 等价的 if/else 写法
if self.messages:
    last = self.messages[-1]
else:
    last = None
​
# MiniClaude S3 也有类似用法
blocked = f" (blocked by: {t.blocked_by})" if t.blocked_by else ""

延伸：

• Java 类比：Java 是 条件 ? X : Y，Python 是 X if 条件 else Y，顺序完全相反，从 Java 转 Python 最容易写反。

• Python 三元表达式是表达式（有返回值），可以写在赋值右边、函数参数里；if/else 语句是语句（无返回值）。

• if self.messages: 利用了空列表为假的特性（truthiness）：空 list、空 str、空 dict、None、0、False 都是假。

---

7. 负索引 messages[-1]

原来怎么理解的：不理解 messages[-1] 是什么意思。 正确解释：messages[-1] 是 Python 的负索引，-1 表示最后一个元素，-2 表示倒数第二个，以此类推。等价于 Java 的 messages.get(messages.size() - 1)，但简洁得多。MiniClaude 用它取对话历史里最后一条消息。 代码示例：

messages = ["msg1", "msg2", "msg3"]
​
messages[-1]   # "msg3"（最后一个）
messages[-2]   # "msg2"（倒数第二个）
messages[0]    # "msg1"（第一个）
​
# 负索引也适用于切片
messages[-2:]  # ["msg2", "msg3"]（最后两个）

延伸：

• Java 类比：Java 的 List.get() 不支持负索引，必须写 list.get(list.size() - 1)，容易越界。Python 的负索引是语法糖，自动换算成 len(seq) + (-n)。

• 易错点：负索引不会越界报错友好——[-1] 在空列表上仍抛 IndexError，所以 MiniClaude 才配合三元表达式做安全检查（见第 6 条）。

• 负索引对所有序列类型都有效：list、tuple、str、bytes。

---

8. 列表推导式 [x for x in ...]

原来怎么理解的：看不懂 registry.py 里 tool_schemas() 的语法结构。 正确解释：这是 Python 的列表推导式（list comprehension），语法是 [表达式 for 变量 in 可迭代对象]。它遍历可迭代对象，对每个元素求值"表达式"，收集成新 list。MiniClaude 的 tool_schemas() 遍历所有工具，每个工具转成 dict，返回 dict 组成的 list，发给 LLM 告诉它有哪些工具可用。还可以加 if 过滤条件。 代码示例：

# 基本形式
squares = [x * x for x in range(5)]  # [0, 1, 4, 9, 16]

# 带过滤
evens = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]

# MiniClaude 的 tool_schemas() 类似这样
schemas = [
    {"name": t.name, "description": t.description, "input_schema": t.input_schema}
    for t in self._tools.values()
]

# MiniClaude 的 Task.from_dict 用推导式把 JSON 数组转成 int 列表（core/task/model.py#L39）
blocked_by = [int(x) for x in data.get("blocked_by", [])]

# core/app.py#L203 用 any() + 生成器表达式做 glob 匹配过滤
if not any(fnmatch.fnmatch(event_type, p) for p in topics):
    continue

延伸：

• Java 类比：等价于 Java Stream 的 map + collect：

  list.stream().map(t -> Map.of(...)).collect(Collectors.toList());
  

  Python 推导式更简洁，是 Pythonic 的核心写法。

• 衍生形式：字典推导式 {k: v for ...}、集合推导式 {x for ...}、生成器表达式 (x for ...)（懒求值，不立即生成 list）。

• 性能：推导式比等价的 for 循环 + append 略快（Python 解释器专门优化）。

---

9. dict() 是函数调用不是注解

原来怎么理解的：把 dict(tool_call.input) 里的 dict() 误认为是类型注解。 正确解释：dict(...) 是函数调用，不是注解。dict(tool_call.input) 是调用 dict 构造函数，把 tool_call.input 拷贝一份成新 dict。MiniClaude 这么做是为了给事件里的 params 存参数快照，防止后续修改影响事件记录。dict[str, Any]（带方括号）才是类型注解——表示"dict 类型，键是 str，值是 Any"。 代码示例：

# 这是函数调用——拷贝一份 dict
params = dict(tool_call.input)   # 等价于 tool_call.input.copy()
params["new_key"] = "x"          # 不影响原 tool_call.input

# 这是类型注解——说明变量类型
def foo(config: dict[str, Any]) -> None: ...

# 区分技巧：
# dict(...)   圆括号 + 参数  → 函数调用（运行时执行）
# dict[...]   方括号 + 类型  → 类型注解（不执行，只标注）

延伸：

• 易错点：dict(x) 是浅拷贝，只复制外层 dict，里面嵌套的 list/dict 还是共享引用。要深拷贝用 copy.deepcopy。

• dict() 还能从键值对序列构造：dict([("a", 1), ("b", 2)]) → {"a": 1, "b": 2}。

• 类型注解 dict[str, Any] 是 Python 3.9+ 才支持的内置泛型语法，3.8 及以前要写 Dict[str, Any]（从 typing 导入）。

---

10. or 短路求值

原来怎么理解的：不理解 provider = self._provider or AnthropicProvider(...) 为什么需要 or。 正确解释：Python 的 or 是短路求值：A or B 中，如果 A 为真就返回 A，不会再算 B；如果 A 为假才返回 B。MiniClaude 用它实现"传了就用传入的，没传（None）就用默认值"——self._provider or AnthropicProvider(...)：传了 provider 就用传入的，没传就自动创建默认的 AnthropicProvider。这是依赖注入的常见写法，支持测试用 Mock、扩展用其他 LLM。 代码示例：

# 短路或：传了 provider 就用传入的，没传（None）就创建默认的
provider = self._provider or AnthropicProvider(...)

# MiniClaude 的 extra_handlers 一处用 or 兜底，配合默认 None 避坑（runner.py#L62/L71）
def __init__(self, ..., extra_handlers=None):  # 默认 None 避开可变默认参数大坑
    extra_handlers = extra_handlers or []       # None 兜底成空列表，后面不用判断 None
    for h in extra_handlers:
        ...

# 短路求值常用于默认值
name = user_input or "anonymous"  # user_input 为空就用 "anonymous"

延伸：

• Java 类比：Java 的 || 也是短路或，但返回 boolean；Python 的 or 返回的是操作数本身（不是 boolean），所以能直接当默认值用。这是 Python 的便利之处。

• 对应的 and 也是短路：A and B，A 为假就返回 A，A 为真才返回 B。

• 短路求值的"假"包括：None、False、0、""、[]、{}、() 等所有空容器和零值。

• 易错点：0 or default 会返回 default，因为 0 是假——如果 0 是合法值，别用 or，要用 if x is None。

---

11. __all__ 公开 API 清单

原来怎么理解的：以为 __all__ 是普通变量，不知道它的特殊作用。 正确解释：__all__ 是模块的**"公开 API 清单"，是一个字符串列表，控制 from module import * 时导出哪些名字**。没在 __all__ 里的名字不会被 import * 导入。MiniClaude 的 tools/__init__.py 里 __all__ = ["BaseTool", "ToolResult", "ToolRegistry", "invoke_tool"] 就声明了这 4 个是公开 API，其他内部实现细节不导出。 代码示例：

# tools/__init__.py
from .base import BaseTool, ToolResult
from .registry import ToolRegistry
from .invocation import invoke_tool

# 公开 API 清单：只有这 4 个会被 from tools import * 导入
__all__ = ["BaseTool", "ToolResult", "ToolRegistry", "invoke_tool"]

# 没列在 __all__ 里的（比如内部辅助函数）不会被 import * 导出
def _internal_helper():
    ...

延伸：

• Java 类比：Java 没有直接对应，最接近的是包级私有（不加 public 的类）。但 Python 没有"包级私有"语法，__all__ 是约定俗成的公开 API 标识。

• 没有 __all__ 时，import * 会导入所有不以 _ 开头的名字。定义了 __all__ 就只导入列出的名字。

• __all__ 只影响 import *，不影响 from module import xxx（显式导入仍可用）。

• 最佳实践：库的顶层 __init__.py 应该写 __all__，明确告诉用户"这些是稳定 API，其他都是内部实现，别依赖"。

---

12. import x vs from x import * 区别

原来怎么理解的：分不清 import mini_claude.core.tools 和 from mini_claude.core.tools import * 的区别。 正确解释：

• import x：把整个模块作为对象引入，用 x.func() 访问。

• from x import *：把模块里 __all__ 列出的名字直接引入当前命名空间，直接用 func() 访问，不用加模块名前缀。

• 两者实际加载的都是 core/tools/__init__.py 这个文件，区别在访问方式和命名空间污染程度。 代码示例：

# 方式一：import x —— 加模块名前缀
import mini_claude.core.tools
tool = mini_claude.core.tools.BaseTool()  # 必须带完整前缀

# 方式二：from x import * —— 直接用名字
from mini_claude.core.tools import *
tool = BaseTool()  # 直接用，不用前缀

# 方式三（推荐）：from x import 具体名字 —— 既省前缀又不污染
from mini_claude.core.tools import BaseTool, ToolRegistry
tool = BaseTool()

延伸：

• Java 类比：import x ≈ import com.example.package;（要带包名前缀）；from x import * ≈ import static com.example.package.*;（直接用静态成员名）。

• 易错点：from x import * 会污染当前命名空间，可能覆盖同名变量，且看不出名字来自哪个模块。生产代码不推荐用 import *，推荐 from x import 具体名字。

• import x as y 可以给模块起别名（如 import numpy as np），常用长模块名缩短。

---

13. __init__.py 作用

原来怎么理解的：看到 __init__.py 经常是空文件，不明白有什么作用。 正确解释：__init__.py 标记一个目录是 Python 包（package）。即使为空，也让 Python 把这个目录当成模块来导入。包的 __init__.py 也可以放初始化代码（包被导入时执行一次）和聚合导出（在 __init__.py 里 from .sub import xxx，让外部更方便导入）。 代码示例：

# 目录结构
# mini_claude/
#   __init__.py          ← 标记 mini_claude 是包
#   core/
#     __init__.py        ← 标记 core 是包
#     tools/
#       __init__.py      ← 标记 tools 是包，可聚合导出
#       base.py
#       registry.py

# tools/__init__.py 里做聚合导出
from .base import BaseTool, ToolResult
from .registry import ToolRegistry
from .invocation import invoke_tool

__all__ = ["BaseTool", "ToolResult", "ToolRegistry", "invoke_tool"]

# 这样外部就能直接写：from mini_claude.core.tools import BaseTool
# 而不用写：from mini_claude.core.tools.base import BaseTool

延伸：

• Java 类比：Java 用目录结构 + package 声明表示包，不需要特殊文件。Python 用 __init__.py 显式标记。

• Python 3.3+ 支持命名空间包（没有 __init__.py 也能导入），但普通项目还是建议写 __init__.py，避免歧义和工具兼容问题。

• __init__.py 里写代码会在包第一次被导入时执行，适合做包级初始化（如注册日志、加载配置）。

---

14. 闭包/嵌套函数定义

原来怎么理解的：不知道 Python 可以在函数里定义函数，也不理解"闭包"是什么。 正确解释：Python 完全支持函数内定义函数（嵌套函数）。内部函数可以捕获外部函数的变量——这就是闭包特性。MiniClaude 的 tui/app.py 在 _socket_loop 里定义了 async def on_event(event) 嵌套函数作为事件回调注册到 SocketClient，它只捕获了外层的 self（调用 self._handle_event(event)），不引用 log。

代码示例：

# tui/app.py#L779-780 —— 闭包只捕获 self，不需要 nonlocal
async def on_event(event: dict) -> None:
    self._handle_event(event)   # 读外层 self，不需要 nonlocal

client.on_event(on_event)

# cli/commands/run.py#L78-79 —— 写外层变量必须 nonlocal
async def on_event(event: dict) -> None:
    nonlocal exit_code           # 要改外层 exit_code，必须 nonlocal
    await printer.handle(event)
    if event.get("type") == "run.finished":
        if event.get("status") != "success":
            exit_code = 1
        finished.set()

# 闭包经典例子：计数器
def make_counter():
    count = 0
    def counter():
        nonlocal count  # 见第 3 条
        count += 1
        return count
    return counter

c = make_counter()
c()  # 1
c()  # 2

延伸：

• Java 类比：Java 8+ 的 lambda 捕获外层变量就是闭包，但 Java 要求捕获的变量是 final（或 effectively final）。Python 更宽松，配合 nonlocal 还能修改外层变量。

• 闭包的核心：函数 + 它捕获的外层变量打包在一起，即使外层函数已经返回，捕获的变量仍然存活（被闭包引用着）。

• 易错点：闭包捕获的是变量本身（引用），不是当时的值。在循环里定义闭包要小心——所有闭包可能共享同一个循环变量的最后值，需要用默认参数或工厂函数固定。

---

15. f-string 变量插值

原来怎么理解的：看不懂 f-string 里的 {t.id}、{t.subject} 是什么，分不清引号结构。 正确解释：f-string（format string）是 Python 3.6+ 的字符串插值语法，前缀 f + 字符串里用 {变量名} 插入变量值。MiniClaude 的 format_list()（core/task/manager.py#L118-127）用 f"{marker.get(t.status, '[?]')} #{t.id}: {t.subject}{blocked}" 把任务的状态标记、ID、subject、blocked 信息直接拼进字符串。marker 是字典 {"pending": "[ ]", "in_progress": "[>]", "completed": "[x]"}，用 .get() 查表取标记；blocked 是用三元表达式提前算好的条件拼接片段。

代码示例：

# f-string：前缀 f + {变量} 插值
name = "Alice"
age = 30
print(f"姓名: {name}, 年龄: {age}")  # 姓名: Alice, 年龄: 30

# MiniClaude 的 format_list() 实际写法（core/task/manager.py#L122-126）
marker = {"pending": "[ ]", "in_progress": "[>]", "completed": "[x]"}
for t in tasks:
    blocked = f" (blocked by: {t.blocked_by})" if t.blocked_by else ""
    lines.append(f"{marker.get(t.status, '[?]')} #{t.id}: {t.subject}{blocked}")
# 输出示例: [ ] #1: 读取源文件 (blocked by: [2, 3])
# 输出示例: [x] #2: 写入配置

# f-string 里还能写表达式
print(f"2 + 3 = {2 + 3}")        # 2 + 3 = 5
print(f"长度: {len(name)}")      # 长度: 5

延伸：

• Java 类比：Java 没有直接等价的字符串插值语法，最接近的是 String.format("姓名: %s", name) 或 MessageFormat.format("姓名: {0}", name)，但都不能直接写变量名。Java 21+ 才有字符串模板预览特性。

• 引号不混乱的技巧：f-string 外层用双引号 f"..."，里面 {} 里如果要嵌字符串，用单引号：f"{ 'X' if cond else 'Y' }"。Python 3.12+ 才支持 f-string 里用和外层相同的引号。

• 老式写法对比："姓名: " + name + ", 年龄: " + str(age)（拼接，繁琐）vs "姓名: %s, 年龄: %d" % (name, age)（C 风格，易错）vs f"姓名: {name}, 年龄: {age}"（最推荐）。

• 易错点：f-string 在定义时立即求值，不是惰性。所以日志里用 f-string 会无条件求值，即使日志级别没开。性能敏感场景用 logging 的 %s 占位符延迟求值。

---

16. set() 去重 + list() 转回

原来怎么理解的：不理解 list(set(task.blocked_by + add_blocked_by)) 这行为什么这么写。 正确解释：这是 Python 经典的去重模式——set() 把列表转成集合（自动去重），list() 再转回列表。MiniClaude 的 add_blocked_by 逻辑：先把新旧依赖列表拼接，set() 去重（避免重复依赖），list() 转回列表（保持类型一致）。三步合起来：拼接 → 去重 → 转回。 代码示例：

# MiniClaude 的 add_blocked_by 去重逻辑
task.blocked_by = [2, 3]              # 旧依赖
add_blocked_by = [3, 4]               # 新依赖

# 拼接 → set 去重 → list 转回
task.blocked_by = list(set(task.blocked_by + add_blocked_by))
# [2, 3] + [3, 4] = [2, 3, 3, 4]
# set([2, 3, 3, 4]) = {2, 3, 4}      ← 自动去重
# list({2, 3, 4}) = [2, 3, 4]        ← 转回列表

# 通用去重模式
def dedup(items):
    return list(set(items))

# 如果想保留顺序，用 dict.fromkeys（Python 3.7+ dict 保序）
def dedup_keep_order(items):
    return list(dict.fromkeys(items))

延伸：

• Java 类比：Java 用 new ArrayList<>(new LinkedHashSet<>(list)) 去重，更啰嗦。Python 的 list(set(...)) 一行搞定。

• 易错点：set 无序，list(set(...)) 去重后顺序丢失。如果顺序重要，用 dict.fromkeys(...) 或 list(dict.fromkeys(...))（3.7+ 保序）。

• 三大容器转换：list(x) 把任意可迭代转 list；set(x) 转 set（去重）；dict(x) 把键值对序列转 dict。

• MiniClaude S3 还有一处 set 用法：self._running_runs: set[asyncio.Task] = set() 用 set 存并发 Run 的 Task，配合 add_done_callback(self._running_runs.discard) 自动清理。

---

复习自检

• 能否说出 * 在函数定义和函数调用里的两种不同含义？

• 能否区分 field(default=...) 和 field(default_factory=...) 的使用场景？为什么可变默认值不能用 default=？

• 能否写出 Python 三元表达式的语法，并指出和 Java ? : 的顺序差异？

• 能否解释 nonlocal、global、直接赋值三者的区别？

• 能否说出 dict(...)（圆括号）和 dict[...]（方括号）分别是什么？

• 能否用列表推导式实现"取出列表中所有偶数的平方"？

• 能否解释 __all__ 只影响哪种导入方式？为什么不影响显式 from x import y？

• 能否说出 list(set(...)) 去重的副作用（顺序丢失），以及如何保留顺序？

易错点总结

• 可变默认参数大坑：def f(x=[]) 所有调用共享同一个 list，必须用 None + or [] 或 field(default_factory=list)。

• 三元表达式顺序反：Python 是 X if 条件 else Y，Java 是 条件 ? X : Y，从 Java 转过来最容易写反。

• or 返回的不是 boolean：Python 的 or 返回操作数本身（0 or 5 返回 5），不是 True/False，所以能直接当默认值用，但 0 是合法值时别用 or。

• set() 去重丢顺序：list(set(...)) 顺序不可预测，顺序敏感场景用 list(dict.fromkeys(...))。

• f-string 立即求值：f-string 在定义时就求值，日志级别没开也会算，性能敏感场景用 %s 占位符。

• 闭包捕获循环变量：循环里定义闭包捕获的是变量引用，所有闭包可能共享循环变量的最后值，需要用默认参数固定。

• nonlocal 只用于嵌套函数：模块顶层不能用 nonlocal；它找最近一层外层函数作用域，不跳到全局。

• __post_init__ 名字不能改：必须是双下划线包围的 __post_init__，写错不报错但不生效。