python - 如何在 Python 中定位继承变量的来源？

Question

如果你有多层继承并且知道一个特定的变量存在，有没有办法追溯到变量起源的地方？无需通过查看每个文件和类来向后导航。可能调用某种函数来做到这一点？示例:

父类.py

class parent(object):
    def __init__(self):
        findMe = "Here I am!"

child .py

from parent import parent
class child(parent):
    pass

孙子.py

from child import child
class grandson(child):
    def printVar(self):
        print self.findMe

尝试通过函数调用定位 findMe 变量的来源。

Answer 1

如果“变量”是一个实例变量 - ，那么，如果在 __init__ 方法链中的任何一点，你会:

def __init__(self):
    self.findMe = "Here I am!"

从那时起，它就是一个实例变量，并且就所有效果而言，它不能与任何其他实例变量区分开来。 (除非你设置了一种机制，比如一个带有特殊 __setattr__ 方法的类，它将跟踪属性的变化，并反省代码的哪一部分设置了属性 - 请参见最后一个例子回答)

另请注意，在您的示例中，

class parent(object):
    def __init__(self):
        findMe = "Here I am!"

findMe 被定义为该方法的局部变量，并且在 __init__ 完成后甚至不存在。

现在，如果您的变量被设置为继承链某处的类属性:

class parent(object):
    findMe = False

class childone(parent):
    ...

可以通过检查 MRO(方法解析顺序)链中每个类的 __dict__ 来找到定义了 findMe 的类。当然，如果不对 MRO 链中的所有类进行内省(introspection)，这样做是没有办法，也没有任何意义的——除非一个人跟踪定义的属性，就像下面的例子一样——但是对 MRO 本身进行内省(introspection)是一个 oneliner python :

def __init__(self):
    super().__init__()
    ...
    findme_definer = [cls for cls in self.__class__.__mro__ if "findMe" in cls.__dict__][0]

同样 - 您的继承链可以有一个元类，它可以跟踪继承树中所有已定义的属性，并使用字典来检索每个属性的定义位置。同一个元类还可以自动修饰所有 __init__(或所有方法)，并设置一个特殊的 __setitem__ 以便它可以在创建实例属性时跟踪它们，如上所列.

这是可以做到的，有点复杂，很难维护，并且可能表明您对问题采取了错误的方法。

因此，仅记录类属性的元类可以简单地是(python3 语法 - 如果您仍在使用 Python 2.7，则在类主体上定义一个 __metaclass__ 属性):

class MetaBase(type):
    definitions = {}
    def __init__(cls, name, bases, dct):
        for attr in dct.keys():
            cls.__class__.definitions[attr] = cls

class parent(metaclass=MetaBase):
    findMe = 5
    def __init__(self):
        print(self.__class__.definitions["findMe"])

现在，如果想要找到哪个父类(super class)定义了当前类的属性，只需一个“实时”跟踪机制，将每个方法包装在每个类中就可以了——这要复杂得多。

我做到了 - 即使您不需要这么多，它结合了两种方法 - 在类的 definitions 和实例 _definitions 中跟踪类属性 字典 - 因为在每个创建的实例中，任意方法可能是最后一个设置特定实例属性的方法:(这是纯 Python3，由于 Python2 使用的“未绑定(bind)方法”，可能不是直接移植到 Python2 , 并且是 Python3 中的一个简单函数)

from threading import current_thread
from functools import wraps
from types import MethodType
from collections import defaultdict

def method_decorator(func, cls):
    @wraps(func)
    def wrapper(self, *args, **kw):
        self.__class__.__class__.current_running_class[current_thread()].append(cls)
        result = MethodType(func, self)(*args, **kw)
        self.__class__.__class__.current_running_class[current_thread()].pop()
        return result
    return wrapper

class MetaBase(type):
    definitions = {}
    current_running_class = defaultdict(list)
    def __init__(cls, name, bases, dct):
        for attrname, attr in dct.items():
            cls.__class__.definitions[attr] = cls
            if callable(attr) and attrname != "__setattr__":
                setattr(cls, attrname, method_decorator(attr, cls))

class Base(object, metaclass=MetaBase):
    def __setattr__(self, attr, value):
        if not hasattr(self, "_definitions"):
            super().__setattr__("_definitions", {})
        self._definitions[attr] = self.__class__.current_running_class[current_thread()][-1]
        return super().__setattr__(attr,value)

上述代码的示例类:

class Parent(Base):
    def __init__(self):
        super().__init__()
        self.findMe = 10

class Child1(Parent):
    def __init__(self):
        super().__init__()
        self.findMe1 = 20

class Child2(Parent):
    def __init__(self):
        super().__init__()
        self.findMe2 = 30

class GrandChild(Child1, Child2):
    def __init__(self):
        super().__init__()
    def findall(self):
        for attr in "findMe findMe1 findMe2".split():
            print("Attr '{}' defined in class '{}' ".format(attr, self._definitions[attr].__name__))

在控制台上会得到这样的结果:

In [87]: g = GrandChild()

In [88]: g.findall()
Attr 'findMe' defined in class 'Parent' 
Attr 'findMe1' defined in class 'Child1' 
Attr 'findMe2' defined in class 'Child2'