Python 方法绑定机制深度解析：为什么实例方法会自动绑定 `self`？

Python 方法绑定机制深度解析：为什么实例方法会自动绑定self？

在 Python 编程中，我们每天都在写这样的代码：

classUser:defsay_hello(self):print("Hello")u=User()u.say_hello()

初学者常常会疑惑：say_hello明明定义了一个参数self，调用时为什么不用写u.say_hello(u)？而资深开发者进一步会问：这个“自动绑定”到底发生在什么时候？它是解释器的特殊语法规则，还是对象模型中的通用机制？

答案非常关键：实例方法自动绑定self，不是因为self是关键字，也不是因为函数定义在类里就天然带对象，而是因为 Python 的函数对象实现了描述符协议。

理解这一点，你会真正看懂 Python 面向对象的底层逻辑，也会更容易理解property、classmethod、staticmethod、ORM 字段、装饰器、元编程以及框架源码。

Python 自 1991 年前后公开发展以来，一直以简洁、清晰、可组合著称；官方 FAQ 也提到，Python 的稳定版本长期持续发布，并逐渐形成成熟生态。(Python documentation) 到 2026 年 6 月，TIOBE 指数中 Python 仍排在第 1 位，评分为 18.96%；Stack Overflow 2025 开发者调查也提到，Python 从 2024 到 2025 的采用率增加了 7 个百分点，尤其受 AI、数据科学和后端开发推动。(TIOBE) (survey.stackoverflow.co)

但越流行的语言，越容易被“只会用、不懂底层”。今天我们就把self自动绑定这件事讲透。

一、先从一个最普通的例子开始

看下面这段代码：

classAccount:defdeposit(self,amount):self.balance+=amount account=Account()account.balance=100account.deposit(50)print(account.balance)# 150

我们调用的是：

account.deposit(50)

但deposit定义时有两个参数：

defdeposit(self,amount):

为什么没有报错？

因为 Python 在调用实例方法时，会自动把account作为第一个参数传进去。换句话说，下面两种写法本质等价：

account.deposit(50)Account.deposit(account,50)

官方数据模型文档也明确说明：当实例方法对象被调用时，底层函数会被调用，并把实例对象插入到参数列表最前面；例如x.f(1)等价于C.f(x, 1)。(Python documentation)

这就是self自动绑定的表层答案。

但真正的问题是：Python 是什么时候把account塞进去的？

二、self不是关键字，只是约定

先澄清一个常见误区：self不是 Python 关键字。

你完全可以这样写：

classDog:defbark(this):print("Woof!",this)d=Dog()d.bark()

这段代码可以正常运行。

因为 Python 只关心“第一个参数”，不关心它叫什么。官方教程也说明，方法的第一个参数通常叫self，但这只是约定，self这个名字对 Python 没有特殊含义。(Python documentation)

不过在真实项目中，强烈建议永远使用self。因为 Python 社区、代码审查工具、IDE、文档生成器和开发者习惯都默认这个约定。你可以不遵守，但团队同事可能会在心里默默给你的代码减分。

三、函数放进类以后，发生了什么？

先看一个实验：

classUser:defhello(self):return"hello"print(User.__dict__["hello"])

输出类似：

<function User.hello at 0x...>

也就是说，类字典里存放的hello本质上还是一个普通函数对象。

再看：

u=User()print(User.hello)print(u.hello)

输出大致是：

<function User.hello at 0x...><bound method User.hello of<__main__.Userobjectat 0x...>>

重点来了：

User.hello

拿到的是函数。

u.hello

拿到的是绑定方法。

这说明，同一个名字hello，通过类访问和通过实例访问，返回的对象是不一样的。

这背后就是描述符协议。

四、描述符协议：方法绑定的真正幕后英雄

Python 官方描述符指南指出，描述符会在点号属性查找时被触发，而函数变成绑定方法，正是描述符机制的应用之一；classmethod()、staticmethod()、property()和functools.cached_property()也都基于描述符实现。(Python documentation)

所谓描述符，就是实现了下面这些方法之一的对象：

__get__(self,instance,owner)__set__(self,instance,value)__delete__(self,instance)

而 Python 中的普通函数对象，实现了__get__。

我们可以验证：

classUser:defhello(self):return"hello"func=User.__dict__["hello"]print(hasattr(func,"__get__"))# True

当你写：

u.hello

Python 大致会做这样的事：

func=User.__dict__["hello"]method=func.__get__(u,User)

这个method就是绑定方法对象。

你可以手动调用：

classUser:defhello(self,name):returnf"Hello,{name}. I am{self}"u=User()func=User.__dict__["hello"]bound_method=func.__get__(u,User)print(bound_method("Alice"))

这和下面写法等价：

u.hello("Alice")

也就是说，self并不是在函数定义时自动生成的，而是在属性访问阶段被绑定的。

五、绑定方法对象里藏着什么？

绑定方法不是玄学对象，它有两个非常重要的属性：

__self__ __func__

看代码：

classUser:defhello(self,name):returnf"Hello,{name}"u=User()m=u.helloprint(m.__self__)print(m.__func__)

输出类似：

<__main__.Userobjectat 0x...><function User.hello at 0x...>

其中：

m.__self__

保存的是被绑定的实例，也就是u。

m.__func__

保存的是原始函数，也就是User.hello。

Python 标准类型文档说明，通过实例访问类命名空间中的函数时，会得到一个绑定方法对象；调用该对象时，它会把self加入参数列表，并且m(arg1, ..., argn)等价于m.__func__(m.__self__, arg1, ..., argn)。(Python documentation)

所以：

u.hello("Alice")

可以展开为：

m=u.hello m.__func__(m.__self__,"Alice")

再展开就是：

User.hello(u,"Alice")

这就是self自动绑定的完整真相。

六、用纯 Python 模拟绑定方法

为了让这个机制更直观，我们自己实现一个迷你版绑定方法。

classMethodType:def__init__(self,func,obj):self.__func__=func self.__self__=objdef__call__(self,*args,**kwargs):returnself.__func__(self.__self__,*args,**kwargs)

再实现一个迷你函数描述符：

classFunctionLike:def__init__(self,func):self.func=funcdef__get__(self,instance,owner):ifinstanceisNone:returnself.funcreturnMethodType(self.func,instance)

使用它：

defraw_hello(self,name):returnf"{self.name}says hello to{name}"classUser:hello=FunctionLike(raw_hello)def__init__(self,name):self.name=name u=User("Tom")print(u.hello("Alice"))print(User.hello(u,"Bob"))

输出：

Tom says hello to Alice Tom says hello to Bob

虽然真实 CPython 内部实现更复杂，但核心思想就是这样：

函数对象.__get__(实例, 类) → 绑定方法对象 绑定方法对象(...) → 原函数(实例, ...)

这也是 Python 设计优雅的地方：它没有为方法调用创造一套完全割裂的语法系统，而是通过统一的属性访问协议完成了方法绑定。

七、为什么函数放在实例上不会自动绑定？

看一个很容易踩坑的例子：

defhello(self):returnf"hello from{self}"classUser:passu=User()u.hello=helloprint(u.hello())

这段代码会报错：

TypeError:hello()missing1required positional argument:'self'

为什么？

因为hello被放进了实例字典：

u.__dict__["hello"]=hello

而描述符协议只会在对象作为类属性时发挥方法绑定作用。官方数据模型文档特别说明，用户自定义函数如果是类实例的属性，不会被转换为绑定方法；只有当函数是类属性时，才会发生这种转换。(Python documentation)

正确写法之一是：

importtypesdefhello(self):returnf"hello from{self}"classUser:passu=User()u.hello=types.MethodType(hello,u)print(u.hello())

types.MethodType可以手动创建绑定方法。

这在插件系统、动态 monkey patch、测试替身对象中偶尔有用，但业务代码中不要滥用，否则可读性会迅速下降。

八、staticmethod和classmethod为什么不一样？

理解了实例方法绑定，再看staticmethod和classmethod就清楚多了。

1. 普通实例方法

classDemo:defmethod(self):print("instance method",self)d=Demo()d.method()

调用时绑定实例：

Demo.method(d)

2. 静态方法

classDemo:@staticmethoddefmethod():print("static method")d=Demo()d.method()Demo.method()

静态方法不绑定实例，也不绑定类。它只是放在类命名空间里的普通函数，常用于和类概念相关、但不需要访问对象状态的工具函数。

3. 类方法

classDemo:@classmethoddefmethod(cls):print("class method",cls)d=Demo()d.method()Demo.method()

类方法绑定的是类对象，而不是实例对象。官方数据模型文档说明，当从类或实例获取classmethod对象创建方法时，其__self__是类本身。(Python documentation)

可以用下面的示意图记忆：

访问方式 自动绑定对象 -------------------------------- obj.method() obj Class.method(obj) 手动传 obj obj.static() 不绑定 obj.class_method() Class Class.class_method() Class

实践建议：

需要访问实例状态：用实例方法 需要访问类状态或构造替代构造器：用 classmethod 只是逻辑上归属于这个类：用 staticmethod

九、实战案例：用绑定机制设计一个插件系统

假设我们要写一个简单的数据清洗框架。每个清洗器都有自己的规则：

classCleaner:defstrip(self,text):returntext.strip()deflower(self,text):returntext.lower()defremove_comma(self,text):returntext.replace(",","")

现在我们希望按配置动态调用方法：

defrun_pipeline(cleaner,text,steps):forstepinsteps:func=getattr(cleaner,step)text=func(text)returntext cleaner=Cleaner()result=run_pipeline(cleaner," Hello, PYTHON ",["strip","lower","remove_comma"],)print(result)# hello python

这里的关键是：

func=getattr(cleaner,step)

拿到的不是普通函数，而是已经绑定了cleaner的方法对象。因此后面只需要传业务参数：

text=func(text)

如果你改成从类上取方法：

func=getattr(Cleaner,step)text=func(cleaner,text)

就必须手动传入实例。

这个机制在很多框架里都很常见：路由分发、命令模式、任务调度、测试框架、ORM 钩子函数，都大量依赖“按名字查找方法，然后调用绑定方法”。

十、常见错误一：忘记写self

初学者最常见的错误：

classUser:defhello():print("hello")u=User()u.hello()

报错：

TypeError:hello()takes0positional arguments but1was given

原因不是 Python 多传了一个“奇怪参数”，而是它正确地把u绑定进去了。只是你的方法定义没有接收它。

正确写法：

classUser:defhello(self):print("hello")

如果这个方法确实不需要实例状态，可以声明为静态方法：

classUser:@staticmethoddefhello():print("hello")

十一、常见错误二：把实例方法当函数传递时误判参数

看这个例子：

classCalculator:defadd(self,x,y):returnx+y calc=Calculator()tasks=[calc.add,]fortaskintasks:print(task(1,2))

这里task已经是绑定方法，所以调用时只需要传x和y。

但如果你保存的是类方法函数：

tasks=[Calculator.add,]fortaskintasks:print(task(calc,1,2))

这时必须手动传入calc。

工程中写回调、事件系统、装饰器时尤其要注意：你拿到的到底是函数对象，还是绑定方法对象。

可以这样调试：

importinspectprint(inspect.ismethod(calc.add))# Trueprint(inspect.isfunction(calc.add))# Falseprint(inspect.ismethod(Calculator.add))# Falseprint(inspect.isfunction(Calculator.add))# True

十二、常见错误三：装饰器破坏方法签名

装饰器如果写得不好，也会影响实例方法。

错误示例：

deflog(func):defwrapper():print("calling...")returnfunc()returnwrapperclassService:@logdefrun(self):print("running")s=Service()s.run()

这会报错，因为wrapper没有接收self。

正确写法：

fromfunctoolsimportwrapsdeflog(func):@wraps(func)defwrapper(*args,**kwargs):print(f"calling{func.__name__}...")returnfunc(*args,**kwargs)returnwrapperclassService:@logdefrun(self):print("running")s=Service()s.run()

为什么*args能解决？因为绑定方法调用时，实例对象会作为第一个参数进入wrapper。也就是说：

s.run()

实际相当于：

wrapper(s)

所以装饰器必须能接住这个参数。

十三、性能与最佳实践：绑定方法会不会很慢？

每次访问：

obj.method

都会创建或返回一个方法对象。通常这点开销非常小，不需要担心。

但在极端高频循环中，可以把绑定方法提到循环外：

items=[" A "," B "," C "]strip=str.strip result=[strip(item)foriteminitems]

或者：

classProcessor:defhandle(self,item):returnitem*2defrun(self,items):handle=self.handlereturn[handle(item)foriteminitems]

这既能略微减少属性查找，也能让意图更清晰。

不过请记住：绝大多数业务代码中，优先考虑可读性。只有在性能剖析确认瓶颈后，再做这种微优化。

十四、方法绑定与架构设计：别小看这个细节

当你理解self自动绑定后，很多框架设计会豁然开朗。

例如 Web 框架中常见的类视图：

classUserView:defget(self,request):return{"method":"GET"}defpost(self,request):return{"method":"POST"}defdispatch(view,request):handler=getattr(view,request["method"].lower())returnhandler(request)view=UserView()print(dispatch(view,{"method":"GET"}))print(dispatch(view,{"method":"POST"}))

getattr(view, "get")返回绑定方法，所以handler(request)不需要再传view。

这就是面向对象分发的基本形态：

请求进入 ↓ 根据名称查找实例方法 ↓ 自动绑定当前对象 ↓ 调用业务参数 ↓ 返回结果

如果用 Mermaid 表示：

这背后体现了 Python 的一个重要哲学：对象行为不靠繁重语法堆砌，而靠统一协议组合出来。

十五、总结：一句话讲清self自动绑定

实例方法之所以会自动绑定self，是因为：

定义在类中的函数对象是描述符； 通过实例访问该函数时，会触发函数对象的 __get__； __get__ 返回绑定方法对象； 绑定方法对象保存了实例 __self__ 和原函数 __func__； 调用绑定方法时，会自动把 __self__ 插入参数列表最前面。

所以：

obj.method(a,b)

本质上等价于：

Class.method(obj,a,b)

但这只在函数作为类属性被实例访问时发生。如果函数被直接放到实例属性上，它不会自动绑定。

理解这个机制，你就不只是“会写 Python 类”，而是真的理解了 Python 对象模型的运转方式。

下一次当你写下：

self.name=name self.save()self.validate()

不妨停一秒想想：这个小小的self，连接的是对象状态、类命名空间、描述符协议和 Python 整个面向对象体系。

这也是 Python 最迷人的地方：表面温柔，底层锋利；入门简单，深入无穷。

互动问题

你在日常开发中有没有遇到过这些问题？

• 为什么obj.method和Class.method打印结果不一样？
• 为什么忘写self会提示“多传了一个参数”？
• 为什么装饰器一套上实例方法就报错？
• 你是否在框架源码中见过__get__、__self__、__func__？

欢迎在评论区分享你的踩坑经历。真正的 Python 编程成长，往往就藏在这些“看似理所当然”的细节里。

SEO 关键词建议

Python编程、Python教程、Python实战、Python最佳实践、Python实例方法、Python self、Python描述符、bound method、Python面向对象、Python底层机制。

推荐延伸阅读

建议继续阅读 Python 官方教程中的 Classes 章节、Python 数据模型文档、Descriptor HowTo Guide，以及《流畅的 Python》《Effective Python》《Python 编程：从入门到实践》等书籍。官方文档中对实例方法、绑定方法和描述符协议的解释，是理解框架源码和高级 Python 编程的核心基础。(Python documentation) (Python documentation)