在运行时创建类时，使用 exec 而不是 type() 有什么优势？

Question

我想在运行时在 python 中动态创建类。

例如，我想复制下面的代码：

>>> class RefObj(object):
...     def __init__(self, ParentClassName):
...         print "Created RefObj with ties to %s" % ParentClassName
... class Foo1(object):
...     ref_obj = RefObj("Foo1")
... class Foo2(object):
...     ref_obj = RefObj("Foo2")
... 
Created RefObj with ties to Foo1
Created RefObj with ties to Foo2
>>>

...但我希望动态创建 Foo1、Foo2、Foo 类（即：在执行期间而不是在首次编译时）。

实现此目的的一种方法是使用type()，如下所示：

>>> class RefObj(object):
...     def __init__(self, ParentClassName):
...         print "Created RefObj with ties to %s" % ParentClassName
... def make_foo_class(index):
...     name = "Foo%s" % index
...     return type(name, (object, ), dict(ref_obj = RefObj(name)))
... 
>>> Foo1 = make_foo_class(1)
Created RefObj with ties to Foo1
>>> Foo2 = make_foo_class(2)
Created RefObj with ties to Foo2
>>> type(Foo1()), type(Foo2())
(<class 'Foo1'>, <class 'Foo2'>)

我也可以用exec 实现，像这样：

>>> class RefObj(object):
...     def __init__(self, ParentClassName):
...         print "Created RefObj with ties to %s" % ParentClassName
... def make_foo_object(index):
...     class_template = """class Foo%(index)d(object):
...         ref_obj = RefObj("Foo%(index)d")
...         """ % dict(index = index)
...     global RefObj
...     namespace = dict(RefObj = RefObj)
...     exec class_template in namespace
...     return namespace["Foo%d" % index]
... 
>>> Foo1 = make_foo_object(1)
Created RefObj with ties to Foo1
>>> Foo2 = make_foo_object(2)
Created RefObj with ties to Foo2
>>> type(Foo1()), type(Foo2())
(<class 'Foo1'>, <class 'Foo2'>)

exec 的使用并不适合我（因为我预计很多阅读此问题的人不会这样做）但exec 完全是 python 的@ 987654336@ 类is implemented（见this line）。同样非常相关的是类的创建者（Raymond Hettinger）对exechere的这种使用的辩护。在这个辩护中，声明“命名元组的一个关键特征是它们完全等同于手写类”，这可能意味着使用type()还不如用exec...

有区别吗？为什么使用exec 与type()？

我希望答案可能是两种方式都是相同的，只是 namedtuple 实现有很多 namedtuple 变量贯穿其中，并且通过为所有方法动态生成闭包来执行此操作使代码变得笨拙，但我想知道这是否还有其他内容。

关于我对exec 的不适，我确实认识到，如果不受信任的各方无法向其中注入恶意代码，那应该没问题...只是确保这让我感到紧张。

Answer 1

我会在这里推荐type 而不是exec。

事实上，class 语句只是调用type 的语法糖：类主体在其自己的命名空间内执行，然后传递给元类，如果没有，则默认为type已指定自定义元类。

这种方法不太容易出错，因为不需要在运行时解析代码，甚至可能会更快一些。

Answer 2

为什么不在函数中创建一个类？

def foo_factory(index):
    name = 'Foo%d' % index

    class Foo(object):
        ref_obj = RefObj(name)

    Foo.__name__ = name
    return Foo

Answer 3

使用 type() 而不是 exec 没有任何缺点。我认为雷蒙德的防守有点防守。您必须选择您认为最易读和易于理解的技术。这两种方式都会产生令人困惑的代码。

你应该尽量避免一开始就创建类的代码，这是最好的。