时间戳

首页 > 解决方案 > Python 跟踪范围内的子类

python - Python 跟踪范围内的子类

问题描述

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

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

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的子类。FooFooTracker

我尝试了一些不同的事情，例如解析 Foo 子类的限定名称并使用exec()来进行名称解析，但基本问题是它总是可以计算出相对于范围内FooTracker.__init__()而不是位置的子类它被称为。

我唯一的另一个想法是尝试一些东西，inspect.currentframe()但即使这是可能的，它也可能太过分了，并且会使代码变得太脆弱（例如，文档中有一条评论指出并非所有 Python 实现都具有框架支持在口译员中”）。

标签： python

解决方案

没有简单的方法可以完全按照您的要求进行。但是您也许可以使用一些 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。装饰器语法比在定义每个类后将其附加到列表要好一些，但不是很多（您仍然会重复很多，这可能会很烦人，除非您使跟踪器和方法名称非常短） .

一个稍微复杂的版本可能会通过基类，以便它会自动检测子类（通过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

推荐阅读