在游戏实体类中进行代码重用的 Pythonic 方式

Question

我开始为我正在编写的游戏定义我的实体类。但是，我想要很多代码重用。我想为不同的功能定义类，然后让类“具有”其中一些类的功能。

例如：

class Collidable:
    def handle_collision(other, incident_vector):
        pass

    def __init__(self, shape):
        self.shape = shape

class Movable:
    def update_position(self):
        self.velocity += self.acceleration
        self.position += self.velocity

    def __init__(self, velocity, acceleration):
        self.velocity, self.acceleration = velocity, acceleration

class Drawable:
    def draw(self):
        pass

    def __init__(self, image):
        self.image = image

class Controllable:
    def key_down(self, key):
        pass

    def __init__(self):
        pass

然后有一个 Player 类，它是 Collidable、Movable、Drawable、Controllable，一个 Invisible Barrier，它只是 Collidable，一个 Background，它只是 Drawable，等等。我听说过许多不同的连接方式多个类，（例如通过组合、（多个）继承、接口等），但我不知道哪种最适合这种情况和/或 Pythonic。

Mix-ins（多重继承的特殊情况）看起来是我正在寻找的（因为 Player 应该是 Collidable、Movable、Drawable 和 Controllable），但在尝试这个时，我'我发现使用 super 将正确的参数传递给正确的 init 函数有困难。

编辑：

我正在使用 python 3.2。

Answer 1

Mixins 是要走的路，但你不想在它们上调用__init__：

class CollidableMixin(object):
    #...
    def init_collidable(self, shape):
        self.shape = shape

class MovableMixin(object):
    #...
    def init_movable(self, velocity, acceleration):
        self.velocity, self.acceleration = velocity, acceleration

class DrawableMixin(object):
    #...
    def init_drawable(self, image):
        self.image = image

在我看来，您不需要为Controllable 单独的类，因为它只是定义了继承类应该具有的接口。虽然您在 Java 等静态类型语言中经常这样做，但在 Python 中则不需要。相反，您只需定义一个 key_down 方法并完成它。这称为鸭子打字。

在示例实现中，这将如下所示：

class Player(CollidableMixin, DrawableMixin, MovableMixin):
    def __init__(self):
        self.init_collidable(...)
        self.init_drawable(...)
        self.init_movable(...)

    def key_down(self, key):
        # ...

objects = []
objects.append(Player())
# ... add some more objects. Later we iterate through that collection,
# not knowing which of them is a player:
for o in objects:
    try:
        o.key_down(...)
    except AttributeError:
        pass

Answer 2

这是使用super() 实现继承的简单方法。为此，您将始终需要使用关键字参数创建 Player 的实例（以及从您的 ***able 类继承的其他类）。每个基类都会从 kwargs 中删除它正在使用的任何关键字参数，并将其余的传递给 mro 中的下一个 __init__()，例如：

class Collidable(object):
    def handle_collision(other, incident_vector):
        pass

    def __init__(self, shape, **kwargs):
        self.shape = shape
        super(Collidable, self).__init__(**kwargs)

class Movable(object):
    def update_position(self):
        self.velocity += self.acceleration
        self.position += self.velocity

    def __init__(self, velocity, acceleration, **kwargs):
        self.velocity, self.acceleration = velocity, acceleration
        super(Movable, self).__init__(**kwargs)

class Drawable(object):
    def draw(self):
        pass

    def __init__(self, image, **kwargs):
        self.image = image
        super(Drawable, self).__init__(**kwargs)

class Controllable(object):
    def key_down(self, key):
        pass

    def __init__(self, **kwargs):
        super(Controllable, self).__init__(**kwargs)

然后你可以定义你的Player 类：

class Player(Collidable, Movable, Drawable, Controllable):
    pass

并像这样使用它：

>>> p = Player(shape='circle', velocity=0.0, acceleration=1.0, image='player.png')
>>> p.shape
'circle'
>>> p.velocity
0.0
>>> p.acceleration
1.0

如果您需要 Player 类的其他实例变量，您可以定义一个类似于其他类的 __init__()，例如：

class Player(Collidable, Movable, Drawable, Controllable):
    def __init__(name, **kwargs):
        self.name = name
        super(Player, self).__init__(**kwargs)