Gestion des instances en Python

Question

Je suis novice en Python et c'est la première fois que je pose une question sur stackOverflow, mais je suis un lecteur de longue date. Je travaille sur un jeu basé sur une carte simple mais j'ai du mal à gérer les instances de ma classe Hand. Si vous regardez ci-dessous vous pouvez voir que la classe main est un simple conteneur pour les cartes (qui sont juste des valeurs int) et chaque classe Player contient une classe main. Cependant, chaque fois que je crée plusieurs instances de ma classe Player, elles semblent toutes manipuler une seule instance de la classe Hand. D'après mon expérience en C et en Java, il semble que je rends ma classe Hand statique. Si quelqu'un pouvait aider avec ce problème, je l'apprécierais grandement.

Merci, Thad

Pour clarifier: Un exemple de cette situation serait

p = player.Player()
p1 = player.Player()
p.recieveCard (15)
p1.recieveCard (21)
p.viewHand()

qui se traduirait par: [15,21]
même si une seule carte a été ajouté à la page

classe des mains:

class Hand: 

    index = 0 
    cards = [] #Collections of cards 

    #Constructor 
    def __init__(self): 
     self.index 
     self.cards 

    def addCard(self, card): 
     """Adds a card to current hand""" 
     self.cards.append(card) 
     return card 

    def discardCard(self, card): 
     """Discards a card from current hand""" 
     self.cards.remove(card) 
     return card 

    def viewCards(self): 
     """Returns a collection of cards""" 
     return self.cards 

    def fold(self): 
     """Folds the current hand""" 
     temp = self.cards 
     self.cards = [] 
     return temp 

Classe du joueur

import hand 
class Player: 

name = "" 
position = 0 
chips = 0 
dealer = 0 
     pHand = [] 

def __init__ (self, nm, pos, buyIn, deal): 
      self.name = nm 
      self.position = pos 
      self.chips = buyIn 
      self.dealer = deal 

      self.pHand = hand.Hand() 
      return 

     def recieveCard(self, card): 
      """Recieve card from the dealer""" 
      self.pHand.addCard(card) 
      return card 

     def discardCard(self, card): 
      """Throw away a card""" 
      self.pHand.discardCard(card) 
      return card 

     def viewHand(self): 
      """View the players hand""" 
      return self.pHand.viewCards() 

     def getChips(self): 
      """Get the number of chips the player currently holds""" 
      return self.chips 

     def setChips(self, chip): 
      """Sets the number of chips the player holds""" 
      self.chips = chip 
      return 

     def makeDealer(self): 
      """Makes this player the dealer""" 
      self.dealer = 1 
      return 

     def notDealer(self): 
      """Makes this player not the dealer""" 
      self.dealer = 0 
      return 

     def isDealer(self): 
      """Returns flag wether this player is the dealer""" 
      return self.dealer 

     def getPosition(self): 
      """Returns position of the player""" 
      return self.position 

     def getName(self): 
      """Returns name of the player""" 
      return self.name 

Answer 1

De mon expérience en C et Java, il semble que je fais en quelque sorte ma main classe statique.

En fait, c'est essentiellement ce que vous faites. Eh bien, ne rend pas la classe statique, mais rend la variable statique.

Lorsque vous écrivez des déclarations comme ceci:

class Hand: 
    cards = [] 

cette variable (cards) est associée à la classe , pas avec l'instance. Pour faire une analogie avec Java, chaque instruction dans une classe Python qui ne fait pas partie d'une méthode de cette classe s'exécute essentiellement dans un initialiseur statique. On pourrait presque penser comme ceci:

class Hand { 
    static { 
     cards = new object[]; 
    } 
} 

(simplement une analogie grossière, bien sûr)

Pour créer une variable d'instance en Python, vous devez le définir comme un attribut de l'instance, qui vous oblige à attendre jusqu'à ce que vous ayez une référence à l'instance. Dans la pratique, cela signifie que vous l'initialiser dans le constructeur, comme suit:

class Hand: 
    def __init__(self): 
     self.cards = [] 

Answer 2

Votre problème est assez simple

si vous attribuez des listes au corps des classes de python, lorsque vous ajoutez des articles à elle, ils sera stocké au niveau de la classe, pas au niveau de l'instance.

vous pouvez résoudre ce problème en ajoutant la ligne:

def __init__(self): 
    self.cards = [] 

c'est un cas très connu de piège de python, et je vous recommande la lecture: http://zephyrfalcon.org/labs/python_pitfalls.html

Answer 3

Comme d'autres réponses notées, vous étaient confus au sujet des variables de classe par rapport aux variables d'instance. Je vous suggère de revoir les bases du fonctionnement des classes Python. Voici une réponse que j'ai écrite pour une autre question; lire ceci pourrait vous aider.

How to define a class in Python