从 Django 中的基本模型实例返回代理模型实例的正确方法？

Question

假设我有模型：

class Animal(models.Model):
    type = models.CharField(max_length=255)

class Dog(Animal):
    def make_sound(self):
        print "Woof!"
    class Meta:
        proxy = True

class Cat(Animal):
    def make_sound(self):
        print "Meow!"
    class Meta:
        proxy = True

假设我想做：

 animals = Animal.objects.all()
 for animal in animals:
     animal.make_sound()

我想要取回一系列的汪汪声和喵声。显然，我可以在基于 Animal_type 分叉的原始模型中定义 make_sound，但是每次我添加新的动物类型（想象它们位于不同的应用程序中）时，我都必须进入并编辑 make_sound 函数。我宁愿只定义代理模型并让它们自己定义行为。据我所知，无法返回混合的 Cat 或 Dog 实例，但我想也许我可以在返回猫或狗模型的主类上定义一个“get_proxy_model”方法。

当然，您可以这样做，并传递诸如主键之类的内容，然后只需执行 Cat.objects.get(pk = Passed_in_primary_key) 即可。但这意味着对已有的数据进行额外的查询，这似乎是多余的。有什么方法可以有效地将动物变成猫或狗实例吗？实现我想要实现的目标的正确方法是什么？

Answer 1

我尝试了很多方法来做到这一点。最后，最简单的似乎就是前进的道路。
覆盖基类的__init__。

class Animal(models.Model):
    type = models.CharField(max_length=255)
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.__class__ = eval(self.type)

我知道 eval 可能很危险，等等，但是您始终可以在类型选择上添加保护/验证，以确保它是您想要看到的。
除此之外，我想不出任何明显的陷阱，但如果我发现任何陷阱，我会提及它们/删除答案！ （是的，我知道这个问题非常老，但希望这能帮助其他遇到同样问题的人）

Answer 2

您或许可以使用此处描述的方法使 Django 模型具有多态性。我相信该代码处于开发的早期阶段，但值得研究。

Answer 3

这个答案可能在某种程度上回避了这个问题，因为它不使用代理模型。然而，正如问题所提出的，它确实让人们编写以下内容（如果添加新类型，则无需更新 Animal 类）——

animals = Animal.objects.all()
for animal in animals:
    animal.make_sound()

为了避免元类编程，可以使用 组合优于继承。例如，

class Animal(models.Model):

    type = models.CharField(max_length=255)

    @property
    def type_instance(self):
        """Return a Dog or Cat object, etc."""
        return globals()[self.type]()

    def make_sound(self):
        return self.type_instance.make_sound()

class Dog(object):
    def make_sound(self):
        print "Woof!"

class Cat(object):
    def make_sound(self):
        print "Meow!"

如果 Dog 和 Cat 类需要访问 Animal 实例，您还可以调整 type_instance()<上面的 /code> 方法将其所需的内容传递给类构造函数（例如 self）。

Answer 4

thedk 提出的元类方法确实是一种非常强大的方法，但是，我必须将其与问题的答案结合起来 此处让查询返回代理模型实例。适用于前面示例的代码的简化版本是：

from django.db.models.base import ModelBase

class InheritanceMetaclass(ModelBase):
    def __call__(cls, *args, **kwargs):
        obj = super(InheritanceMetaclass, cls).__call__(*args, **kwargs)
        return obj.get_object()

class Animal(models.Model):
    __metaclass__ = InheritanceMetaclass
    type = models.CharField(max_length=255)
    object_class = models.CharField(max_length=20)

    def save(self, *args, **kwargs):
        if not self.object_class:
            self.object_class = self._meta.module_name
        super(Animal, self).save( *args, **kwargs)

    def get_object(self):
        if self.object_class in SUBCLASSES_OF_ANIMAL:
            self.__class__ = SUBCLASSES_OF_ANIMAL[self.object_class]
        return self

class Dog(Animal):
    class Meta:
        proxy = True
    def make_sound(self):
        print "Woof!"


class Cat(Animal):
    class Meta:
        proxy = True
    def make_sound(self):
        print "Meow!"


SUBCLASSES_OF_ANIMAL = dict([(cls.__name__, cls) for cls in ANIMAL.__subclasses__()])

这种代理方法的优点是创建新子类时不需要数据库迁移。缺点是子类中不能添加特定的字段。

我很高兴收到有关此方法的反馈。

Answer 5

人类已知的唯一方法是使用元类编程。

这是简短的答案：

from django.db.models.base import ModelBase

class InheritanceMetaclass(ModelBase):
    def __call__(cls, *args, **kwargs):
        obj = super(InheritanceMetaclass, cls).__call__(*args, **kwargs)
        return obj.get_object()

class Animal(models.Model):
    __metaclass__ = InheritanceMetaclass
    type = models.CharField(max_length=255)
    object_class = models.CharField(max_length=20)

    def save(self, *args, **kwargs):
        if not self.object_class:
            self.object_class = self._meta.module_name
        super(Animal, self).save( *args, **kwargs)
    def get_object(self):
        if not self.object_class or self._meta.module_name == self.object_class:
            return self
        else:
            return getattr(self, self.object_class)

class Dog(Animal):
    def make_sound(self):
        print "Woof!"


class Cat(Animal):
    def make_sound(self):
        print "Meow!"

以及期望的结果：

shell$ ./manage.py shell_plus
From 'models' autoload: Animal, Dog, Cat
Python 2.6.5 (r265:79063, Apr 16 2010, 13:57:41) 
[GCC 4.4.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> dog1=Dog(type="Ozzie").save()
>>> cat1=Cat(type="Kitty").save()
>>> dog2=Dog(type="Dozzie").save()
>>> cat2=Cat(type="Kinnie").save()
>>> Animal.objects.all()
[<Dog: Dog object>, <Cat: Cat object>, <Dog: Dog object>, <Cat: Cat object>]
>>> for a in Animal.objects.all():
...    print a.type, a.make_sound()
... 
Ozzie Woof!
None
Kitty Meow!
None
Dozzie Woof!
None
Kinnie Meow!
None
>>> 

它是如何工作的？

1. 存储有关班级的信息
   动物的名字 - 我们使用
   object_class
2. 删除“代理”元属性 - 我们需要
   Django 中的反向关系（不好的
   我们创建额外的数据库
   每个儿童模型的表格和
   为此浪费额外的数据库命中，
   好的一面是我们可以添加一些孩子
   模型相关字段）
3. 为 Animal 自定义 save() 来保存类
   对象的 object_class 中的名称
   调用保存。
4. 需要方法get_object来引用
   通过Django中的反向关系
   到名称缓存在的模型
   对象_类。
5. 自动执行此 .get_object() “转换”
   每次 Animal 被实例化时
   重新定义动物元类
   模型。元类就像是
   类的模板（就像
   类是对象的模板）。

有关 Python 中元类的更多信息：http://www.ibm.com/ developerworks/linux/library/l-pymeta.html