Как я могу получить список всех классов в текущем модуле в Python?

Я видел множество примеров людей, извлекающих все классы из модуля, обычно что-то вроде:

# foo.py
class Foo:
    pass

# test.py
import inspect
import foo

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

Потрясающие.

Но я не могу узнать, как получить все классы из текущего модуля.

# foo.py
import inspect

class Foo:
    pass

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

# test.py
import foo

foo.print_classes()

Это, наверное, что-то действительно очевидное, но я не смог ничего найти. Может кто-нибудь мне помочь?

Попробуй это:

import sys
current_module = sys.modules[__name__]

В вашем контексте:

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

И даже лучше:

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

Потому что inspect.getmembers()принимает предикат.

Что о

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

?

Я не знаю, есть ли «правильный» способ сделать это, но ваш фрагмент находится на правильном пути: просто добавьте import fooв foo.py, сделайте inspect.getmembers(foo), и он должен работать нормально.

Я смог получить все, что мне нужно от dirвстроенного плюса 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)

Тем не менее, он выглядит как шарик:

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

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

import pyclbr
print(pyclbr.readmodule(__name__).keys())

Обратите внимание, что модуль браузера класса Python stdlib использует статический анализ исходного кода, поэтому он работает только для модулей, которые поддерживаются реальным .pyфайлом.

Если вы хотите иметь все классы, принадлежащие текущему модулю, вы можете использовать это:

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)

Если вы используете ответ Nadia и импортировали другие классы в свой модуль, эти классы также будут импортированы.

Вот почему member.__module__ == __name__он добавляется к предикату, используемому для is_class_member. Это утверждение проверяет, что класс действительно принадлежит модулю.

Предикат - это функция (вызываемая), которая возвращает логическое значение.

Другое решение, которое работает в Python 2 и 3:

#foo.py
import sys

class Foo(object):
    pass

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

# test.py
import foo
foo.print_classes()

Это строка, которую я использую, чтобы получить все классы, которые были определены в текущем модуле (т.е. не импортированы). Согласно PEP-8, он немного длинный, но вы можете изменить его по своему усмотрению.

import sys
import inspect

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

Это дает вам список имен классов. Если вы хотите, чтобы сами объекты класса просто оставляли объект obj.

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

Это было более полезным в моем опыте.

import Foo 
dir(Foo)

import collections
dir(collections)

Я думаю, что вы можете сделать что-то подобное.

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

если вам нужны собственные занятия

Я часто пишу утилиты командной строки, где первый аргумент предназначен для ссылки на один из множества различных классов. Например ./something.py feature command —-arguments, где Featureкласс и commandметод этого класса. Вот базовый класс, который делает это легко.

Предполагается, что этот базовый класс находится в каталоге вместе со всеми его подклассами. Затем вы можете позвонить, ArgBaseClass(foo = bar).load_subclasses()который вернет словарь. Например, если каталог выглядит так:

• arg_base_class.py
• feature.py

Предполагая feature.pyреализации class Feature(ArgBaseClass), тогда приведенный выше вызов load_subclassesвернется { 'feature' : <Feature object> }. То же самое kwargs( foo = bar) будет передано в Featureкласс.

#!/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