从Python类/对象列表中动态调用方法

我有X个python类，所有这些类都继承自同一个抽象基类，它期望子类实现一个名为executeTest（）的方法

在我的主程序中，我需要一次加载继承这个基类的每个类的一个实例，调用executeTest（），并将结果记录到某种集合中供以后使用。随着人们想出新的测试来编写，实现TestCase的类的数量将继续增长

---

如何在python中高效地执行此操作？我是否需要有一个单独的XML或类似类型的文件，其中包含所有单个类名的列表，然后在for循环中使用某种类加载函数？这是我第一次晚上用python编写代码，所以我甚至不确定要搜索什么技术或关键字

使用decorator枚举类，并以列表理解方式执行方法。

我将尝试这样做：

1） 将抽象类保存在

test\u case.py

class TestCase:
    def executeTest():
        #do some logic for the test, then return if it passed or failed

from test_case import TestCase
class Test_Case_1(TestCase):
    def executeTest():
        #overriden function

class Test_Case_2(TestCase):
    def executeTest():
        #overriden function

class Test_Case_3(TestCase):
    def executeTest():
        #overriden function

class TestCase:
    def executeTest():
        #do some logic for the test, then return if it passed or failed

from test_case.test_case import TestCase
class Test_Case_1(TestCase):
    def executeTest():
        #overriden function

from test_case.test_case import TestCase
class Test_Case_2(TestCase):
    def executeTest():
        #overriden function

from test_case.test_case import TestCase
class Test_Case_3(TestCase):
    def executeTest():
        #overriden function

2） 在

test\u case\u children.py中保存所有子类

class TestCase:
    def executeTest():
        #do some logic for the test, then return if it passed or failed

from test_case import TestCase
class Test_Case_1(TestCase):
    def executeTest():
        #overriden function

class Test_Case_2(TestCase):
    def executeTest():
        #overriden function

class Test_Case_3(TestCase):
    def executeTest():
        #overriden function

class TestCase:
    def executeTest():
        #do some logic for the test, then return if it passed or failed

from test_case.test_case import TestCase
class Test_Case_1(TestCase):
    def executeTest():
        #overriden function

from test_case.test_case import TestCase
class Test_Case_2(TestCase):
    def executeTest():
        #overriden function

from test_case.test_case import TestCase
class Test_Case_3(TestCase):
    def executeTest():
        #overriden function

3） 将主功能保存在
main.py
中：

from test_case import TestCase
import test_case_children

def main():
    #grab the all the elements in the script 'test_case_children'
    items = test_case_children.__dict__

    #build list of all 'TestCase' sub-classes
    test_classes = [] 
    for (key, value) in items.items():
        try:
            # check whether the item is a sub-class of 'TestCase' class
            if TestCase.__subclasscheck__(value):
                test_classes.append(value)
        except TypeError: #if item is not of type 'TestCase', ignore it
            pass

    #run the tests
    for test_class in test_classes:
        test_runner = test_class()
        test_runner.executeTest()


# this will run main() method, only when script is directly executed 
# from shell or command prompt ...
if __name__ == "__main__":
    main()

from test_case import TestCase
from test_case import test_case_children

def main():
    #grab the all the elements in the module 'test_case_children'
    items = test_case_children.__dict__

    #build list of all 'TestCase' sub-classes
    test_classes = []
    for (dict_key, dict_value) in items:
        #check whether the type of item's value is a module,
        # if its a module it's likely to contain a TestCase subclass...
        if str(type(dict_value)) == "<type 'module'>":
            for (key, value) in dict_value.items():
                try:
                    # check whether the item is a sub-class of 'TestCase' class
                    if TestCase.__subclasscheck__(value):
                        test_classes.append(value)
                except TypeError: #if item is not of type 'TestCase', ignore it
                    pass

    #run the tests
    for test_class in test_classes:
        test_runner = test_class()
        test_runner.executeTest()


# this will run main() method, only when script is directly executed 
# from shell or command prompt ...
if __name__ == "__main__":
    main()

4） 执行
main.py
脚本：

$ cd test_case/
$ python main.py

$python main.py

class TestCase:
    def executeTest():
        #do some logic for the test, then return if it passed or failed

from test_case import TestCase
class Test_Case_1(TestCase):
    def executeTest():
        #overriden function

class Test_Case_2(TestCase):
    def executeTest():
        #overriden function

class Test_Case_3(TestCase):
    def executeTest():
        #overriden function

class TestCase:
    def executeTest():
        #do some logic for the test, then return if it passed or failed

from test_case.test_case import TestCase
class Test_Case_1(TestCase):
    def executeTest():
        #overriden function

from test_case.test_case import TestCase
class Test_Case_2(TestCase):
    def executeTest():
        #overriden function

from test_case.test_case import TestCase
class Test_Case_3(TestCase):
    def executeTest():
        #overriden function

注意：还有一件事，您将保存这些文件的文件夹还应该包含一个空的
\uuu init\uuuu.py
文件，以使该文件夹成为python应用程序（类似于
Java
中的
packages
或
C++
中的
namespace
）。如果不这样做，那么这些导入语句可能无法工作

[从不同文件运行测试用例的更新]

1） 将文件保留在以下继承权中：

<root>/
------>test_case/
---------------->__init__.py
---------------->main.py
---------------->test_case.py
---------------->test_case_children/
--------------------------------->__init__.py
--------------------------------->test_case_1.py
--------------------------------->test_case_2.py
--------------------------------->test_case_3.py

3） 保存子类，如下所示：

文件：
test\u case/test\u case\u children/test\u case\u 1.py

class TestCase:
    def executeTest():
        #do some logic for the test, then return if it passed or failed

from test_case import TestCase
class Test_Case_1(TestCase):
    def executeTest():
        #overriden function

class Test_Case_2(TestCase):
    def executeTest():
        #overriden function

class Test_Case_3(TestCase):
    def executeTest():
        #overriden function

class TestCase:
    def executeTest():
        #do some logic for the test, then return if it passed or failed

from test_case.test_case import TestCase
class Test_Case_1(TestCase):
    def executeTest():
        #overriden function

from test_case.test_case import TestCase
class Test_Case_2(TestCase):
    def executeTest():
        #overriden function

from test_case.test_case import TestCase
class Test_Case_3(TestCase):
    def executeTest():
        #overriden function

文件：
test\u case/test\u case\u children/test\u case\u 2.py

class TestCase:
    def executeTest():
        #do some logic for the test, then return if it passed or failed

from test_case import TestCase
class Test_Case_1(TestCase):
    def executeTest():
        #overriden function

class Test_Case_2(TestCase):
    def executeTest():
        #overriden function

class Test_Case_3(TestCase):
    def executeTest():
        #overriden function

class TestCase:
    def executeTest():
        #do some logic for the test, then return if it passed or failed

from test_case.test_case import TestCase
class Test_Case_1(TestCase):
    def executeTest():
        #overriden function

from test_case.test_case import TestCase
class Test_Case_2(TestCase):
    def executeTest():
        #overriden function

from test_case.test_case import TestCase
class Test_Case_3(TestCase):
    def executeTest():
        #overriden function

文件：
test\u case/test\u case\u children/test\u case\u 3.py

class TestCase:
    def executeTest():
        #do some logic for the test, then return if it passed or failed

from test_case import TestCase
class Test_Case_1(TestCase):
    def executeTest():
        #overriden function

class Test_Case_2(TestCase):
    def executeTest():
        #overriden function

class Test_Case_3(TestCase):
    def executeTest():
        #overriden function

class TestCase:
    def executeTest():
        #do some logic for the test, then return if it passed or failed

from test_case.test_case import TestCase
class Test_Case_1(TestCase):
    def executeTest():
        #overriden function

from test_case.test_case import TestCase
class Test_Case_2(TestCase):
    def executeTest():
        #overriden function

from test_case.test_case import TestCase
class Test_Case_3(TestCase):
    def executeTest():
        #overriden function

4） 将主功能保存在
main.py
中：

from test_case import TestCase
import test_case_children

def main():
    #grab the all the elements in the script 'test_case_children'
    items = test_case_children.__dict__

    #build list of all 'TestCase' sub-classes
    test_classes = [] 
    for (key, value) in items.items():
        try:
            # check whether the item is a sub-class of 'TestCase' class
            if TestCase.__subclasscheck__(value):
                test_classes.append(value)
        except TypeError: #if item is not of type 'TestCase', ignore it
            pass

    #run the tests
    for test_class in test_classes:
        test_runner = test_class()
        test_runner.executeTest()


# this will run main() method, only when script is directly executed 
# from shell or command prompt ...
if __name__ == "__main__":
    main()

from test_case import TestCase
from test_case import test_case_children

def main():
    #grab the all the elements in the module 'test_case_children'
    items = test_case_children.__dict__

    #build list of all 'TestCase' sub-classes
    test_classes = []
    for (dict_key, dict_value) in items:
        #check whether the type of item's value is a module,
        # if its a module it's likely to contain a TestCase subclass...
        if str(type(dict_value)) == "<type 'module'>":
            for (key, value) in dict_value.items():
                try:
                    # check whether the item is a sub-class of 'TestCase' class
                    if TestCase.__subclasscheck__(value):
                        test_classes.append(value)
                except TypeError: #if item is not of type 'TestCase', ignore it
                    pass

    #run the tests
    for test_class in test_classes:
        test_runner = test_class()
        test_runner.executeTest()


# this will run main() method, only when script is directly executed 
# from shell or command prompt ...
if __name__ == "__main__":
    main()

我希望这对您有用。
这是一个元答案-这意味着我认为您应该考虑您的设计调用测试

在python中，有一些行之有效的编写测试的方法。[1]
还有一些工具可以收集所有可用的测试并执行它们（包括统计数据、覆盖率、xml输出等等）。[2]

如果我是你，我会看一看。如果你能使用它们，就没有必要重新发明轮子

[1] http://docs.python.org/library/unittest.html
[2] http://readthedocs.org/docs/nose/en/latest/

你有这样的例子吗？我不确定我是否理解你所说的“使用装饰器”是什么意思。我必须将每个测试用例保存在一个单独的类文件中。将来可能会有几百个。把它们都放在一个文件里太乱了。如果我只有三个或四个，这就行了。您仍然可以使用相同的解决方案，并在
main.py
文件中进行一些修改。您还可以获取包的dict（
\uuu dict\uu
）。然后遍历每个文件的包，并在这些文件中找到
TestCase
类的子类。我将在稍后更新答案。我现在有点忙。在此之前，您可以自己尝试。您可能对此感兴趣：您假设OP方法名称中的“测试”指的是单元测试。它可能与领域相关。我不执行单元测试。我正在测试网络探测的结果。每个测试都可以保存您想要的任何python源代码，例如网络探测-即使它被称为“unittest”。nosetests[2]使您能够收集所有测试并执行它们。