如何根据给定名称查找一个类的所有子类？

Question

我需要一种获取从 Python 基类继承的所有类的工作方法。

Answer 1

新式类（即从 object 派生的子类，这是 Python 3 中的默认设置）具有返回子类的 __subclasses__ 方法：

class Foo(object): pass
class Bar(Foo): pass
class Baz(Foo): pass
class Bing(Bar): pass

以下是子类的名称：

print([cls.__name__ for cls in Foo.__subclasses__()])
# ['Bar', 'Baz']

这里是子类本身：

print(Foo.__subclasses__())
# [<class '__main__.Bar'>, <class '__main__.Baz'>]

确认子类确实将 Foo 列为其基类：

for cls in Foo.__subclasses__():
    print(cls.__base__)
# <class '__main__.Foo'>
# <class '__main__.Foo'>

请注意，如果您想要子子类，则必须递归：

def all_subclasses(cls):
    return set(cls.__subclasses__()).union(
        [s for c in cls.__subclasses__() for s in all_subclasses(c)])

print(all_subclasses(Foo))
# {<class '__main__.Bar'>, <class '__main__.Baz'>, <class '__main__.Bing'>}

请注意，如果子类的类定义尚未定义尚未执行 - 例如，如果子类的模块尚未导入 - 那么该子类尚不存在，并且 __subclasses__ 不会找到它。

---

你提到“给它的名字”。由于 Python 类是一等对象，因此您不需要使用带有类名的字符串来代替类或类似的内容。您可以直接使用该类，而且您可能应该这样做。

如果您确实有一个表示类名称的字符串，并且想要查找该类的子类，则有两个步骤：根据名称查找该类，然后使用上面的 __subclasses__ 查找子类。

如何从名称找到类取决于您期望在哪里找到它。如果您希望在与尝试定位该类的代码相同的模块中找到它，那么

cls = globals()[name]

就可以完成这项工作，或者在不太可能的情况下，您希望在局部变量中找到它，

cls = locals()[name]

如果该类可能位于任何模块，那么您的名称字符串应包含完全限定的名称 - 类似 'pkg.module.Foo' 而不仅仅是 'Foo'。使用importlib加载类的模块，然后检索相应的属性：

import importlib
modname, _, clsname = name.rpartition('.')
mod = importlib.import_module(modname)
cls = getattr(mod, clsname)

无论您如何找到该类，cls.__subclasses__()都会返回其子类的列表。

Answer 2

如果您只想要直接子类，那么 .__subclasses__() 工作正常。如果您想要所有子类、子类的子类等等，您将需要一个函数来为您执行此操作。

这是一个简单、可读的函数，它递归地查找给定类的所有子类：

def get_all_subclasses(cls):
    all_subclasses = []

    for subclass in cls.__subclasses__():
        all_subclasses.append(subclass)
        all_subclasses.extend(get_all_subclasses(subclass))

    return all_subclasses

Answer 3

一般形式的最简单的解决方案：

def get_subclasses(cls):
    for subclass in cls.__subclasses__():
        yield from get_subclasses(subclass)
        yield subclass

以及一个类方法，如果您有一个继承自的类：

@classmethod
def get_subclasses(cls):
    for subclass in cls.__subclasses__():
        yield from subclass.get_subclasses()
        yield subclass

Answer 4

Python 3.6 - __init_subclass__

正如其他答案提到的，您可以检查 __subclasses__ 属性来获取子类列表，因为 python 3.6 您可以修改此属性通过覆盖 创建__init_subclass__ 方法。

class PluginBase:
    subclasses = []

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        cls.subclasses.append(cls)

class Plugin1(PluginBase):
    pass

class Plugin2(PluginBase):
    pass

这样，如果您知道自己在做什么，则可以覆盖 __subclasses__ 的行为并从此列表中省略/添加子类。

Answer 5

注意：我看到有人（不是 @unutbu）更改了引用的答案，使其不再使用 vars()['Foo'] - 因此我帖子的主要观点不再适用.

FWIW，这就是我关于 @unutbu 的答案 仅使用本地定义的类的意思 - 并且使用 < code>eval() 而不是 vars() 将使其适用于任何可访问的类，而不仅仅是当前范围中定义的类。

对于那些不喜欢使用 eval() 的人，还提供了一种避免使用它的方法。

首先，这是一个具体示例，演示了使用 vars() 的潜在问题：

class Foo(object): pass
class Bar(Foo): pass
class Baz(Foo): pass
class Bing(Bar): pass

# unutbu's approach
def all_subclasses(cls):
    return cls.__subclasses__() + [g for s in cls.__subclasses__()
                                       for g in all_subclasses(s)]

print(all_subclasses(vars()['Foo']))  # Fine because  Foo is in scope
# -> [<class '__main__.Bar'>, <class '__main__.Baz'>, <class '__main__.Bing'>]

def func():  # won't work because Foo class is not locally defined
    print(all_subclasses(vars()['Foo']))

try:
    func()  # not OK because Foo is not local to func()
except Exception as e:
    print('calling func() raised exception: {!r}'.format(e))
    # -> calling func() raised exception: KeyError('Foo',)

print(all_subclasses(eval('Foo')))  # OK
# -> [<class '__main__.Bar'>, <class '__main__.Baz'>, <class '__main__.Bing'>]

# using eval('xxx') instead of vars()['xxx']
def func2():
    print(all_subclasses(eval('Foo')))

func2()  # Works
# -> [<class '__main__.Bar'>, <class '__main__.Baz'>, <class '__main__.Bing'>]

可以通过将 eval('ClassName') 向下移动到定义的函数中来改进，这使得使用它更容易，而不损失通过使用 eval() 获得的额外通用性，它与 vars() 不同，它不是上下文相关的：

# easier to use version
def all_subclasses2(classname):
    direct_subclasses = eval(classname).__subclasses__()
    return direct_subclasses + [g for s in direct_subclasses
                                    for g in all_subclasses2(s.__name__)]

# pass 'xxx' instead of eval('xxx')
def func_ez():
    print(all_subclasses2('Foo'))  # simpler

func_ez()
# -> [<class '__main__.Bar'>, <class '__main__.Baz'>, <class '__main__.Bing'>]

最后，它是可能的，甚至可能很重要在某些情况下，出于安全原因避免使用 eval() ，因此这里有一个没有它的版本：

def get_all_subclasses(cls):
    """ Generator of all a class's subclasses. """
    try:
        for subclass in cls.__subclasses__():
            yield subclass
            for subclass in get_all_subclasses(subclass):
                yield subclass
    except TypeError:
        return

def all_subclasses3(classname):
    for cls in get_all_subclasses(object):  # object is base of all new-style classes.
        if cls.__name__.split('.')[-1] == classname:
            break
    else:
        raise ValueError('class %s not found' % classname)
    direct_subclasses = cls.__subclasses__()
    return direct_subclasses + [g for s in direct_subclasses
                                    for g in all_subclasses3(s.__name__)]

# no eval('xxx')
def func3():
    print(all_subclasses3('Foo'))

func3()  # Also works
# -> [<class '__main__.Bar'>, <class '__main__.Baz'>, <class '__main__.Bing'>]

Answer 6

下面是一个简单但高效的代码版本：

def get_all_subclasses(cls):
    subclass_list = []

    def recurse(klass):
        for subclass in klass.__subclasses__():
            subclass_list.append(subclass)
            recurse(subclass)

    recurse(cls)

    return set(subclass_list)

它的时间复杂度为 O(n)，其中 n 是如果没有多重继承的话所有子类的数量。
它比使用生成器递归创建列表或生成类的函数更有效，当类层次结构是平衡树时，其复杂度可能为 (1) O(nlogn) 或 (2) O (n^2) 当类层次结构是偏向树时。

Answer 7

用于获取所有子类列表的更短版本：

from itertools import chain

def subclasses(cls):
    return list(
        chain.from_iterable(
            [list(chain.from_iterable([[x], subclasses(x)])) for x in cls.__subclasses__()]
        )
    )

Answer 8

这是一个没有递归的版本：

def get_subclasses_gen(cls):

    def _subclasses(classes, seen):
        while True:
            subclasses = sum((x.__subclasses__() for x in classes), [])
            yield from classes
            yield from seen
            found = []
            if not subclasses:
                return

            classes = subclasses
            seen = found

    return _subclasses([cls], [])

这与其他实现的不同之处在于它返回原始类。
这是因为它使代码更简单，并且：

class Ham(object):
    pass

assert(issubclass(Ham, Ham)) # True

如果 get_subclasses_gen 看起来有点奇怪，那是因为它是通过将尾递归实现转换为循环生成器创建的：

def get_subclasses(cls):

    def _subclasses(classes, seen):
        subclasses = sum(*(frozenset(x.__subclasses__()) for x in classes))
        found = classes + seen
        if not subclasses:
            return found

        return _subclasses(subclasses, found)

    return _subclasses([cls], [])

Answer 9

如何找到给定名称的类的所有子类？

如果可以访问对象本身，我们当然可以轻松地做到这一点，是的。

简单地给出它的名称是一个糟糕的主意，因为可以有多个同名的类，甚至是在同一个模块中定义的。

我为另一个答案创建了一个实现，因为它回答了这个问题并且比这里的其他解决方案更优雅，这是：

def get_subclasses(cls):
    """returns all subclasses of argument, cls"""
    if issubclass(cls, type):
        subclasses = cls.__subclasses__(cls)
    else:
        subclasses = cls.__subclasses__()
    for subclass in subclasses:
        subclasses.extend(get_subclasses(subclass))
    return subclasses

用法：

>>> import pprint
>>> list_of_classes = get_subclasses(int)
>>> pprint.pprint(list_of_classes)
[<class 'bool'>,
 <enum 'IntEnum'>,
 <enum 'IntFlag'>,
 <class 'sre_constants._NamedIntConstant'>,
 <class 'subprocess.Handle'>,
 <enum '_ParameterKind'>,
 <enum 'Signals'>,
 <enum 'Handlers'>,
 <enum 'RegexFlag'>]

Answer 10

这不像使用 @unutbu 提到的特殊内置 __subclasses__() 类方法那么好，所以我仅将其作为练习。定义的 subclasses() 函数返回一个字典，它将所有子类名称映射到子类本身。

def traced_subclass(baseclass):
    class _SubclassTracer(type):
        def __new__(cls, classname, bases, classdict):
            obj = type(classname, bases, classdict)
            if baseclass in bases: # sanity check
                attrname = '_%s__derived' % baseclass.__name__
                derived = getattr(baseclass, attrname, {})
                derived.update( {classname:obj} )
                setattr(baseclass, attrname, derived)
             return obj
    return _SubclassTracer

def subclasses(baseclass):
    attrname = '_%s__derived' % baseclass.__name__
    return getattr(baseclass, attrname, None)


class BaseClass(object):
    pass

class SubclassA(BaseClass):
    __metaclass__ = traced_subclass(BaseClass)

class SubclassB(BaseClass):
    __metaclass__ = traced_subclass(BaseClass)

print subclasses(BaseClass)

输出：

{'SubclassB': <class '__main__.SubclassB'>,
 'SubclassA': <class '__main__.SubclassA'>}

Answer 11

使用__subclasses()__方法的局限性是：

1. 您需要加载类（即导入它们），否则它将无法工作。
2. 如果有多层继承，则需要递归。例如：A 类 -> B(A) 类 -> C(B) 类。 A.__subclasses__() 只会给你类 B 而不是类 C。这是因为类 C 继承自类 B 而不是 A！

因此，为了解决这两个限制，除了上面的精彩答案之外，我还有一个稍微不同的方法。

此函数将获取包中的所有类：

def get_classes_from_package_recursively(package: str) -> list[type]:
    """Return a list of classes inside a given package (recurse thorugh any sub-packages).

    Keyword arguments:
    package -- package represented as a string. Must not be relative.
    """
    classes_in_package = []
    # Go through the modules in the package
    for _importer, module_name, is_package in pkgutil.iter_modules(importlib.import_module(package).__path__):
        full_module_name = f"{package}.{module_name}"
        # Recurse through any sub-packages
        if is_package:
            classes_in_subpackage = get_classes_from_package_recursively(package=full_module_name)
            classes_in_package.extend(classes_in_subpackage)

        # Load the module for inspection
        module = importlib.import_module(full_module_name)

        # Iterate through all the objects in the module and
        # using the lambda, filter for class objects and only objects that exist within the module
        for _name, obj in inspect.getmembers(
            module,
            lambda member, module_name=full_module_name: inspect.isclass(member) and member.__module__ == module_name,
        ):
            classes_in_package.append(obj)
    return classes_in_package

如何使用上面的类的示例：

my_classes = get_classes_from_package_recursively(package="src.database.models")

my_classes 现在看起来像这样 [MyModel1、MyModel2、MyModel3 等...]

得到这个后，只需像这样过滤列表：

my_subclasses = [class_ for class_ in my_classes if issubclass(class_, parent_class) and class_ is not parent_class]

Answer 12

虽然我非常偏爱 __init_subclass__ 方法，但如果您有一个非常密集的层次结构并且到处都有多重继承，这将保留定义顺序，并避免增长的组合顺序：

def descendents(cls):
    '''Does not return the class itself'''
    R = {}
    def visit(cls):
        for subCls in cls.__subclasses__():
            if not subCls in R:
                R[subCls] = True
                visit(subCls)
    visit(cls)
    return list(R.keys())

这是有效的，因为字典会记住插入顺序他们的钥匙。