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

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

class User:
    def say_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 自动绑定这件事讲透。

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

看下面这段代码：

class Account:
    def deposit(self, amount):
        self.balance += amount


account = Account()
account.balance = 100

account.deposit(50)

print(account.balance)  # 150

我们调用的是：

account.deposit(50)

但 deposit 定义时有两个参数：

def deposit(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 关键字。

你完全可以这样写：

class Dog:
    def bark(this):
        print("Woof!", this)


d = Dog()
d.bark()

这段代码可以正常运行。

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

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

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

先看一个实验：

class User:
    def hello(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__.User object at 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__。

我们可以验证：

class User:
    def hello(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 就是绑定方法对象。

你可以手动调用：

class User:
    def hello(self, name):
        return f"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__

看代码：

class User:
    def hello(self, name):
        return f"Hello, {name}"


u = User()
m = u.hello

print(m.__self__)
print(m.__func__)

输出类似：

<__main__.User object at 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 模拟绑定方法

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

class MethodType:
    def __init__(self, func, obj):
        self.__func__ = func
        self.__self__ = obj

    def __call__(self, *args, **kwargs):
        return self.__func__(self.__self__, *args, **kwargs)

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

class FunctionLike:
    def __init__(self, func):
        self.func = func

    def __get__(self, instance, owner):
        if instance is None:
            return self.func
        return MethodType(self.func, instance)

使用它：

def raw_hello(self, name):
    return f"{self.name} says hello to {name}"


class User:
    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 设计优雅的地方：它没有为方法调用创造一套完全割裂的语法系统，而是通过统一的属性访问协议完成了方法绑定。

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

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

def hello(self):
    return f"hello from {self}"


class User:
    pass


u = User()
u.hello = hello

print(u.hello())

这段代码会报错：

TypeError: hello() missing 1 required positional argument: 'self'

为什么？

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

u.__dict__["hello"] = hello

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

正确写法之一是：

import types


def hello(self):
    return f"hello from {self}"


class User:
    pass


u = User()
u.hello = types.MethodType(hello, u)

print(u.hello())

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

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

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

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

1. 普通实例方法

class Demo:
    def method(self):
        print("instance method", self)


d = Demo()
d.method()

调用时绑定实例：

Demo.method(d)

2. 静态方法

class Demo:
    @staticmethod
    def method():
        print("static method")


d = Demo()
d.method()
Demo.method()

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

3. 类方法

class Demo:
    @classmethod
    def method(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

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

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

class Cleaner:
    def strip(self, text):
        return text.strip()

    def lower(self, text):
        return text.lower()

    def remove_comma(self, text):
        return text.replace(",", "")

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

def run_pipeline(cleaner, text, steps):
    for step in steps:
        func = getattr(cleaner, step)
        text = func(text)
    return text


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

初学者最常见的错误：

class User:
    def hello():
        print("hello")


u = User()
u.hello()

报错：

TypeError: hello() takes 0 positional arguments but 1 was given

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

正确写法：

class User:
    def hello(self):
        print("hello")

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

class User:
    @staticmethod
    def hello():
        print("hello")

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

看这个例子：

class Calculator:
    def add(self, x, y):
        return x + y


calc = Calculator()

tasks = [
    calc.add,
]

for task in tasks:
    print(task(1, 2))

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

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

tasks = [
    Calculator.add,
]

for task in tasks:
    print(task(calc, 1, 2))

这时必须手动传入 calc。

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

可以这样调试：

import inspect


print(inspect.ismethod(calc.add))       # True
print(inspect.isfunction(calc.add))     # False

print(inspect.ismethod(Calculator.add)) # False
print(inspect.isfunction(Calculator.add)) # True

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

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

错误示例：

def log(func):
    def wrapper():
        print("calling...")
        return func()
    return wrapper


class Service:
    @log
    def run(self):
        print("running")


s = Service()
s.run()

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

正确写法：

from functools import wraps


def log(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"calling {func.__name__}...")
        return func(*args, **kwargs)
    return wrapper


class Service:
    @log
    def run(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) for item in items]

或者：

class Processor:
    def handle(self, item):
        return item * 2

    def run(self, items):
        handle = self.handle
        return [handle(item) for item in items]

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

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

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

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

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

class UserView:
    def get(self, request):
        return {"method": "GET"}

    def post(self, request):
        return {"method": "POST"}


def dispatch(view, request):
    handler = getattr(view, request["method"].lower())
    return handler(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)