iter 与 next#

迭代器实现迭代器协议：__iter__() 返回自身（或另一迭代器），该对象再提供 __next__()。内置 iter() 优先调用 __iter__()；若没有 __iter__ 但实现了从 0 开始的 __getitem__，仍可按序列方式迭代（见 iterator protocol）。日常自己写可迭代对象时，实现 __iter__ 即可。

next(iterator[, default]) 调用 iterator.__next__()。没有更多元素时，__next__() 抛出 StopIteration；若提供了 default，则返回 default 而不抛异常。

容器（如 list）本身通常不是迭代器，但可迭代（iterable）：__iter__() 返回一个新的迭代器。每次 for x in lst: 都会先 iter(lst) 再反复 next。

1
it = iter([10, 20, 30])
2
print(next(it))  # 10
3
print(next(it))  # 20
4
print(next(it, "没了"))  # 30
5
print(next(it, "没了"))  # 没了

for 循环在底层等价于：取迭代器 → 反复 next → 捕获 StopIteration 结束。自己实现可迭代对象时，最小骨架如下（菜鸟 迭代器 有类似例子，协议以官方为准）：

1
class CountDown:
2
    def __init__(self, n):
3
        self.n = n
4

5
    def __iter__(self):
6
        return self
7

8
    def __next__(self):
9
        if self.n <= 0:
10
            raise StopIteration
11
        self.n -= 1
12
        return self.n + 1

生成器与 yield#

生成器是一种迭代器，由含 yield 的函数或 yield from 表达式产生。调用生成器函数不会立刻执行函数体，而是返回一个生成器对象；每次 next() 或 for 循环驱动执行到下一个 yield，产出值并暂停。

1
def count_up_to(n):
2
    i = 1
3
    while i <= n:
4
        yield i
5
        i += 1
6

7
for x in count_up_to(3):
8
    print(x)  # 1, 2, 3

生成器表达式 (x * x for x in range(5)) 语法类似列表推导，但结果是生成器而非列表，适合大数据或流水线，见 Generator expressions。

yield from iterable 把产出委托给另一个可迭代对象，常用于扁平化嵌套生成器。要用 with 包一层生成器，需 contextlib.contextmanager；生成器本身不是上下文管理器。

定义函数 def#

def 定义用户函数。函数体在调用时才执行；定义时只创建函数对象并绑定名字。函数是一等对象，可赋给变量、当参数、当返回值。

1
def greet(name):
2
    """向 name 问好。"""
3
    return f"Hello, {name}!"
4

5
print(greet("Alice"))
6
print(greet.__name__)  # greet

教程 · Defining Functions 强调：函数可 return 多个值（实际是返回一个元组），也可无 return（等价于 return None）。

参数：位置、默认、关键字、*args、**kwargs#

参数种类见 More on Defining Functions 与 Function definitions。

位置参数（positional）：按定义顺序传入。

默认参数（default）：形参带 = 默认值；缺省调用时使用默认值。默认值在函数定义时只求值一次——不要用可变对象（如 []、{}）当默认值，否则多次调用会共享同一对象：

1
def bad(a, items=[]):  # 反例
2
    items.append(a)
3
    return items
4

5
def good(a, items=None):
6
    if items is None:
7
        items = []
8
    items.append(a)
9
    return items

仅关键字参数（keyword-only）：在 * 或 *args 之后的参数必须用关键字传入；PEP 3102 起可在签名里写 *, x, y。

关键字参数（keyword）：func(a=1, b=2) 按名字传参，顺序可与定义不同。

*args：收集多余位置实参为元组。**kwargs：收集多余关键字实参为字典。名字只是约定，可以是 *rest、**opts。

1
def demo(pos, /, both, *, kwonly, **kwargs):
2
    # pos: 仅位置（3.8+ 语法 /）
3
    # both: 位置或关键字
4
    # kwonly: 仅关键字
5
    # kwargs: 其余关键字
6
    print(pos, both, kwonly, kwargs)
7

8
demo(1, 2, kwonly=3, extra=4)
9
# demo(pos=1, ...) 会 TypeError：pos 不能按关键字

调用侧 *iterable 解包位置实参，**mapping 解包关键字实参（键须为字符串）。

return#

return 结束当前函数调用，可选跟一个表达式。无表达式时返回 None。return 可在任意缩进层级结束函数，不会自动结束外层循环（与某些语言不同）。

1
def find_first(pred, items):
2
    for x in items:
3
        if pred(x):
4
            return x
5
    return None

lambda#

lambda 产生匿名函数对象，语法 lambda 参数: 表达式。只能写单个表达式，不能含语句或赋值（3.8+ 海象 := 在 lambda 里仍受限）。适合短小的回调，复杂逻辑用 def。

1
pairs = [(2, "b"), (1, "a"), (3, "c")]
2
pairs.sort(key=lambda p: p[0])

LEGB：名字怎么找#

命名与绑定 规定：名字引用按 LEGB 顺序查找——Local（当前函数）、Enclosing（外层函数）、Global（模块全局）、Built-in（内置名，如 len）。

1
x = "global"
2

3
def outer():
4
    x = "enclosing"
5

6
    def inner():
7
        x = "local"
8
        print(x)  # local
9

10
    inner()
11
    print(x)  # enclosing
12

13
outer()
14
print(x)  # global

函数定义在定义时绑定外层作用域（闭包），不是调用时。内层函数可读取外层名字；若要重新绑定外层非全局名字，需要 nonlocal；绑定模块级名字需要 global。

if / for / while / try 不创建函数那样的局部作用域，块里赋的名在块外仍能用（菜鸟 命名空间 有图；语义以 Naming and binding 为准）。

内置名在 builtins 模块：import builtins; dir(builtins)。

global 与 nonlocal#

global 把本函数里的名字标成模块全局。nonlocal 标成最近一层外层函数里的名字（不能是全局）。

函数体内只要出现对某名字的赋值，整个函数都把它当局部。因此下面会 UnboundLocalError：

1
x = 1
2

3
def f():
4
    print(x)  # 想读全局 x
5
    x = 2     # 这一行让 x 在整个 f 里都是局部

要改全局就写 global x，或不要在函数里给同名赋值。

1
count = 0
2

3
def inc_global():
4
    global count
5
    count += 1
6

7
def make_counter():
8
    n = 0
9

10
    def inc():
11
        nonlocal n
12
        n += 1
13
        return n
14

15
    return inc
16

17
c = make_counter()
18
print(c(), c())  # 1, 2
19
inc_global()
20
print(count)     # 1

滥用 global 会让数据流难追踪；优先用参数、返回值或类封装状态。

装饰器#

PEP 318 引入函数装饰器语法：@decorator 放在 def（或 class）前，等价于 func = decorator(func)。装饰器通常是接受 callable、返回 callable 的可调用对象。

1
def log_calls(fn):
2
    def wrapper(*args, **kwargs):
3
        print(f"calling {fn.__name__}")
4
        return fn(*args, **kwargs)
5
    return wrapper
6

7
@log_calls
8
def add(a, b):
9
    return a + b
10

11
add(1, 2)  # 先打印 calling add，再返回 3

被包装后 wrapper.__name__ 等元数据会丢；用 functools.wraps 拷回去：

1
import functools
2

3
def log_calls(fn):
4
    @functools.wraps(fn)
5
    def wrapper(*args, **kwargs):
6
        print(f"calling {fn.__name__}")
7
        return fn(*args, **kwargs)
8
    return wrapper

带参装饰器：外层函数先接收装饰器参数，返回真正的装饰器。

1
def repeat(times):
2
    def decorator(fn):
3
        def wrapper(*args, **kwargs):
4
            for _ in range(times):
5
                result = fn(*args, **kwargs)
6
            return result
7
        return wrapper
8
    return decorator
9

10
@repeat(3)
11
def hi():
12
    print("hi")

类也可以当装饰器（实现 __call__）。内置装饰器如 staticmethod、classmethod、property 在第 8 篇类一节会碰到。装饰器栈从下往上应用：@a @b def f 等价于 f = a(b(f))。

with 与上下文管理器#

with 语句用于管理资源：进入时 setup，离开时 teardown，即使发生异常也会清理。PEP 343 定义协议。

上下文管理器需实现：

• __enter__(self)：进入 with 块前调用；返回值绑定到 as 后的变量（若无 as 则忽略返回值）。
• __exit__(self, exc_type, exc_val, exc_tb)：离开 with 块时调用。若返回真值，会抑制当前异常（一般不这么做）；否则异常继续传播。

1
class Tag:
2
    def __init__(self, name):
3
        self.name = name
4

5
    def __enter__(self):
6
        print(f"<{self.name}>")
7
        return self
8

9
    def __exit__(self, exc_type, exc, tb):
10
        print(f"</{self.name}>")
11
        return False
12

13
with Tag("p") as t:
14
    print("body")

内置 open() 返回的文件对象、threading.Lock 等已实现该协议。手写资源管理可用 contextlib.contextmanager 装饰生成器，或用 contextlib.AbstractContextManager。多个上下文管理器可写 with A() as a, B() as b:。

try / except / else / finally#

完整语法见 The try statement 与 Errors and Exceptions。

1
try:
2
    risky()
3
except ValueError as e:
4
    handle(e)
5
except (TypeError, OSError):
6
    recover()
7
else:
8
    # 仅当 try 块未抛出异常时执行
9
    on_success()
10
finally:
11
    # 总是执行（除非进程被杀死等）
12
    cleanup()

要点：

• except：匹配异常类型（元组表示多个）。as e 绑定异常实例；在 Python 3 里，except 块结束后 e 会被删除，避免循环引用（PEP 3110）。
• else：没有异常时运行，常把可能抛错的逻辑放在 try、成功路径放在 else，避免把 else 里的错误当成 except 能处理的同一类问题（教程建议）。
• finally：用于释放资源；若有 return，finally 仍会在返回前执行。
• 顺序：try → 若异常则匹配的 except → 无异常则 else → 始终 finally。

raise 抛出异常：raise ValueError("msg")；raise 单独使用则重新抛出当前异常（常在 except 里记录后再抛）。

1
def parse_int(s):
2
    try:
3
        return int(s)
4
    except ValueError:
5
        raise ValueError(f"不是整数: {s!r}") from None  # 抑制异常链

Exception chaining：内层 raise ... from e 保留原因；from None 隐藏上下文。

用户自定义异常：继承 Exception（不要直接继承 BaseException，除非做系统退出类异常）。

1
class MyAppError(Exception):
2
    pass

assert 用于调试断言，-O 优化模式下会被去掉；不要用 assert 做业务校验或数据验证。

常见内置异常（点名）#

下列名字均来自 Built-in Exceptions，日常读写代码时最常见。完整继承树见文末附录。

一般不捕获 BaseException 下的 KeyboardInterrupt、SystemExit、GeneratorExit，除非在做框架级顶层处理。

附录：内置异常继承关系（节选）#

以下为官方文档 Exception hierarchy 的压缩表，便于查「该捕哪个父类」。缩进表示子类。

捕获时：except OSError 可捕 FileNotFoundError；except LookupError 可捕 IndexError 与 KeyError。具体是否捕获取决于你是否能合理处理。

附录：函数参数汇总#

参考#

官方文档（中文版 可对照阅读）：

1. More Control Flow Tools — Defining Functions — 默认参数、关键字参数、*args / **kwargs、Docstring
2. More Control Flow Tools — Intermezzo: Coding Style — 命名与可读性（与函数组织相关）
3. Errors and Exceptions — 异常处理、else / finally、raise、用户异常、异常链
4. Compound statements — Function definitions — 完整参数语法、lambda 不能替代 def 的全部能力
5. Compound statements — The try statement — try / except / else / finally 语义
6. Compound statements — The with statement — with 与 as
7. Data model — With Statement Context Managers — __enter__ / __exit__
8. Glossary — iterator / generator / iterable — 术语定义
9. Execution model — Naming and binding — LEGB、闭包
10. Simple statements — global / nonlocal / return / raise / yield
11. Built-in Exceptions — 异常列表与继承树
12. functools.wraps — 装饰器保留元数据
13. contextlib — 上下文管理器工具

PEP：

14. PEP 318 — Decorators for Functions and Methods
15. PEP 343 — The “with” Statement
16. PEP 3102 — Keyword-Only Arguments
17. PEP 3110 — Catching exceptions in Python 3000

目录来源（骨架，不以它为准改语法）：

18. 菜鸟教程 · Python3 函数
19. 菜鸟教程 · Python3 迭代器与生成器
20. 菜鸟教程 · Python3 装饰器
21. 菜鸟教程 · Python3 错误和异常
22. 菜鸟教程 · Python3 命名空间/作用域
23. 菜鸟教程 · Python3 with
24. 菜鸟教程 · Python3 lambda