Question

我正在尝试编写一个跟踪器类，其中跟踪器类的实例跟踪在跟踪器实例范围内的另一个类的子类。

更具体地说，以下是我要实现的示例：

class Foo(object): pass

class FooTracker(object):
     def __init__(self):

          # use Foo.__subclasses__() or a metaclass to track subclasses 
          # - but how do I filter this to only get the ones in scope?

          self.inscope = <something magic goes here>

ft1 = FooTracker()
assert ft1.inscope == []

class Bar(Foo): pass
ft2 = FooTracker()
assert ft2.inscope == [<class '__main__.Bar'>]

def afunction():
    class Baz(Foo): pass    # the global definition of Bar is now hidden
    class Bar(Foo): pass
    ft3 = FooTracker()

    assert (set(ft3.inscope) == set([<class '__main__.afunction.<locals>.Baz'>,
                                     <class '__main__.afunction.<locals>.Bar'>])

ft4 = FooTracker()   # afunction.Baz and afunction.Bar are no longer in scope
assert ft4.inscope == [<class '__main__.Bar'>]

所以我希望FooTracker的实例跟踪创建Foo对象时作用域内的FooTracker的子类。

我尝试了几种不同的方法，例如解析Foo子类的合格名称，并使用exec()进行名称解析，但是基本的问题是它总是可以计算出子类相对于FooTracker.__init__()中的范围，而不是它的调用位置。

我唯一的想法是尝试使用inspect.currentframe()进行操作，但是即使有可能，也可能是太多的破解，并且会使代码过于脆弱（例如，文档中有一条评论并非所有的Python实现都会在解释器中提供框架支持”。

Answer 1

没有一种简单的方法可以准确地完成您的要求。但是您也许可以使用某些Python功能来使用大致相似的API来获取内容，而不会带来太多麻烦。

一种选择是要求每个子类都用Tracker类的方法修饰。这将使真正易于跟踪，因为您只需将方法的每个调用者附加到列表中即可：

class Tracker:
    def __init__(self):
        self.subclasses = []

    def register(self, cls):
        self.subclasses.append(cls)
        return cls

class Foo(): pass

foo_tracker = Tracker()

@foo_tracker.register
class FooSubclass1(Foo): pass

@foo_tracker.register
class FooSubclass2(Foo): pass

print(foo_tracker.subclasses)

这实际上并不需要所跟踪的类是Foo的子类，如果将它们传递给register方法，则可以跟踪所有类（甚至是非类对象）。 Decorator语法使它比仅在定义后将每个类添加到列表好一点，但效果却不尽如人意（您仍然要重复很多，除非使跟踪器和方法名非常短，否则可能会很烦人）

一个稍微棘手的版本可能会通过基类，以便它可以自动检测子类（通过Foo.__subclasses__）。为了限制它检测到的子类（而不是获取该基类的所有子类），可以使其充当上下文管理器，并且仅跟踪在with块中定义的新子类：

class Tracker:
    def __init__(self, base):
        self.base = base
        self._exclude = set()
        self.subclasses = set()

    def __enter__(self):
        self._exclude = set(self.base.__subclasses__())
        return self

    def __exit__(self, *args):
        self.subclasses = set(self.base.__subclasses__()) - self._exclude
        return False

class Foo(): pass
class UntrackedSubclass1(Foo): pass

with Tracker(Foo) as foo_tracker:
    class TrackedSubclass1(Foo): pass
    class TrackedSubclass2(Foo): pass

class UntrackedSubclass2(Foo): pass

print(foo_tracker.subclasses)

如果您使用的是Python 3.6或更高版本，则可以通过将__init_subclass__类方法注入到跟踪的基类中来进行跟踪，而不必依赖__subclasses__。如果您不需要支持已经出于自身目的而使用__init_subclass__的类层次结构（并且您不需要支持嵌套的跟踪器），则可以很优雅：

class Tracker:
    def __init__(self, base):
        self.base = base
        self.subclasses = []

    def __enter__(self):
        @classmethod
        def __init_subclass__(cls, **kwargs):
            self.subclasses.append(cls)

        self.base.__init_subclass__ = __init_subclass__
        return self

    def __exit__(self, *args):
        del self.base.__init_subclass__
        return False

class Foo(): pass
class UntrackedSubclass1(Foo): pass

with Tracker(Foo) as foo_tracker:
    class TrackedSubclass1(Foo): pass
    class TrackedSubclass2(Foo): pass

class UntrackedSubclass2(Foo): pass

print(foo_tracker.subclasses)

此版本的一个不错的功能是它会自动跟踪更深的继承层次结构。如果在with块中创建了子类的子类，则仍将跟踪该“孙子”类。如果需要的话，我们可以通过添加另一个函数以递归方式扩展找到的每个类的子类来使基于__subclasses__的先前版本也能以这种方式工作。

如果您确实想与现有的__init_subclass__方法配合使用，或者希望能够嵌套跟踪器，则需要使代码更加复杂。以可逆的方式注入行为良好的classmethod是棘手的，因为您既需要处理基类拥有自己的方法的情况，又需要继承其父类的版本。

class Tracker:
    def __init__(self, base):
        self.base = base
        self.subclasses = []

    def __enter__(self):
        if '__init_subclass__' in self.base.__dict__:
            self.old_init_subclass = self.base.__dict__['__init_subclass__']
        else:
            self.old_init_subclass = None

        @classmethod
        def __init_subclass__(cls, **kwargs):
            if self.old_init_subclass is not None:
                self.old_init_subclass.__get__(None, cls)(**kwargs)
            else:
                super(self.base, cls).__init_subclass__(**kwargs)
            self.subclasses.append(cls)

        self.base.__init_subclass__ = __init_subclass__
        return self

    def __exit__(self, *args):
        if self.old_init_subclass is not None:
            self.base.__init_subclass__ = self.old_init_subclass
        else:
            del self.base.__init_subclass__
        return False

class Foo:
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        print("Foo!")

class Bar(Foo): pass   # every class definition from here on prints "Foo!" when it runs

with Tracker(Bar) as tracker1:
    class Baz(Bar): pass

    with Tracker(Foo) as tracker2:
        class Quux(Foo): pass

        with Tracker(Bar) as tracker3:
            class Plop(Bar): pass

# four Foo! lines will have be printed by now by Foo.__init_subclass__
print(tracker1.subclasses) # will describe Baz and Plop, but not Quux
print(tracker2.subclasses) # will describe Quux and Plop
print(tracker3.subclasses) # will describe only Plop

范围内的Python跟踪子类

1 个答案: