如何在Python中获得当前模块中所有类的列表?

我不知道是否有一个“合适的”方法来做到这一点，但你的代码片段是在正确的轨道上:只需将import foo添加到foo.py，执行inspect.getmembers(foo)，它应该可以正常工作。

试试这个:

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 pyclbr
print(pyclbr.readmodule(__name__).keys())

注意，stdlib的Python类浏览器模块使用静态源分析，因此它只适用于由真正的.py文件支持的模块。

我能够从内置的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']
)
))

另一个适用于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()

如果你想拥有所有属于当前模块的类，你可以使用这个:

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上使用的谓词中。这个语句检查类是否真的属于模块。

谓词是返回布尔值的函数(可调用)。

我觉得你可以这样做。

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())`

如果你需要自己的类

这是一行，我用来获得所有的类，已定义在当前模块(即未导入)。根据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__]

在我的经验中，这是更有用的。

我经常发现自己在编写命令行实用程序时，第一个参数指的是许多不同类中的一个。例如./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

import Foo
dir(Foo)


import collections
dir(collections)

进入Python解释器。输入帮助(“module_name”)，然后按Enter。 例:帮助(“操作系统”)。 在这里，我将输出的一部分粘贴在下面:

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

以下内容可以放在文件的顶部:

def get_classes():
import inspect, sys
return dict(inspect.getmembers(
sys.modules[__name__],
lambda member: inspect.isclass(member) and member.__module__ == __name__
))

注意，这可以放在模块的顶部，因为我们已经将逻辑包装在函数定义中。如果希望字典作为顶级对象存在，则需要将定义放在文件的底部，以确保包括所有类。