1. 项目概述理解Python的调用与绑定约定在Python的世界里无论你是刚入门的新手还是已经写了几年脚本的开发者迟早都会遇到一个核心问题一个函数或方法到底是如何被“调用”起来的对象的方法又是如何“绑定”到实例上的这听起来像是语言内部的魔法但理解它是真正从“会用Python”迈向“懂Python”的关键一步。我见过不少项目因为对调用和绑定的理解不透彻导致了性能瓶颈、难以调试的Bug甚至是架构设计上的缺陷。简单来说调用约定决定了当你写func(arg1, arg2)时Python解释器在背后做了什么来定位函数、传递参数并执行代码。而绑定约定则解释了为什么在类中定义的方法通过实例调用时能自动获得self参数而通过类直接调用时却不行。这两个概念是Python面向对象和函数式编程的基石。无论你是要开发高性能的Web框架、设计复杂的类库API还是仅仅想优化自己的代码吃透它们都至关重要。接下来我将带你深入CPython解释器的层面拆解这些约定并用大量代码示例展示它们在实际开发中的影响和妙用。2. 核心概念解析什么是可调用对象在深入调用和绑定之前我们必须统一认识在Python中“调用”这个操作即使用()运算符作用于一个可调用对象。那么哪些东西是可调用的呢绝不仅仅是def定义的函数。2.1 内置可调用类型首先我们可以用callable()内置函数来检测。常见的可调用对象包括用户自定义函数使用def语句或lambda表达式创建。内置函数像len,print这类用C实现并内置在解释器中的函数。内置方法如list.append这是内置类型的绑定方法。类对类进行调用如MyClass()会触发其__new__和__init__方法返回一个实例。类的实例如果某个类定义了__call__方法那么它的实例就可以像函数一样被调用。方法在类定义中定义的函数通过实例访问时成为绑定方法通过类访问时成为非绑定方法在Python 3中它就是一个普通函数。生成器函数使用yield的函数调用后返回一个生成器对象。虽然生成器对象本身也是可迭代的但最初对生成器函数的调用是标准的函数调用。# 示例不同类型的可调用对象 def ordinary_function(x): return x * 2 class MyClass: def method(self): return ‘instance method‘ classmethod def class_method(cls): return ‘class method‘ staticmethod def static_method(): return ‘static method‘ def __call__(self): return ‘instance called!‘ print(callable(ordinary_function)) # True print(callable(MyClass)) # True - 类是可调用的 obj MyClass() print(callable(obj.method)) # True - 绑定方法 print(callable(MyClass.method)) # True - 在Python 3中这是普通函数 print(callable(obj)) # True - 因为定义了 __call__ print(callable(print)) # True - 内置函数注意callable()在Python 3.2以后的行为更精确。在早期版本中一些没有__call__的对象也可能返回True但现在它主要检查对象是否具有__call__属性。2.2 函数与方法的底层表示理解它们底层如何表示有助于看清调用的本质。每个用户自定义函数都有一些特殊的属性__name__: 函数名。__module__: 定义该函数的模块名。__code__: 编译后的字节码对象包含实际的指令。__defaults__: 包含默认参数值的元组。__kwdefaults__: 包含仅关键字参数默认值的字典。__annotations__: 包含参数和返回类型注解的字典。方法则是一种包装器。当你通过实例obj.method访问时Python创建了一个绑定方法对象。这个对象内部存储了两个关键引用一是底层实现函数即你在类定义中写的def method(self): ...二是该实例本身obj。当你调用这个绑定方法时它会自动将存储的实例作为第一个参数self传递给底层函数。class MyClass: def func(self, value): return self, value obj MyClass() bound_method obj.func # 获取绑定方法 print(bound_method) # 输出: bound method MyClass.func of __main__.MyClass object at ... print(bound_method.__self__ is obj) # True 绑定了实例obj print(bound_method.__func__ is MyClass.func) # True 指向类中的原始函数 # 调用绑定方法等价于 result1 bound_method(‘test‘) # 自动传递了 obj 作为 self result2 MyClass.func(obj, ‘test‘) # 手动传递实例 print(result1 result2) # True而通过类直接访问MyClass.func在Python 3中你得到的就是一个普通的函数对象它没有被绑定到任何实例因此调用时必须显式提供self参数。3. 调用约定的深度剖析调用约定简单说就是“调用一个函数时参数是如何传递和处理的”。Python提供了极其灵活的参数传递机制这既是其强大之处也是初学者容易困惑的地方。3.1 参数传递的四种形式Python函数参数主要分为四类其定义和调用顺序是固定的位置参数最常见的参数按顺序传递。默认参数在函数定义时赋予默认值调用时可省略。可变位置参数使用*args收集多余的位置参数得到一个元组。可变关键字参数使用**kwargs收集多余的关键字参数得到一个字典。仅关键字参数在*args或单个*之后定义的参数必须通过关键字指定。定义顺序必须为(位置参数, 默认参数, *args, 仅关键字参数, **kwargs)。def complex_func(a, b10, *args, c, d20, **kwargs): 一个包含所有参数类型的复杂函数示例 print(f‘a{a}, b{b}‘) print(f‘args{args}‘) print(f‘c{c}, d{d}‘) print(f‘kwargs{kwargs}‘) # 合法调用 complex_func(1, 2, 3, 4, c5, extra‘hello‘) # 输出: # a1, b2 # args(3, 4) # c5, d20 # kwargs{‘extra‘: ‘hello‘} # 另一个调用 complex_func(1, c30) # b使用默认值10args为空d使用默认值203.2 参数解包*和**操作符的妙用调用时的*和**操作符是参数传递的“语法糖”它们分别将序列列表、元组等和映射字典解包为位置参数和关键字参数。这个特性在函数转发、装饰器和可变参数处理中极其有用。def func(a, b, c, dNone): print(a, b, c, d) # 传统传参 func(1, 2, 3, 4) # 使用解包 args_list [1, 2, 3] func(*args_list, d4) # 等价于 func(1, 2, 3, d4) kwargs_dict {‘b‘: 2, ‘a‘: 1, ‘c‘: 3, ‘d‘: 4} func(**kwargs_dict) # 等价于 func(a1, b2, c3, d4) # 混合使用 func(*[1, 2], **{‘c‘: 3, ‘d‘: 4})一个高级技巧在类继承或包装器中我们经常需要将接收到的所有参数原封不动地传递给另一个函数。这时*args, **kwargs就成了标准模式。class Base: def __init__(self, x, y, **options): self.x x self.y y self.options options class Derived(Base): def __init__(self, z, *args, **kwargs): self.z z # 将收到的args和kwargs全部传递给父类的__init__ super().__init__(*args, **kwargs) obj Derived(z‘new‘, x1, y2, color‘red‘, size‘large‘) print(obj.x, obj.y, obj.z, obj.options) # 输出: 1 2 new {‘color‘: ‘red‘, ‘size‘: ‘large‘}实操心得在设计接收大量配置参数的函数或类时我倾向于将核心的、必需的参数定义为位置参数或关键字参数而将大量可选的、配置性的参数收集到一个**kwargs字典中。这样既保持了函数签名的清晰又提供了极大的灵活性。后续可以通过kwargs.get(‘option‘, default)来安全地获取可选值。3.3 函数签名与inspect模块Python的inspect模块是内省查看对象内部信息的瑞士军刀。对于调用约定我们可以用inspect.signature()来动态获取和分析函数的签名。import inspect def example(a: int, b: str ‘hello‘, *args: float, c: bool, d: int 100, **kwargs: str): pass sig inspect.signature(example) print(sig) # 输出: (a:int, b:str‘hello‘, *args:float, c:bool, d:int100, **kwargs:str) # 遍历参数 for name, param in sig.parameters.items(): print(f‘{name}: kind{param.kind}, default{param.default}, annotation{param.annotation}‘) # param.kind 的取值可以是 # POSITIONAL_ONLY, POSITIONAL_OR_KEYWORD, VAR_POSITIONAL, KEYWORD_ONLY, VAR_KEYWORD # 动态绑定参数 bound_args sig.bind(1, ‘world‘, 1.5, 2.5, cFalse, extra‘info‘) print(bound_args.arguments) # 输出一个有序字典包含参数名到实参的映射 # {‘a‘: 1, ‘b‘: ‘world‘, ‘args‘: (1.5, 2.5), ‘c‘: False, ‘kwargs‘: {‘extra‘: ‘info‘}} # 注意d 使用了默认值所以不在arguments中这个功能在编写框架时非常强大。例如你可以创建一个装饰器自动验证传入函数的参数类型是否与注解匹配或者根据签名自动从配置字典中填充参数。4. 绑定约定的实现机制绑定约定是Python将方法与特定实例或类关联起来的规则。这是面向对象编程中self和cls自动传递的魔法来源。4.1 描述符协议绑定的基石Python的方法绑定功能其核心是描述符协议。描述符是实现了__get__、__set__或__delete__方法的类。当一个类属性被访问时Python会检查这个属性是否是一个描述符。函数对象用def定义的就是一个非数据描述符它只实现了__get__方法。# 描述符的简单示例 class Descriptor: def __get__(self, obj, objtypeNone): print(f‘__get__ called: obj{obj}, type{objtype}‘) return ‘value from descriptor‘ class MyClass: attr Descriptor() obj MyClass() print(obj.attr) # 触发 Descriptor.__get__(descriptor_instance, obj, MyClass) # 输出: # __get__ called: obj__main__.MyClass object at ..., typeclass ‘__main__.MyClass‘ # value from descriptor print(MyClass.attr) # 触发 Descriptor.__get__(descriptor_instance, None, MyClass) # 输出: # __get__ called: objNone, typeclass ‘__main__.MyClass‘ # value from descriptor当一个函数被定义在类体内时它作为一个描述符存在。通过实例访问它obj.method会触发其__get__方法该方法返回一个绑定方法对象这个对象内部存储了函数本身__func__和实例__self__。通过类访问它MyClass.method同样触发__get__但此时obj参数为None返回的要么是函数本身Python 3要么是一个未绑定的方法对象Python 2。4.2 方法类型详解实例方法、类方法与静态方法Python类中定义的方法有三种它们的绑定行为各不相同方法类型装饰器第一个参数绑定对象访问方式主要用途实例方法无self(实例引用)实例obj.method()操作实例的属性和状态。这是最常用的方法。类方法classmethodcls(类引用)类Class.method()或obj.method()操作类属性或作为替代构造函数。静态方法staticmethod无无不绑定Class.method()或obj.method()逻辑上属于类但不需访问实例或类状态的工具函数。class MyClass: class_attr ‘class‘ def __init__(self, value): self.instance_attr value def instance_method(self): # 可以访问实例和类属性 return f‘instance: self.instance_attr{self.instance_attr}, class_attr{self.class_attr}‘ classmethod def class_method(cls): # 只能访问类属性不能访问实例属性因为没有self return f‘class: cls.class_attr{cls.class_attr}‘ staticmethod def static_method(): # 既不能访问实例属性也不能访问类属性没有self或cls return ‘static: just a utility function‘ obj MyClass(‘instance‘) # 调用实例方法 print(obj.instance_method()) # 自动传递 obj 给 self # print(MyClass.instance_method()) # 错误缺少self参数 # 调用类方法 print(MyClass.class_method()) # 自动传递 MyClass 给 cls print(obj.class_method()) # 同样自动传递 MyClass 给 cls而不是 obj # 调用静态方法 print(MyClass.static_method()) # 不传递任何特殊参数 print(obj.static_method()) # 同样不传递任何特殊参数关键理解点classmethod装饰器本质上是创建了一个不同的描述符其__get__方法返回的是一个绑定到类的方法对象而不是实例。staticmethod装饰器则创建了一个非描述符它直接返回底层函数阻止了绑定过程。4.3 属性访问顺序与__getattribute__当你在一个实例上访问obj.method时Python遵循一个特定的属性解析顺序这由__getattribute__方法控制。默认的__getattribute__实现大致遵循以下步骤检查该属性是否在对象的__dict__中。检查该属性是否在对象类的__dict__中。如果找到的是一个描述符比如函数则调用其__get__方法这就是方法绑定的发生点。沿着类的继承链MRO向上查找。如果都没找到则调用__getattr__如果定义了。如果还没找到抛出AttributeError。你可以重写__getattribute__来完全自定义属性访问行为但这需要非常小心因为它会拦截所有属性访问。class LoggingAccess: def __init__(self, value): self.value value def __getattribute__(self, name): print(f‘Accessing attribute: {name}‘) # 必须通过object类的__getattribute__来避免递归调用 return object.__getattribute__(self, name) def method(self): return self.value * 2 obj LoggingAccess(5) print(obj.value) # 会打印 “Accessing attribute: value“ print(obj.method) # 会打印 “Accessing attribute: method“然后返回一个绑定方法对象 print(obj.method()) # 先访问method再调用调用时又会访问self.value5. 高级应用与性能考量理解了基础机制后我们可以看看这些知识如何应用于高级场景以及它们对性能的影响。5.1 使用functools.partial与lambda进行手动绑定有时我们需要将一个函数“预绑定”一些参数创建出一个新的可调用对象。functools.partial和lambda是两种常用工具但它们有细微差别。functools.partial: 返回一个部分应用了参数的新函数。它效率较高且能保留原函数的元信息如__name__,__doc__。lambda: 创建一个匿名函数。在绑定简单场景时很简洁但复杂的lambda可读性差且不保留元信息。import functools def power(base, exponent): 计算幂 return base ** exponent # 使用 partial 创建平方函数 square functools.partial(power, exponent2) print(square(5)) # 25 print(square.__name__) # ‘power‘ (partial保留了原函数名但显示为‘power‘) print(square.func) # function power at ... print(square.args, square.keywords) # () {‘exponent‘: 2} # 使用 lambda 创建立方函数 cube lambda base: power(base, exponent3) print(cube(3)) # 27 # lambda 没有有意义的 __name__ # 在回调函数中的应用 def process_data(data, callback): result [callback(item) for item in data] return result data [1, 2, 3, 4] # 使用 partial 预绑定参数 add_five functools.partial(lambda x, y: x y, y5) result1 process_data(data, add_five) # [6,7,8,9] # 对比 lambda result2 process_data(data, lambda x: x 5) # 效果相同选择建议如果只是简单的单行操作lambda很便捷。如果需要固定多个参数、希望保留函数文档或进行更复杂的函数操作partial是更专业的选择。5.2 方法解析顺序与多重继承下的绑定在多重继承中方法绑定变得复杂因为需要确定从哪个父类查找方法。Python使用C3线性化算法来计算一个类的方法解析顺序。你可以通过ClassName.__mro__或ClassName.mro()查看。class A: def method(self): return ‘A‘ class B(A): def method(self): return ‘B‘ class C(A): def method(self): return ‘C‘ class D(B, C): pass print(D.__mro__) # 输出: (class ‘__main__.D‘, class ‘__main__.B‘, class ‘__main__.C‘, class ‘__main__.A‘, class ‘object‘) obj D() print(obj.method()) # 输出: ‘B‘ # 查找顺序D - B - C - A。在B中找到了所以调用B.method。MRO确保了继承关系的一致性和可预测性。在设计复杂的类体系时理解MRO至关重要尤其是在使用super()进行协作式多重继承时。super()并不是简单地调用父类方法而是按照__mro__顺序调用下一个类的方法。5.3 性能影响与优化建议方法调用在Python中是有开销的。每次通过实例调用方法都需要进行属性查找可能触发描述符协议并创建绑定方法对象尽管这个对象有时会被缓存。对于在紧密循环中调用的方法这个开销可能变得显著。优化技巧将方法赋值给局部变量在循环开始前将频繁调用的方法绑定到局部变量避免每次循环都进行属性查找。# 较慢的写法 for item in large_list: processed obj.transform(item) # 每次循环都查找 obj.transform # 较快的写法 transform_func obj.transform # 提前完成查找和绑定 for item in large_list: processed transform_func(item) # 直接调用绑定方法谨慎使用propertyproperty装饰器将方法转换为属性描述符每次访问都会调用一个函数。如果这个计算很重又被频繁访问考虑将结果缓存到实例变量中。class ExpensiveComputation: def __init__(self, data): self._data data self._result_cache None # 缓存 property def result(self): if self._result_cache is None: print(‘Performing heavy computation...‘) self._result_cache sum(x**2 for x in self._data) # 模拟重计算 return self._result_cache obj ExpensiveComputation(range(1000)) print(obj.result) # 第一次计算 print(obj.result) # 第二次直接返回缓存不会打印使用__slots__对于拥有大量实例的类使用__slots__可以显著减少内存占用并略微提升属性访问速度。但它会禁止动态创建新属性并影响某些高级特性如弱引用。class PointWithSlots: __slots__ (‘x‘, ‘y‘) # 固定允许的属性名 def __init__(self, x, y): self.x x self.y y class PointRegular: def __init__(self, x, y): self.x x self.y y # PointWithSlots 的实例没有 __dict__内存更小访问 x, y 稍快。 # PointRegular 的实例有 __dict__可以动态添加属性但内存开销大。6. 实战构建一个简单的RPC框架模拟让我们综合运用调用和绑定的知识模拟一个极简的远程过程调用框架的核心。在这个框架中客户端可以“透明地”调用服务器端对象的方法仿佛它们在本地一样。6.1 设计思路服务端维护一个注册表将服务名映射到实际的对象。客户端存根创建一个代理对象。当调用这个代理对象的方法时它并不本地执行而是将方法名和参数序列化通过网络发送给服务器。服务器端骨架接收请求反序列化根据服务名找到对应的对象利用Python强大的内省和调用机制getattr,callable,inspect.signature.bind来安全地调用对应的方法然后将结果序列化发回。绑定模拟客户端存根需要模拟方法绑定的行为即让proxy.method(arg1, arg2)能够工作。6.2 核心代码实现以下是高度简化的概念验证代码省略了实际的网络传输和序列化专注于方法调用和绑定的模拟。import inspect class RemoteService: 服务器端的一个简单服务 def add(self, a, b): return a b def greet(self, name, title‘Mr.‘): return f‘Hello, {title} {name}!‘ class ClientStub: 客户端存根模拟远程对象 def __init__(self, service_name, transport): self._service_name service_name self._transport transport # 模拟网络传输的对象 def __getattr__(self, method_name): 当访问一个不存在的属性时返回一个可调用对象。 这是模拟方法绑定的关键 def remote_method(*args, **kwargs): # 1. 准备请求 request { ‘service‘: self._service_name, ‘method‘: method_name, ‘args‘: args, ‘kwargs‘: kwargs } # 2. “发送”请求这里用打印模拟 print(f‘[Client] Calling remote: {request}‘) # 模拟网络发送和接收 response self._transport.send_and_receive(request) # 3. 返回响应 return response[‘result‘] return remote_method class ServerSkeleton: 服务器端骨架处理请求 def __init__(self): self._services {} # 服务注册表 def register_service(self, name, obj): self._services[name] obj def handle_request(self, request): service_name request[‘service‘] method_name request[‘method‘] args request[‘args‘] kwargs request[‘kwargs‘] # 1. 获取服务对象 service_obj self._services.get(service_name) if not service_obj: return {‘error‘: f‘Service {service_name} not found‘} # 2. 获取方法 method getattr(service_obj, method_name, None) if not method or not callable(method): return {‘error‘: f‘Method {method_name} not callable‘} # 3. 可选使用inspect进行参数绑定验证更安全 try: sig inspect.signature(method) bound_args sig.bind(*args, **kwargs) bound_args.apply_defaults() # 应用默认参数 # 4. 实际调用 result method(*bound_args.args, **bound_args.kwargs) return {‘result‘: result} except TypeError as e: return {‘error‘: f‘Invalid arguments: {e}‘} class MockTransport: 模拟网络传输 def __init__(self, server): self.server server def send_and_receive(self, request): # 模拟网络往返直接交给服务器处理 return self.server.handle_request(request) # 模拟运行 if __name__ ‘__main__‘: # 服务器端设置 server ServerSkeleton() service RemoteService() server.register_service(‘calc‘, service) # 客户端设置 transport MockTransport(server) client_proxy ClientStub(‘calc‘, transport) # 客户端“透明”调用 print(client_proxy.add(10, 20)) # 看起来像本地调用 print(client_proxy.greet(‘Alice‘)) print(client_proxy.greet(‘Bob‘, title‘Dr.‘)) # 输出示例 # [Client] Calling remote: {‘service‘: ‘calc‘, ‘method‘: ‘add‘, ‘args‘: (10, 20), ‘kwargs‘: {}} # 30 # [Client] Calling remote: {‘service‘: ‘calc‘, ‘method‘: ‘greet‘, ‘args‘: (‘Alice‘,), ‘kwargs‘: {}} # Hello, Mr. Alice! # [Client] Calling remote: {‘service‘: ‘calc‘, ‘method‘: ‘greet‘, ‘args‘: (‘Bob‘,), ‘kwargs‘: {‘title‘: ‘Dr.‘}} # Hello, Dr. Bob!6.3 关键点分析__getattr__魔法方法ClientStub的核心。当客户端代码尝试访问client_proxy.add时由于client_proxy实例没有add属性Python会调用__getattr__(‘add‘)。这个方法返回一个预先定义好的remote_method函数。这就模拟了从类中获取方法的过程。闭包remote_method函数是一个闭包它记住了创建时的method_name、self._service_name和self._transport。这使得每个“远程方法”都携带了必要的上下文信息。动态调用与安全服务器端的handle_request使用getattr动态获取方法并使用inspect.signature来验证和绑定参数。这是一种比直接method(*args, **kwargs)更安全的方式因为它会检查参数数量、关键字名称等更接近Python解释器本身的调用检查。绑定约定的应用整个框架的透明性就建立在模拟Python本地的绑定约定之上。用户感觉像是在调用本地对象的方法但实际上触发了一系列复杂的远程通信过程。这个例子展示了对Python调用和绑定机制的深刻理解能够让你设计出非常强大和优雅的API与框架。许多流行的RPC库如gRPC的Python实现和分布式计算框架其底层原理都与此类似。7. 常见陷阱与调试技巧即使理解了原理在实际编码中仍会遇到一些坑。这里记录几个我踩过的以及如何排查。7.1 可变默认参数的经典陷阱这是Python中最著名的陷阱之一。默认参数的值在函数定义时被计算并绑定而不是在每次调用时。def append_to_list(value, my_list[]): # 危险默认列表在定义时创建 my_list.append(value) return my_list print(append_to_list(1)) # [1] print(append_to_list(2)) # [1, 2] 意外地共享了同一个列表 print(append_to_list(3, [])) # [3] 传入新列表工作正常正确做法使用None作为哨兵值在函数内部创建可变对象。def append_to_list_safe(value, my_listNone): if my_list is None: my_list [] my_list.append(value) return my_list7.2 在类中定义装饰器时丢失self在类内部定义装饰器并应用于其他方法时容易忘记处理self。class MyClass: def decorator(func): def wrapper(*args, **kwargs): print(‘Decorator called‘) return func(*args, **kwargs) return wrapper decorator # 错误decorator被当成了普通函数而不是方法 def method(self): return ‘ok‘ # 调用 MyClass().method() 会出错因为wrapper收到的第一个参数是实例self # 但func期望的是被装饰的method而method需要self。解决方案将装饰器定义为类方法或静态方法或者确保它能正确处理第一个参数。class MyClass: staticmethod # 将其定义为静态方法因为它不依赖实例 def decorator(func): def wrapper(*args, **kwargs): print(‘Decorator called‘) return func(*args, **kwargs) return wrapper decorator def method(self): return ‘ok‘7.3 使用super()时的参数传递super()在调用父类方法时会自动传递当前实例self和当前类cls。但如果你手动调用父类方法如ParentClass.method(self)或者在使用partial或包装器时容易漏掉self。class Parent: def func(self, x): return x * 2 class Child(Parent): def func(self, x): # 正确使用 super result super().func(x) # 不需要显式传递self return result 1 def wrong_call(self, x): # 错误直接调用父类方法时漏掉了self # return Parent.func(x) # TypeError # 正确 return Parent.func(self, x)7.4 调试技巧使用inspect追踪调用当遇到复杂的调用错误时inspect模块是你的好朋友。import inspect def problematic_func(a, b, c‘default‘): frame inspect.currentframe() args_info inspect.getargvalues(frame) print(‘Function name:‘, args_info.function) print(‘Args:‘, args_info.args) print(‘Locals:‘, args_info.locals) # 查看调用时的局部变量即参数值 return locals() # 返回所有局部变量 # 调用它看看参数是如何被绑定的 print(problematic_func(1, 2, c‘override‘))此外在IPython或Jupyter中可以使用%debug魔法命令在异常发生后进入调试器然后使用u(up) 和d(down) 查看调用栈用args查看当前函数的参数这对于理解多层调用中的绑定问题非常有效。理解Python的调用与绑定约定就像是拿到了语言的底层地图。它不会让你立刻写出更炫酷的代码但会让你在遇到诡异Bug时能迅速定位在设计复杂系统时能做出更优雅、更高效的选择。从描述符协议到MRO从*args解包到super()的协作这些机制共同构成了Python动态性和表现力的基石。我个人的体会是每深入理解一层就对“Pythonic”这个词多一分敬畏写代码时也更多一分从容和自信。下次当你再看到self或者定义一个装饰器时不妨想想背后发生的这些故事。