blocks|key|1126750|text|这不是一个比使用@unutbu提到的特殊内置__subclasses__()类方法更好的答案，所以我只是将其作为练习。定义的subclasses()函数返回一个字典，该字典将所有子类名称映射到子类本身。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1126751|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+=+'_%25s__derived'+%25+baseclass.__name__
++++++++++++++++derived+=+getattr(baseclass,+attrname,+{})
++++++++++++++++derived.update(+{classname:obj}+)
++++++++++++++++setattr(baseclass,+attrname,+derived)
+++++++++++++return+obj
++++return+_SubclassTracer

def+subclasses(baseclass):
++++attrname+=+'_%25s__derived'+%25+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)|code-block|syntax|javascript|1126752|输出：|1126753|{'SubclassB':+<class+'__main__.SubclassB'>,
+'SubclassA':+<class+'__main__.SubclassA'>}|1126754|entityMap^0|M|G|1Q|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

This isn't as good an answer as using the special built-in <code>__subclasses__()</code> class method which @unutbu mentions, so I present it merely as an exercise. The <code>subclasses()</code> function defined returns a dictionary which maps all the subclass names to the subclasses themselves.
<pre><code>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)
</code></pre>
Output:
<pre class="lang-none prettyprint-override"><code>{'SubclassB': &lt;class '__main__.SubclassB'&gt;,
 'SubclassA': &lt;class '__main__.SubclassA'&gt;}
</code></pre>

blocks|key|911812|text|如果你只想要直接的子类，那么.__subclasses__()可以很好地工作。如果您想要所有的子类、子类的子类等等，那么您需要一个函数来完成这些工作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|911813|下面是一个简单的、可读的函数，它递归地查找给定类的所有子类：|911814|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|code-block|syntax|javascript|911815|entityMap^0|E|H|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

If you just want direct subclasses then <code>.__subclasses__()</code> works fine. If you want all subclasses, subclasses of subclasses, and so on, you'll need a function to do that for you.

Here's a simple, readable function that recursively finds all subclasses of a given class:

<pre><code>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
</code></pre>

blocks|key|1126832|text|最简单的一般形式的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1126833|def+get_subclasses(cls):
++++for+subclass+in+cls.__subclasses__():
++++++++yield+from+get_subclasses(subclass)
++++++++yield+subclass|code-block|syntax|javascript|1126834|如果你有一个继承自的类，还有一个类方法：|1126835|@classmethod
def+get_subclasses(cls):
++++for+subclass+in+cls.__subclasses__():
++++++++yield+from+subclass.get_subclasses()
++++++++yield+subclass|1126836|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The simplest solution in general form:

<pre><code>def get_subclasses(cls):
 for subclass in cls.__subclasses__():
 yield from get_subclasses(subclass)
 yield subclass
</code></pre>

And a classmethod in case you have a single class where you inherit from:

<pre><code>@classmethod
def get_subclasses(cls):
 for subclass in cls.__subclasses__():
 yield from subclass.get_subclasses()
 yield subclass
</code></pre>

blocks|key|1126880|text|用于获取所有子类列表的更短的版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1126881|from+itertools+import+chain

def+subclasses(cls):
++++return+list(
++++++++chain.from_iterable(
++++++++++++[list(chain.from_iterable([[x],+subclasses(x)]))+for+x+in+cls.__subclasses__()]
++++++++)
++++)|code-block|syntax|javascript|1126882|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A much shorter version for getting a list of all subclasses:

<pre><code>from itertools import chain

def subclasses(cls):
 return list(
 chain.from_iterable(
 [list(chain.from_iterable([[x], subclasses(x)])) for x in cls.__subclasses__()]
 )
 )
</code></pre>

blocks|key|1126942|text|下面是一个没有递归的版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1126943|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],+[])|code-block|syntax|javascript|1126944|这与其他实现的不同之处在于它返回原始类。这是因为它使代码更简单，并且：|1126945|class+Ham(object):
++++pass

assert(issubclass(Ham,+Ham))+#+True|1126946|如果get_subclasses_gen看起来有点奇怪，那是因为它是通过将尾递归实现转换为循环生成器而创建的：|1126947|def+get_subclasses(cls):

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

++++++++return+_subclasses(subclasses,+found)

++++return+_subclasses([cls],+[])|1126948|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Here's a version without recursion:

<pre><code>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], [])
</code></pre>

This differs from other implementations in that it returns the original class.
This is because it makes the code simpler and:

<pre><code>class Ham(object):
 pass

assert(issubclass(Ham, Ham)) # True
</code></pre>

If get_subclasses_gen looks a bit weird that's because it was created by converting a tail-recursive implementation into a looping generator:

<pre><code>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], [])
</code></pre>

blocks|key|912032|text|下面是一个简单但高效的代码版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|912033|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)|code-block|syntax|javascript|912034|它的时间复杂度是O(n)，其中n是所有子类的数量，如果没有多重继承的话。它比递归创建列表或生成带有生成器的类的函数更有效，后者的复杂性可能是(1)当类层次结构是平衡树时是O(nlogn)，或者(2)当类层次结构是有偏树时是O(n%5E2)。|offset|length|style|CODE|912035|entityMap^0|0|0|8|4|F|1|2D|8|33|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|N|$]]

Here is a simple but efficient version of code:
<pre><code>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)
</code></pre>
Its time complexity is <code>O(n)</code> where <code>n</code> is the number of all subclasses if there's no multiple inheritance.
It's more efficient than the functions that recursively create lists or yield classes with generators, whose complexity could be (1) <code>O(nlogn)</code> when the class hierarchy is a balanced tree or (2) <code>O(n^2)</code> when the class hierarchy is a biased tree.

I need a working approach of getting all classes that are inherited from a base class in Python.

How to find all the subclasses of a class given its name?

我需要一种有效的方法来获得所有的类，这些类是从Python的基类继承而来的。

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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