reflection – How can I get a list of all classes within current module in Python?

The Question :

326 people think this question is useful

I’ve seen plenty of examples of people extracting all of the classes from a module, usually something like:

class Foo:

import inspect
import foo

for name, obj in inspect.getmembers(foo):
    if inspect.isclass(obj):
        print obj


But I can’t find out how to get all of the classes from the current module.

import inspect

class Foo:

def print_classes():
    for name, obj in inspect.getmembers(???): # what do I do here?
        if inspect.isclass(obj):
            print obj

import foo


This is probably something really obvious, but I haven’t been able to find anything. Can anyone help me out?

The Question Comments :
  • There was a PEP for a feature like this, but it was rejected.
  • What’s wrong with reading the source for "class"? Why won’t that work?
  • I’m guessing the question is about wanting to automate some task, so it’s important that it be done programmatically. Presumably the questioner thinks that doing it manually, by reading the source code with your eyes, might be repetitive, error-prone or time-consuming.

The Answer 1

409 people think this answer is useful

Try this:

import sys
current_module = sys.modules[__name__]

In your context:

import sys, inspect
def print_classes():
    for name, obj in inspect.getmembers(sys.modules[__name__]):
        if inspect.isclass(obj):

And even better:

clsmembers = inspect.getmembers(sys.modules[__name__], inspect.isclass)

Because inspect.getmembers() takes a predicate.

The Answer 2

19 people think this answer is useful

What about

g = globals().copy()
for name, obj in g.iteritems():


The Answer 3

16 people think this answer is useful

I don’t know if there’s a ‘proper’ way to do it, but your snippet is on the right track: just add import foo to, do inspect.getmembers(foo), and it should work fine.

The Answer 4

11 people think this answer is useful

I was able to get all I needed from the dir built in plus getattr.

# Works on pretty much everything, but be mindful that 
# you get lists of strings back

print dir(myproject)
print dir(myproject.mymodule)
print dir(myproject.mymodule.myfile)
print dir(myproject.mymodule.myfile.myclass)

# But, the string names can be resolved with getattr, (as seen below)

Though, it does come out looking like a hairball:

def list_supported_platforms():
        List supported platforms (to match sys.platform)

            list str: platform names
    return list(itertools.chain(
            # Get the class's constant
                # Get the module's first class, which we wrote
                    # Get the module
                    getattr(platforms, item),
                        getattr(platforms, item)
            # For each include in platforms/ 
            for item in dir(platforms)
            # Ignore magic, ourselves ( and a base class.
            if not item.startswith('__') and item not in ['index', 'base']

The Answer 5

8 people think this answer is useful
import pyclbr

Note that the stdlib’s Python class browser module uses static source analysis, so it only works for modules that are backed by a real .py file.

The Answer 6

5 people think this answer is useful

If you want to have all the classes, that belong to the current module, you could use this :

import sys, inspect
def print_classes():
    is_class_member = lambda member: inspect.isclass(member) and member.__module__ == __name__
    clsmembers = inspect.getmembers(sys.modules[__name__], is_class_member)

If you use Nadia’s answer and you were importing other classes on your module, that classes will be being imported too.

So that’s why member.__module__ == __name__ is being added to the predicate used on is_class_member. This statement checks that the class really belongs to the module.

A predicate is a function (callable), that returns a boolean value.

The Answer 7

3 people think this answer is useful

Another solution which works in Python 2 and 3:
import sys

class Foo(object):

def print_classes():
    current_module = sys.modules[__name__]
    for key in dir(current_module):
        if isinstance( getattr(current_module, key), type ):

import foo

The Answer 8

3 people think this answer is useful

This is the line that I use to get all of the classes that have been defined in the current module (ie not imported). It’s a little long according to PEP-8 but you can change it as you see fit.

import sys
import inspect

classes = [name for name, obj in inspect.getmembers(sys.modules[__name__], inspect.isclass) 
          if obj.__module__ is __name__]

This gives you a list of the class names. If you want the class objects themselves just keep obj instead.

classes = [obj for name, obj in inspect.getmembers(sys.modules[__name__], inspect.isclass)
          if obj.__module__ is __name__]

This is has been more useful in my experience.

The Answer 9

0 people think this answer is useful

I think that you can do something like this.

class custom(object):
    __custom__ = True
class Alpha(custom):
    something = 3
def GetClasses():
    return [x for x in globals() if hasattr(globals()[str(x)], '__custom__')]

if you need own classes

The Answer 10

0 people think this answer is useful

I frequently find myself writing command line utilities wherein the first argument is meant to refer to one of many different classes. For example ./ feature command —-arguments, where Feature is a class and command is a method on that class. Here’s a base class that makes this easy.

The assumption is that this base class resides in a directory alongside all of its subclasses. You can then call ArgBaseClass(foo = bar).load_subclasses() which will return a dictionary. For example, if the directory looks like this:


Assuming implements class Feature(ArgBaseClass), then the above invocation of load_subclasses will return { 'feature' : <Feature object> }. The same kwargs (foo = bar) will be passed into the Feature class.

#!/usr/bin/env python3
import os, pkgutil, importlib, inspect

class ArgBaseClass():
    # Assign all keyword arguments as properties on self, and keep the kwargs for later.
    def __init__(self, **kwargs):
        self._kwargs = kwargs
        for (k, v) in kwargs.items():
            setattr(self, k, v)
        ms = inspect.getmembers(self, predicate=inspect.ismethod)
        self.methods = dict([(n, m) for (n, m) in ms if not n.startswith('_')])

    # Add the names of the methods to a parser object.
    def _parse_arguments(self, parser):
        parser.add_argument('method', choices=list(self.methods))
        return parser

    # Instantiate one of each of the subclasses of this class.
    def load_subclasses(self):
        module_dir = os.path.dirname(__file__)
        module_name = os.path.basename(os.path.normpath(module_dir))
        parent_class = self.__class__
        modules = {}
        # Load all the modules it the package:
        for (module_loader, name, ispkg) in pkgutil.iter_modules([module_dir]):
            modules[name] = importlib.import_module('.' + name, module_name)

        # Instantiate one of each class, passing the keyword arguments.
        ret = {}
        for cls in parent_class.__subclasses__():
            path = cls.__module__.split('.')
            ret[path[-1]] = cls(**self._kwargs)
        return ret

The Answer 11

0 people think this answer is useful
import Foo 

import collections

The Answer 12

0 people think this answer is useful

Go to Python Interpreter. type help (‘module_name’) , then press Enter. e.g. help(‘os’) . Here, I’ve pasted one part of the output below:

class statvfs_result(__builtin__.object)
     |  statvfs_result: Result from statvfs or fstatvfs.
     |  This object may be accessed either as a tuple of
     |    (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),
     |  or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.
     |  See os.statvfs for more information.
     |  Methods defined here:
     |  __add__(...)
     |      x.__add__(y) <==> x+y
     |  __contains__(...)
     |      x.__contains__(y) <==> y in x

Add a Comment