web-dev-qa-db-ja.com

名前を指定してクラスのすべてのサブクラスを見つける方法は？

Pythonの基本クラスから継承されたすべてのクラスを取得する実用的なアプローチが必要です。

pythonsubclass
184
Roman Prykhodchenko

新しいスタイルのクラス（つまり、Python 3のデフォルトであるobjectのサブクラス）には、サブクラスを返す__subclasses__メソッドがあります。

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

サブクラスの名前は次のとおりです。

print([cls.__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クラスはファーストクラスオブジェクトであるため、クラスまたはそのようなものの代わりにクラス名の文字列を使用する必要はありません。クラスを直接使用するだけで、おそらくそうする必要があります。

クラスの名前を表す文字列があり、そのクラスのサブクラスを検索する場合は、2つの手順があります。名前が指定されたクラスを検索し、上記の__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__()はそのサブクラスのリストを返します。

245
unutbu

直接サブクラスが必要な場合は、.__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
58
fletom

一般的な形式の最も簡単なソリューション：

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
25
Kimvais

Python 3.6-__init_subclass__

python 3.6以降は __subclasses__ メソッドをオーバーライドすることでこの属性の作成を変更できるため、他の回答で言及したように、__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__の動作をオーバーライドし、このリストからサブクラスを省略/追加できます。

16
Or Duan

FWIW、これが私が意味することです @ unutbu's answer ローカルで定義されたクラスでのみ動作します— 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'>]
8
martineau

すべてのサブクラスのリストを取得するためのはるかに短いバージョン：

from itertools import chain

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

これは、@ unutbuが言及している特別なbuilt_in__subclasses__()classメソッドを使用するのと同じくらい良い答えではないので、単に演習として提示します。定義されたsubclasses()functionは、すべてのサブクラス名をサブクラス自体にマップする辞書を返します。

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'>}
1
martineau

名前を指定してクラスのすべてのサブクラスを見つけるにはどうすればよいですか？

確かに、オブジェクト自体へのアクセスがあれば、これを簡単に行うことができます。

同じ名前で複数のクラスがあり、同じモジュールで定義されていることもあるため、単純に名前を指定するのは適切ではありません。

別の answer の実装を作成しましたが、この質問に答えており、ここにある他のソリューションよりも少しエレガントなので、ここにあります：

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
Aaron Hall

再帰のないバージョンは次のとおりです。

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
Thomas Grainger

現実のユースケースを想像することはできませんが、堅牢な方法（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つの新しいスタイルクラスとPython 3クラス、およびPython 2 classicクラスで動作します。

0
Serge Ballesta