Python对象标识与方法动态性
在python中，我们通常通过对象的标识符（id）来区分不同的对象，这可以通过内置的id()函数获取。虽然这个id在底层实现上可能对应于内存地址，但在纯python代码中，我们更关注的是对象的“身份”而非其物理地址。当我们使用is操作符进行比较时，实际上是在检查两个变量是否引用了同一个对象实例。
对于类方法（使用@classmethod装饰器定义的方法），一个常见的误解是，每次通过类名（如Parent.func1）访问它们时，都会得到同一个对象。然而，事实并非如此。Python的描述符协议在这里发挥了关键作用。每当一个类方法被访问时，Python会动态地创建一个新的绑定方法对象。这个新的对象将底层函数（实际执行逻辑的代码）与它所属的类（或实例）绑定起来。由于每次访问都会生成一个新对象，因此它们的id()值会不同，并且使用is操作符进行比较时会返回False。
下面的交互式示例清晰地展示了这一点：
class Parent:
@classmethod
def func1(cls):
pass
class Child(Parent):
pass
# 每次访问Parent.func1都会得到不同的对象ID
print(f"Parent.func1 id 1: {id(Parent.func1)}")
print(f"Parent.func1 id 2: {id(Parent.func1)}")
print(f"Child.func1 id: {id(Child.func1)}")
# 验证不同的方法对象
print(f"Parent.func1 is Parent.func1: {Parent.func1 is Parent.func1}")输出通常会是：
Parent.func1 id 1: 140735877546880 Parent.func1 id 2: 140735877547008 Child.func1 id: 140735877547136 Parent.func1 is Parent.func1: False
这表明，即使是同一个类中的同一个类方法，在不同时间被访问时，也会产生不同的方法对象。
立即学习“Python免费学习笔记（深入）”；
方法对象与底层函数的区别
尽管每次访问类方法会产生新的方法对象，但这些方法对象都指向同一个底层函数对象。这个底层函数包含了方法的实际逻辑，它是唯一且不变的。我们可以通过方法对象的__func__属性来访问这个底层函数。
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__}")输出：
Parent.func1.__func__ is Child.func1.__func__: True
这证实了，虽然Parent.func1和Child.func1是不同的方法对象，但它们共享相同的__func__，即实际的函数定义。
比较逻辑失效的原因与解决方案
在原始代码中，NO_CALCULATE列表存储了Parent.func1这个方法对象。然而，在calculate_kpis方法内部，for func in cls.CALCULATE循环中获取的func也是一个动态生成的绑定方法对象。由于这些方法对象是不同的实例，即使它们看起来“相同”，Python默认的相等性比较（对于没有自定义__eq__方法的对象，会退化为身份比较is）会判断它们不相等。这就是为什么if func not in cls.NO_CALCULATE语句总是评估为True，导致所有函数都被计算的原因。
为了正确地实现“不计算”的逻辑，我们需要确保比较的是对象的身份或某个稳定的属性。以下是两种推荐的解决方案：
1. 通过比较底层函数 (__func__)
如果NO_CALCULATE列表存储的是底层函数对象，那么在循环中也可以比较func.__func__。
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_FUNCS = [] # 存储底层函数对象
@classmethod
def calculate_kpis(cls):
for func in cls.CALCULATE:
# 比较底层函数对象
if func.__func__ not in cls.NO_CALCULATE_FUNCS:
func(cls) # 直接调用绑定方法
class Child(Parent):
# 移除这个计算，通过存储Parent.func1的底层函数
NO_CALCULATE_FUNCS = [Parent.func1.__func__]
if __name__ == "__main__":
p1 = Child()
p1.calculate_kpis()这种方法虽然可行，但需要确保NO_CALCULATE列表中的元素也是底层函数对象，这可能会增加代码的复杂性。
2. 通过比较方法名称 (推荐)
更简洁和推荐的做法是，将NO_CALCULATE列表中的元素存储为方法的字符串名称，并在比较时使用func.__name__。这种方式不仅清晰易读，而且避免了处理动态方法对象的问题。
class Parent:
@classmethod
def func1(cls):
print("hello func1 from Parent.func1")
@classmethod
def func2(cls):
print("hello func2 from Parent.func2")
@classmethod
def func3(cls):
print("hello func3 from Parent.func3")
CALCULATE = [func1, func2, func3]
# 存储方法名称字符串
NO_CALCULATE = []
@classmethod
def calculate_kpis(cls):
for func in cls.CALCULATE:
# 比较方法名称字符串
if func.__name__ not in cls.NO_CALCULATE:
# 直接调用绑定方法，无需使用__get__
func(cls)
class Child(Parent):
# 移除Parent.func1的计算
NO_CALCULATE = ["func1"] # 列表存储方法名称字符串
if __name__ == "__main__":
print("--- Child instance calculation ---")
p1 = Child()
p1.calculate_kpis()
print("\n--- Parent instance calculation ---")
Parent.calculate_kpis() # 验证Parent类行为运行上述代码，Child实例的输出将是：
--- Child instance calculation --- hello func2 from Parent.func2 hello func3 from Parent.func3 --- Parent instance calculation --- hello func1 from Parent.func1 hello func2 from Parent.func2 hello func3 from Parent.func3
这表明Child类成功地排除了func1的计算，而Parent类则计算了所有方法。
调用类方法的注意事项
在原始代码中，调用类方法使用了func.__get__(cls)()。虽然这在技术上是可行的，因为它手动触发了描述符协议来获取一个绑定到cls的方法并调用它，但对于已经是一个绑定方法对象（如在for func in cls.CALCULATE循环中获取的func）而言，更直接、更Pythonic的调用方式是func(cls)。当func是一个绑定类方法时，它已经知道如何将cls作为第一个参数传递。
总结
理解Python中类方法对象的动态创建机制是编写健壮代码的关键。每次访问类方法时，Python都会生成一个新的绑定方法对象，但这些对象共享同一个底层函数。因此，在需要比较方法或将其作为集合元素时，直接比较方法对象可能会导致意外结果。推荐的做法是：
- 比较底层函数对象 (__func__)：如果需要精确地基于函数定义进行比较。
- 比较方法名称字符串 (__name__)：这通常是更简洁、更可读且更易于维护的解决方案，尤其适用于配置排除列表等场景。 同时，调用绑定类方法时，直接使用func(cls)是比func.__get__(cls)()更推荐的方式。掌握这些细节有助于避免常见的陷阱，并编写出更符合Python惯例的专业代码。
