有没有办法即时创建子类？

Question

我正在创建一个游戏，其中我有一个有点复杂的方法来创建实体。

加载关卡时，加载代码会读取一堆 YAML 文件，其中包含所有不同可能单元的属性。它使用 YAML 文件创建一个所谓的 EntityResource 对象。该 EntityResource 对象在生成新单位时充当权威信息源。目标有两个：

1. 通过对 YAML 文件的输出实施哈希检查来阻止作弊
2. 通过让所有单元信息都来自单一的权威来源来帮助调试。

然后，这些 EntityResource 对象被输入到 EntityFactory 对象中以生成特定类型的单元。

我的问题如下。有没有办法根据读入的 YAML 文件的内容动态创建 EntityResource 的子类？

另外，我希望为每个 YAML 文件派生的子类分配一个单例元类。有什么注意事项吗？

Answer 1

我不确定这是否是您要找的，但您可以使用 type 动态创建子类：

SubClass = type('SubClass', (EntityResource,), {})

编辑：要了解 type 的工作原理，您只需翻译如何编写该类并将其转换为 type 调用。例如，如果您想编写如下内容：

class SubClass(EntityResource):
    A=1
    B=2

then，则将被翻译为：

 SubClass = type('SubClass', (EntityResource,), {'A': 1, 'B': 2})

其中：

• 第一个参数只是类名
• 第二个参数是父类列表
• 第三个参数是初始化类对象的字典。这不仅包括类属性，还包括方法。

Answer 2

可以动态创建子类。这并不意味着您应该这样做。无论如何，我都会提供一个机制。

每个类中的 bases 属性告诉您继承链：

class Animal(object):
    pass

class Dog(Animal):
    pass

print Animal.__bases__
print Dog.__bases__
# prints:
#(<type 'object'>,)
#(<class '__main__.Animal'>,)

因此，__bases__ 是一个具有“继承基”的元组。您可以替换此元组（您不能“追加到它”或“从中弹出”，因为它是一个元组，并且元组是不可变的）。例如，假设您有一个“mixin 类”，它向某些动物子类添加功能，但不向其他动物子类添加功能：

class Animal(object):
    pass

class Dog(Animal):
    pass

class Cat(Animal):
    pass

class TalkMixin(object):
    def talk(self):
        print("I talk like a {0}".format(self.__class__.__name__))

if __name__ == "__main__":

    dog = Dog()
    cat = Cat()

    try:
        dog.talk() 
        cat.talk()
    except AttributeError:
        print("Great - the program raised AttributeError, as expected")

    # now, add the MixIn to the class "Dog", but not to the class
    # "Cat" - do this on the fly:
    old_dog_bases = Dog.__bases__
    Dog.__bases__ = (Animal, TalkMixin)

    # this should be successful!
    dog.talk()

    try:
        cat.talk()
    except AttributeError:
        print("As expected, cat.talk() raised AttributeError")

    # now do the same (add the mixin dynamically - via inheritance) to
    # the Cat
    old_cat_bases = Cat.__bases__
    Cat.__bases__ = (Animal, TalkMixin)

    # this should be successful!
    cat.talk()

    # Now, remove the mixin (drop from the inheritance) for both cats
    # and dogs:
    Dog.__bases__ = old_dog_bases
    Cat.__bases__ = old_cat_bases

    try:
        dog.talk()
        cat.talk()
    except AttributeError:
        print("as expected, they can no longer talk")

产生以下输出：

Great - the program raised AttributeError, as expected
I talk like a Dog
As expected, cat.talk() raised AttributeError
I talk like a Cat
as expected, they can no longer talk

很多人认为 MixIn 类是邪恶的。他们可能是对的！您可以想象，如果您弄乱了 bases 属性，那么您的程序几乎就毁了。所以，就是这样 - 您可以动态更改对象的继承，但这并不意味着您应该（可能是抽象类或概念实现？）

Answer 3

当我听到“动态创建子类”时，我理解“动态创建行为不同的对象”，这实际上是一个配置问题。

有没有什么东西是您无法通过读取某些数据并创建一个对象来获得的，该对象根据读取的内容来决定它的行为方式？

这是一个比喻：我是一个手巧的人——我可以组装你扔给我的任何宜家物品。但我每次都不是不同的人，我只是同一个人，阅读不同的图表并寻找不同类型的螺钉和木块。这就是我认为子类化不是自然解决方案的原因。