Python 有哪些好玩的语法糖？

在 Python 中，许多看似普通的语法结构背后，其实隐藏着相当精巧的运行时机制。理解这些机制不仅能帮助我们写出更灵活的代码，还能在阅读他人代码时更快抓住本质。本文从函数定义的底层流程谈起，再延伸到 class 语句的构造过程，最后给出几个利用这些特性“偷懒省事”的实用技巧。

一、函数定义：不只是写一段代码

先看一个最简单的函数定义：

def f(a=b):
    print(a)

从源码到可执行对象，这个过程大致分为几步：

1. 编译期：f 的代码块被编译成一个 code object，存放在字节码常量池中。此时它只是一个静态的指令序列，还没有名字、没有默认值绑定，也没有闭包环境。
2. 执行期：当解释器执行到 def 语句所在位置时，会根据这个 code object 构建一个 function object。
3. 赋值：最后，这个 function object 被赋值给变量 f。是的，f 本质上就是一个变量名，和 x = 1 中的 x 没有本质区别。

那么问题来了：为什么不直接把 code object 赋给 f，而要额外封装一层 function object？

原因在于，function object 除了携带 code object 之外，还保存了大量动态信息：

• 函数参数默认值（例如上面的 b）
• 闭包信息（如果 f 是一个闭包函数，需要记录自由变量）
• 函数名、文档字符串、注解等元数据
• __dict__、__globals__ 等运行时属性

code object 是“静态的”，而 function object 是“活的”。只有封装成 function object，函数才能在运行时正确绑定默认值、访问闭包变量、支持属性挂载等操作。

理解这一点，是理解后面 class 构造过程的基础。

二、class 语句：一个“伪装”的函数执行过程

class 本质上也是一个赋值语句，只不过比普通赋值复杂得多。执行到 class A: ... 时，解释器大致做了以下几件事：

1. 创建一个临时命名空间（可以理解为一个字典），用来存放类体中的局部变量。
2. 把类体代码块“假装”当成一个函数来执行。也就是说，类体代码会被编译成一个 code object，然后像函数一样被调用。
3. 执行完成后，不销毁局部环境，而是将局部变量整理、转换，最终构建出 class object。
4. 将 class object 赋值给类名变量。和函数一样，类名也是变量。

但类体这个“假函数”与真正的函数有一些关键区别：

• 没有输入参数：类体不能像函数那样接收参数（除非通过元类或 __init_subclass__ 等机制间接传入）。
• 不能显式 return：类体中写 return 是语法错误。
• 类体中 def 定义的函数不作为这个“假函数”的闭包：这一点很重要。在普通函数里嵌套定义函数，内层函数会捕获外层函数的局部变量形成闭包；但在类体中定义的函数，并不会把类体的局部变量当作闭包变量。

执行上的最大区别在于：执行完成后，局部环境不被销毁，而是被转化为类的属性。这正是 class 能够“动态构造”的根本原因。

三、利用类体执行特性动态生成方法

因为类体代码是在构造类的时候才执行的，所以我们可以根据运行时的条件，决定类中到底定义哪些方法、哪些属性。例如：

class A:
    i = raw_input()
    if i == "a":
        def f(self):
            print("user select a")
    else:
        def f(self):
            print("user select b")
    del i
a = A()
a.f()

这段代码在构造 A 的时候，会根据用户输入决定 f 的具体实现。注意这里有两个“局部变量”：i 和 f。最后 del i 把 i 从类属性中移除，这样 i 就不会成为 A 的一个属性（俗称“类静态变量”）。如果不删除，A.i 就会一直存在，可能并不是我们想要的结果。

这种写法在某些场景下非常实用。比如批量生成方法：

class Pkg:
    for _fmt in "BHIQ":
        exec('unpack_%s = lambda self: struct.unpack("!%s", self.bytes)[0]' % (_fmt, _fmt))
    del _fmt
    __str__ = __repr__ = lambda self: `self.bytes`

这里利用 exec 在类体中动态创建了 unpack_B、unpack_H、unpack_I、unpack_Q 四个方法。lambda 和 def 在功能上等价，只是写法不同。最后 del _fmt 避免 _fmt 成为类属性。

这种“在类定义时批量生成方法”的技巧，在编写协议解析、序列化/反序列化、ORM 字段映射等场景时尤其有用。

四、方法转换：从 function 到 method

还有一个容易被忽略的细节：类体执行完毕后，并不是简单地把残余局部变量表直接变成类属性。对于其中的函数对象，解释器会做一次“方法转换”。

看这个例子：

class A:
    def f(self):
        print("f")
print(f)        # 此时 f 还是一个普通 function
print(A.f)      # 通过类访问，f 变成了 function（未绑定）
print(A().f)    # 通过实例访问，f 变成了 bound method

在 def f 执行完之后，f 本来是一个普通的 function object。但在构造 class object 的时候，解释器会把它转换成类的方法（在 Python 3 中，通过类访问得到的是普通函数，通过实例访问得到的是绑定方法）。这个转换过程依赖于描述符协议。

而对于用装饰器指定为 staticmethod 或 classmethod 的函数，则不会做同样的转换，或者会做其它类型的转换。因此，解释器在“构造 class”的过程中，需要识别这些装饰器所修饰过的函数，并分别处理。

这也解释了为什么 staticmethod 和 classmethod 必须放在 def 的最外层——因为它们需要在类构造阶段被识别并做特殊处理。

五、实用建议与注意事项

掌握这些底层机制后，可以在实际开发中更自如地使用以下技巧：

• 动态方法生成：在类体中用循环 + exec 或 setattr 批量创建方法，减少重复代码。
• 条件定义：根据运行时配置决定类中是否包含某些方法或属性。
• 清理临时变量：用 del 移除类体中产生的临时变量，避免污染类属性。
• 谨慎使用 exec：虽然灵活，但可读性和安全性较差，建议仅在明确收益时使用。

同时也要注意：

• 类体中的变量作用域与函数不同，不要假设闭包行为。
• 装饰器在类构造阶段就会被处理，顺序和位置很重要。
• 过度依赖动态构造会降低代码可读性，建议配合注释和文档。

结语

Python 的 class 语句远不止“定义一个类”这么简单。它本质上是一段在构造阶段执行的代码块，执行完成后将局部环境转化为类属性，并对函数做方法转换。理解这一过程，不仅能让我们看懂许多“魔法”代码，还能在需要时写出更灵活、更简洁的实现。语法糖之所以“好玩”，正是因为它们背后往往藏着值得深挖的设计思想。