一個方法調用多個實例

Question

我在Character類中有一個函數update() ，這樣，每次創建類字符的實例時，都需要在主循環中調用update方法，例如：

troll = Character()
monster = Character()

while True:
   troll.update()
   monster.update()

很好，但是如果我要有很多Character類的實例，那是不干凈的。

我知道可以使用@classmethod annotation來完成。 但是我不想這樣做，還有其他方法嗎？

有什么建議么？

Answer 1

利用在類中存儲數據的優勢。

class Character():
    instances = []

    def __init__(self):
        Character.instances.append(self)
        self.x = 0

    def class_update(self):
        for x in self.instances:
            x.instance_update()

    def instance_update(self):
        self.x += 1

A = Character()
B = Character()

A.class_update()
B.class_update()

C = Character()

C.class_update()

print Character.instances
print A, B, C
print A.x, B.x, C.x

輸出-

[<__main__.Character instance at 0x10a8523f8>, <__main__.Character instance at 0x10a852440>, <__main__.Character instance at 0x10a852488>]
<__main__.Character instance at 0x10a8523f8> <__main__.Character instance at 0x10a852440> <__main__.Character instance at 0x10a852488>
3 3 1

我不了解這種方法的陷阱，而無需更多地了解您需要完成什么。

Answer 2

您可以將所有Character對象保留在dict ：

characters = {}
characters["troll"] = Character()
characters["monster"] = Character()

然后，更新所有角色都很容易：

for character in characters.values():
    character.update()

Answer 3

您不能在這里使用類方法，因為類方法不適用於實例，而是適用於所有子畫面共享的類的某些部分。

假設您的角色具有用於移動精靈的更新方法。 所以看起來像這樣：

def update(self):
    self.pos = (self.pos[0] + self.v[0], self.pos[1] + self.v[1])

如果要將其設為類方法，則第一個參數將是類，而不是實例，因此除非類本身具有實例列表，否則無法從類方法中更改實例。

您應該采取的方法應取決於游戲的大小。

對於初學者，只需將它們放在列表中，然后迭代以調用每個實例更新方法。

另一種方法是像RyPeck所建議的那樣，在類中包含一個字符列表。 我認為將列表存儲在主程序中會更好，因為該類無需了解任何實例的存在。

Answer 4

我認為您正在尋找的是復合模式 。 您創建一個包含所有Character實例的CompositeCharacter類。 然后，您可以在CompositeCharacter對象中調用一個update方法，該對象將迭代地對其所有子對象（您的Character對象集合）調用update方法。

您可以像這樣定義您的復合類，或對此類進行一些變體。 關鍵是您實例化的CompositeCharacter對象將具有一個內部列表，並提供操作該列表的方法。

class CompositeCharacter():
    children = []

    def update(self):
        for c in self.children:
            c.update()

    def add(self, char):
        self.children.append(char)

在代碼的開頭，您將復合字符對象實例化為一些變量引用……例如compCharacters。

compCharacters = CompositeCharacter()

或者您可以根據一些分組的字符類實例化許多CompositeCharacters

trollCharacters = CompositeCharacter()
monsterCharacters = CompositeCharacter()
humanCharacters = CompositeCharacter()

然后，當實例化各個Character（）時，將它們添加到適當的CompositeCharacter對象。

troll = Character()
compCharacters.add(troll)    OR trollCharacters.add(troll)
monster = Character()
compCharacters.add(monster)  OR monsterCharacters.add(monster)

如果已將它們添加到常規復合對象（compCharacters）中，則只需對該對象調用更新

compCharacters.update()

或者，如果您使用了專門的分組，則可以在要更新的任何組上調用更新。

trollCharacters.update()

要么

monsterCharacters.update()

要么

humanCharacters.update()

您還可以將所有專門的復合對象保留在父復合對象中。 然后，您可以根據需要調用全局更新，也可以調用專門的更新。

compCharacters = CompositeCharacter()

trollCharacters = CompositeCharacter()
compCharacters.add(trollCharacters)

monsterCharacters = CompositeCharacter()
compCharacters.add(monsterCharacters)

humanCharacters = CompositeCharacter()
compCharacters.add(humanCharacters)

然后要調用全局更新，只需調用comp

compCharacters.update()