Как найти все подклассы класса по имени? - PullRequest
Новая
       22

Как найти все подклассы класса по имени?

177 голосов
/ 05 октября 2010

Мне нужен рабочий подход для получения всех классов, которые унаследованы от базового класса в Python.

Ответы [ 10 ]

238 голосов
/ 05 октября 2010

Классы нового стиля (то есть подклассы из 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__() выдаст список его подклассов.

57 голосов
/ 22 июня 2013

Если вам просто нужны прямые подклассы, тогда .__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
25 голосов
/ 09 ноября 2015

Самое простое решение в общем виде: 

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
15 голосов
/ 28 марта 2017

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__ и опустить / добавить подклассы из этого списка.

8 голосов
/ 21 января 2015

FWIW, вот что я имел в виду @ ответ unutbu , работающий только с локально определенными классами & mdash; и что использование 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'>]
3 голосов
/ 06 сентября 2016

Гораздо более короткая версия для получения списка всех подклассов: 

from itertools import chain

def subclasses(cls):
    return list(
        chain.from_iterable(
            [list(chain.from_iterable([[x], subclasses(x)])) for x in cls.__subclasses__()]
        )
    )
1 голос
/ 01 ноября 2017

Как мне найти все подклассы класса по имени?

Конечно, мы можем легко сделать это при наличии доступа к самому объекту, да.

Просто учитывая его имя - плохая идея, так как может быть несколько классов с одним и тем же именем, даже определенных в одном модуле.

Я создал реализацию для другого ответа , и, поскольку он отвечает на этот вопрос, и он немного более элегантен, чем другие решения здесь, вот он: 

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'>]
1 голос
/ 07 июня 2017

Вот версия без рекурсии: 

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], [])
1 голос
/ 05 октября 2010

Это не такой хороший ответ, как использование специального встроенного метода класса __subclasses__(), о котором упоминает @unutbu, поэтому я представляю его просто как упражнение. Определенная функция 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'>}
0 голосов
/ 23 октября 2017

Я не могу представить себе реальный сценарий использования для него, но надежный способ (даже в классах старого стиля Python 2) будет сканировать пространство имен глобалов: 

def has_children(cls):
    g = globals().copy()   # use a copy to make sure it will not change during iteration
    g.update(locals())     # add local symbols
    for k, v in g.items(): # iterate over all globals object
        try:
            if (v is not cls) and issubclass(v, cls): # found a strict sub class?
                return True
        except TypeError:  # issubclass raises a TypeError if arg is not a class...
            pass
    return False

Это работает в Python 2 newклассы стилей и классы Python 3, а также Python 2 classic classes

...