python函数和方法的区别是什么

概要速览：Python 独立函数与绑定方法的核心特性对照

一、直观表现：定义形式与调用行为的区别

初学 Python 时，很多人容易将“在模块中用 def 定义的”称为函数，而将“在类中用 def 定义的”称为方法。从代码组织结构上看确实如此，但若要深入理解二者的运行机制，必须观察它们在被调用时的传参行为以及打印它们时输出的具体类型。

# 示例：独立函数与类方法的定义与打印对比
def standalone_greet(name):
    return f"Hello, {name}!"

class Greeter:
    def bound_greet(self, name):
        return f"Hello, {name} from {self}!"

# 1. 打印独立函数
print("独立函数：", standalone_greet)

# 2. 实例化类并打印实例方法
greeter_inst = Greeter()
print("实例方法：", greeter_inst.bound_greet)

# 3. 通过类名直接访问方法
print("通过类名访问：", Greeter.bound_greet)

# 示例输出：
独立函数： <function standalone_greet at 0x104ab2e10>
实例方法： <bound method Greeter.bound_greet of <__main__.Greeter object at 0x104b281f0>>
通过类名访问： <function Greeter.bound_greet at 0x104b280d0>

从上述运行结果可以观察到两个关键事实：

• 直接通过实例 greeter_inst.bound_greet 获取的是一个 bound method（绑定方法），其明确提示了该方法绑定到了具体的 Greeter object 内存地址。
• 通过类本身 Greeter.bound_greet 获取的依然是一个普通的 function（函数），并没有变成方法。这直接说明：在类内定义的函数本身仍然只是函数，只有当它通过具体的实例被访问时，才会被动态包装为方法。

图1：Python 独立函数与绑定方法的内部对象引用架构对比

二、底层机制：描述符协议与动态方法绑定

为什么通过实例访问函数会变成方法？背后的核心推手是 Python 的描述符协议（Descriptor Protocol）。

在 Python 中，所有函数对象内部都原生实现了 __get__() 方法，这意味着函数天然就是一个“非数据描述符（Non-data Descriptor）”。当程序通过点号表达式访问实例属性（如 obj.method）时，解释器会按固定顺序搜索属性：

1. 首先在实例自身的 obj.__dict__ 中寻找；
2. 若未找到，则在其实例的类 type(obj).__dict__ 及其基类中寻找；
3. 在类中找到同名属性后，如果该属性对象定义了 __get__() 方法，解释器就会自动调用该描述符：func.__get__(obj, type(obj))。

函数的 __get__ 方法执行时，如果传入的第一个参数（instance）不是 None，它就会创建一个 types.MethodType 实例，将该原始函数与调用者实例打包在一起。这个新生成的对象就是绑定方法（Bound Method）。

图2：描述符协议驱动函数向绑定方法转换的完整执行步骤

我们可以通过手动调用函数的描述符方法，清晰验证这个转换全过程：

# 示例：通过描述符手动生成绑定方法
class Calculator:
    def multiply(self, factor):
        return self.base * factor

calc = Calculator()
calc.base = 10

# 获取类中的原生函数
raw_func = Calculator.__dict__['multiply']
print("原生函数类型：", type(raw_func))

# 手动触发描述符协议：传入实例 calc
bound_m = raw_func.__get__(calc, Calculator)
print("转换后的类型：", type(bound_m))

# 检查绑定方法携带的内部引用
print("bound_m.__self__:", bound_m.__self__)
print("bound_m.__func__:", bound_m.__func__)

# 直接调用绑定方法：无需传 self
print("调用结果：", bound_m(5))

# 示例输出：
原生函数类型： <class 'function'>
转换后的类型： <class 'method'>
bound_m.__self__: <__main__.Calculator object at 0x105c317f0>
bound_m.__func__: <function Calculator.multiply at 0x105c31750>
调用结果： 50

绑定方法对象内部持有两个核心属性：__self__ 指向绑定的实例，__func__ 指向原本的底层函数。当执行 bound_m(5) 时，它内部实际上做的事情等价于 bound_m.__func__(bound_m.__self__, 5)。这就是 self 参数能够被隐式自动传递的秘密。

三、分类演进：普通方法、类方法与静态方法

在面向对象编程中，除了常规的实例方法，Python 还通过装饰器提供了 @classmethod 和 @staticmethod，它们对函数与方法的绑定性质产生了不同的改变：

• 实例方法（Instance Method）：默认定义方式。首参数必须保留为 self。通过实例访问时返回绑定到该实例的 method。
• 类方法（Class Method，使用 @classmethod）：使用 classmethod 描述符包装。无论是通过实例访问还是通过类名访问，其 __get__ 始终将该类对象作为宿主进行绑定，调用时自动传入 cls。因此它无论如何都是 method 类型。
• 静态方法（Static Method，使用 @staticmethod）：使用 staticmethod 描述符包装。它的特殊之处在于它的 __get__ 无论何时都原封不动地返回被包装的底层函数，不发生任何对象绑定。因此静态方法在本质上就是普通的 function，只是寄存在类的命名空间内。

# 示例：三种方法形态与普通函数的类型对比
import inspect

class Demo:
    def instance_method(self):
        pass

    @classmethod
    def class_method(cls):
        pass

    @staticmethod
    def static_method():
        pass

demo = Demo()

# 检查各对象在运行时究竟是函数还是方法
targets = [
    ("demo.instance_method", demo.instance_method),
    ("Demo.instance_method", Demo.instance_method),
    ("demo.class_method", demo.class_method),
    ("Demo.class_method", Demo.class_method),
    ("demo.static_method", demo.static_method),
    ("Demo.static_method", Demo.static_method),
]

for name, obj in targets:
    is_f = inspect.isfunction(obj)
    is_m = inspect.ismethod(obj)
    has_self = hasattr(obj, "__self__")
    print(f"{name:<22} | isfunction: {str(is_f):<5} | ismethod: {str(is_m):<5} | has __self__: {has_self}")

# 示例输出：
demo.instance_method   | isfunction: False | ismethod: True  | has __self__: True
Demo.instance_method   | isfunction: True  | ismethod: False | has __self__: False
demo.class_method      | isfunction: False | ismethod: True  | has __self__: True
Demo.class_method      | isfunction: False | ismethod: True  | has __self__: True
demo.static_method     | isfunction: True  | ismethod: False | has __self__: False
Demo.static_method     | isfunction: True  | ismethod: False | has __self__: False

图3：Python 运行时检测函数与方法的逻辑判定流程

四、容易混淆的地方与实战注意事项

理解函数与方法的区别，在工程开发中能够帮助我们避开以下几个经典陷阱：

1. 误区：类内部写的一切代码都是“方法”

在 Python 2 时代，通过类访问未绑定的方法会返回 unbound method。但在 Python 3 中，这一概念被彻底移除，未绑定的方法就是普通的 function。如果你直接用 Demo.instance_method() 调用，Python 会报 TypeError: missing 1 required positional argument: 'self'，因为此时它是普通函数，解释器不会自动寻找任何实例填补 self。

2. 回调函数与多线程任务中的传参问题

许多异步框架（如 threading.Thread、asyncio 或 GUI 事件监听）允许传入一个可调用对象（callable）作为 target。

• 如果你传递的是 demo.instance_method，这是一个已经绑定了 demo 实例的方法对象，调用时无需、也不能额外再把 demo 传给 args；
• 如果你错误地传递了 Demo.instance_method（函数），则必须在 args=(demo, ...) 中显式传入实例作为第一个参数。

3. 自定义装饰器丢失 self 的经典 Bug

编写函数装饰器时，如果不注意兼容类方法，容易造成参数不对齐。例如：

# 错误示例：仅考虑独立函数的简单装饰器
def broken_decorator(func):
    def wrapper():
        print("Before calling")
        return func()
    return wrapper

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

# 执行 Service().run() 会直接报错：
# TypeError: wrapper() takes 0 positional arguments but 1 was given
# 原因：run 变成了 wrapper 函数，当它作为方法被调用时，解释器自动注入了 self 实例，
# 但 wrapper 定义时未接收任何参数，从而抛出异常。

正确做法：编写通用装饰器时，包装层必须声明 *args, **kwargs 并透明透传，以便无论被装饰的是独立函数还是包含 self 的方法，都能安全接收参数。

五、全维度技术对照与总结

最后，我们将函数、实例方法、类方法和静态方法的各项核心特征汇总如下表与图示，作为日常开发和技术选型时的速查基准：

图4：Python 函数与方法（普通、类方法、静态方法）全维度技术对照矩阵

总结而言：在 Python 的底层对象模型中，函数是第一公民也是构成方法的基础原料；而方法是函数与具体对象（实例或类）结合后产生的绑定视图。这种转换借助描述符协议在访问时动态完成，既保证了语法的简洁自洽，也赋予了 Python 极高的灵活性。