Python类方法在继承中的身份识别与描述符协议解析-Python教程-PHP中文网

Python类方法在继承中的身份识别与描述符协议解析

花韻仙語

发布： 2025-10-07 14:49:00

原创

218人浏览过

Python类方法在继承中的身份识别与描述符协议解析

本文深入探讨了Python中类方法在继承场景下的行为，特别是当它们作为列表元素进行比较时，其身份识别问题。核心在于Python的描述符协议导致每次访问类方法时都会创建新的方法对象，而非直接引用其底层函数。文章详细解释了这一机制，并通过示例代码展示了如何正确地在子类中排除父类方法，推荐使用方法名字符串进行比较，以确保逻辑的准确性。

Python类方法的身份识别与描述符协议

在python中，当我们处理类方法（@classmethod装饰器修饰的方法）时，尤其是在涉及继承和动态比较的场景下，可能会遇到关于方法“身份”的困惑。一个常见的误解是，从类或实例中多次访问同一个类方法，会得到同一个方法对象。然而，事实并非如此。

Python内部通过描述符协议（Descriptor Protocol）来管理类方法、静态方法和实例方法的行为。当您通过 Parent.func1 这样的方式访问一个类方法时，Python会触发描述符协议，动态地创建一个新的方法对象。这个方法对象是绑定到特定类（或实例）的。这意味着，即使是多次访问同一个类上的同一个类方法，您得到的也是不同的方法对象。

我们可以通过Python内置的 id() 函数（返回对象的内存地址标识符）和 is 运算符（检查对象身份是否相同）来验证这一点：

class Parent:
    @classmethod
    def func1(cls):
        pass

class Child(Parent):
    pass

# 每次访问 Parent.func1 都会得到不同的方法对象
print(f"id(Parent.func1)第一次: {id(Parent.func1)}")
print(f"id(Parent.func1)第二次: {id(Parent.func1)}")
print(f"Parent.func1 is Parent.func1: {Parent.func1 is Parent.func1}") # 输出 False

# 父类和子类访问同一个方法，也得到不同的方法对象
print(f"id(Child.func1): {id(Child.func1)}")
print(f"Parent.func1 is Child.func1: {Parent.func1 is Child.func1}") # 输出 False

登录后复制

从上述输出可以看出，每次通过 Parent.func1 或 Child.func1 获取类方法时，都会生成一个具有不同 id 的新方法对象，因此它们彼此之间不 is 相同。

底层函数对象的统一性

尽管方法对象本身是动态生成的，但它们背后所引用的底层函数对象是相同的。这个底层函数对象是实际包含方法逻辑的函数定义，可以通过方法对象的 __func__ 属性访问。

立即学习“Python免费学习笔记（深入）”；

class Parent:
    @classmethod
    def func1(cls):
        print("hello func1")

class Child(Parent):
    pass

# 验证底层函数对象是相同的
print(f"Parent.func1.__func__ is Child.func1.__func__: {Parent.func1.__func__ is Child.func1.__func__}") # 输出 True
print(f"Parent.func1.__func__ is Parent.func1.__func__: {Parent.func1.__func__ is Parent.func1.__func__}") # 输出 True

登录后复制

这表明，Parent.func1 和 Child.func1 虽然是不同的方法对象，但它们都指向同一个原始的 func1 函数定义。

原始代码中 NO_CALCULATE 列表的问题

理解了上述机制，我们就能解释为什么原始代码中的 NO_CALCULATE 列表无法按预期工作：

class Parent:
    @classmethod
    def func1(cls):
        print("hello func1")

    @classmethod
    def func2(cls):
        print("hello func2")

    @classmethod
    def func3(cls):
        print("hello func3")

    CALCULATE = [func1, func2, func3]
    NO_CALCULATE = []

    @classmethod
    def calculate_kpis(cls):
        for func in cls.CALCULATE:
            # 这里的 func 是在类定义时创建的方法对象
            # 而 NO_CALCULATE 列表中的 Parent.func1 也是一个方法对象
            # 但它们很可能不是同一个对象实例
            if func not in cls.NO_CALCULATE:
                func.__get__(cls)() # 这种调用方式也是可以简化的

class Child(Parent):
    NO_CALCULATE = [Parent.func1]  # 移除此计算

if __name__ == "__main__":
     p1 = Child()
     p1.calculate_kpis()

登录后复制

在 Child 类中，NO_CALCULATE = [Parent.func1]。这里的 Parent.func1 在列表定义时被解析为一个方法对象。然后，在 calculate_kpis 方法的循环中，for func in cls.CALCULATE: 迭代出的 func 也是方法对象。当执行 if func not in cls.NO_CALCULATE: 时，Python会尝试比较 func 和 NO_CALCULATE 列表中的元素。由于方法对象没有自定义的相等比较逻辑，Python默认使用身份比较（即 is 运算符）。

因为 func (例如 Child.func1 迭代出来的对象) 和 NO_CALCULATE 列表中的 Parent.func1 是两个不同的方法对象实例（即使它们指向同一个底层函数），所以 func not in cls.NO_CALCULATE 会评估为 True，导致 func1 仍然被执行。

解决方案与最佳实践

为了正确地在子类中排除父类方法，我们应该避免直接比较方法对象。有以下两种更可靠的方法：

1. 推荐方案：通过方法名称字符串进行比较

最清晰、最Pythonic的方法是使用方法的名称（字符串）进行比较。将 NO_CALCULATE 列表中的元素改为方法名的字符串形式。

Blackink AI纹身生成

创建类似纹身的设计，生成独特纹身

查看详情

class Parent:
    @classmethod
    def func1(cls):
        print("Parent func1 executed")

    @classmethod
    def func2(cls):
        print("Parent func2 executed")

    @classmethod
    def func3(cls):
        print("Parent func3 executed")

    # CALCULATE 列表仍然存储方法对象
    CALCULATE = [func1, func2, func3]
    NO_CALCULATE = [] # 父类默认不排除任何方法

    @classmethod
    def calculate_kpis(cls):
        for func in cls.CALCULATE:
            # 使用方法名进行比较
            if func.__name__ not in cls.NO_CALCULATE:
                # 对于类方法，直接 func(cls) 调用即可
                func(cls)

class Child(Parent):
    # 子类排除 'func1'，通过方法名字符串指定
    NO_CALCULATE = ["func1"]

if __name__ == "__main__":
     print("--- Calling calculate_kpis on Child instance ---")
     p1 = Child()
     p1.calculate_kpis()
     # 预期输出：
     # Parent func2 executed
     # Parent func3 executed

登录后复制

在这个修正后的代码中，Child.NO_CALCULATE 包含字符串 "func1"。在 calculate_kpis 方法中，func.__name__ 会获取当前迭代到的方法名称字符串，然后与 cls.NO_CALCULATE 列表中的字符串进行比较。这种比较是基于值的，因此能够准确地排除指定的方法。

2. 替代方案：通过底层函数对象 func 进行比较

虽然不如方法名字符串直观，但也可以通过比较方法对象的 __func__ 属性来解决问题，因为 __func__ 属性指向的是同一个底层函数对象。

class Parent:
    @classmethod
    def func1(cls):
        print("Parent func1 executed")

    @classmethod
    def func2(cls):
        print("Parent func2 executed")

    @classmethod
    def func3(cls):
        print("Parent func3 executed")

    CALCULATE = [func1, func2, func3]
    NO_CALCULATE = []

    @classmethod
    def calculate_kpis(cls):
        # 预先提取 NO_CALCULATE 中方法的底层函数对象
        excluded_funcs = [f.__func__ for f in cls.NO_CALCULATE]
        for func in cls.CALCULATE:
            if func.__func__ not in excluded_funcs:
                func(cls)

class Child(Parent):
    # 存储父类方法对象的 __func__ 属性
    NO_CALCULATE = [Parent.func1] # 这里的 Parent.func1 会在列表创建时解析为一个方法对象

if __name__ == "__main__":
     print("--- Calling calculate_kpis on Child instance (using __func__) ---")
     p1 = Child()
     p1.calculate_kpis()

登录后复制

这种方法需要额外处理 NO_CALCULATE 列表，将其中的方法对象转换为其 __func__ 属性，然后进行比较。虽然可行，但通常不如直接使用方法名字符串清晰。

关于类方法调用 func.get(cls)() 的简化

在原始代码中，类方法的调用使用了 func.__get__(cls)()。对于类方法，这种显式使用描述符协议的方式是不必要的。当 func 是一个类方法对象时，直接调用 func(cls) 即可，Python会自动处理绑定逻辑。

# 原始代码中的调用方式
func.__get__(cls)()

# 简化后的调用方式（推荐）
func(cls)

登录后复制

这使得代码更简洁，更符合Python的惯用法。

总结

Python的描述符协议是理解类方法、静态方法和实例方法行为的关键。在继承和动态方法管理中，重要的是要认识到每次访问类方法时都会创建一个新的方法对象。因此，直接比较方法对象（如 method1 is method2 或 method1 in list_of_methods）通常不会按预期工作。

为了在子类中可靠地排除父类方法，推荐的方法是：

在 NO_CALCULATE 等排除列表中存储方法的名称字符串。
在运行时，通过比较 func.__name__ 属性来判断是否应该执行该方法。
对于类方法的调用，直接使用 func(cls) 形式即可。

遵循这些最佳实践，可以确保在复杂的类层次结构中，类方法的管理和调用逻辑是清晰、准确且健壮的。

以上就是Python类方法在继承中的身份识别与描述符协议解析的详细内容，更多请关注php中文网其它相关文章！

大家都在看：

Python二维数组初始化陷阱与正确方法 Python代码怎么调试_Python代码调试方法与工具使用实例 Python struct.unpack 的字节对齐与填充机制解析 Python列表字符串拆分教程：将字符串元素拆分为多个列表的技巧与陷阱 Python自动化：解除Excel密码保护并读取数据

Python类方法在继承中的身份识别与描述符协议解析

Python类方法的身份识别与描述符协议

底层函数对象的统一性

原始代码中 NO_CALCULATE 列表的问题

解决方案与最佳实践

1. 推荐方案：通过方法名称字符串进行比较

2. 替代方案：通过底层函数对象 __func__ 进行比较

关于类方法调用 func.__get__(cls)() 的简化

总结

大家都在看：

2. 替代方案：通过底层函数对象 func 进行比较

关于类方法调用 func.get(cls)() 的简化