类中的函数不计算类python每个部分的值

Question

我正在制作一个二十一点模拟游戏，并为玩家、手牌和纸牌制作了课程。我在 Card Class 中使用这个函数来获取每张卡片的值。

def values(self,rank):
    if self.rank == 'Ace':
        return 11
    elif self.rank == 'Jack' or self.rank == 'Queen' or self.rank == 'King':
        return 10
    else:
        return int(self.rank)

并在 Player Hand 类中使用此函数来汇总每只手的值。

def handValue(self,rank,value):
        value = value + card.values(card.rank)
        return value

我这样调用函数：

print player1Hand.handValue(card.rank)

我在每张卡片添加到玩家手牌类后调用该函数。当我尝试获取手牌的值时，handValue 函数将仅返回第二张牌的值。在我第一次调用 handValue 函数之前，'value' 设置为 0，进入手中的牌来自队列，每张牌都被命名为'card'（可能是问题，但我不确定我是如何会解决的）

卡片像这样被添加到玩家手中：

value = 0
card = deck.dequeue()       #takes a card from a queue (the deck)
player1Hand.addCard(card)       #adds it to the hand
player1Hand.handValue(card.rank,value)      #tries to get value

这是整个代码：

import random
import time

class Queue:
    def __init__(self):
        self.items = []

    def __repr__(self):
        return str(self.items)

    def isEmpty(self):
        return self.items == []

    def enqueue(self, item):
        self.items.insert(0,item)

    def dequeue(self):
        return self.items.pop()

    def size(self):
        return len(self.items)



class Player:

    def __init__(self,balance,name,bet):
        self.name = name
        self.balance = balance
        self.bet = bet

    def __repr__(self):
        return name, str(balance), str(bet)

    def name(self,name):
        self.name = name
        return name

    def balance(self, balance):
        self.balance = balance
        return balance

    def bet(self, bet):
        self.bet = bet
        return bet

    def makeBet(self, balance,bet):
        balance = balance - bet
        return self.balance

    def winMoney(self,balance):
        balance = balance * 2

    def hit(self):
        print "Hitting..."
        self.add_Card(self.deck.addCard())

        return self.hand

    def stand(self):
        print name, 'stands'

    def check_bust(self):
        if self.get_value() > 21:
            self.isBust = True
            print "%s busts!" % self.name
        else:
            self.stand()

    def newBet(bet,self):
        self.bet = bet * 2
        return self.bet

balance = 1000 
bet = 100
name = 'player1'
player1 = Player('player1', balance, bet)
player1.makeBet(balance,bet)
name = 'player2'  
player2 = Player('player2', balance, bet)
player2.makeBet(balance,bet)  
name = 'player3'
player3 = Player('player3', balance, bet)
player3.makeBet(balance,bet)
name = 'dealer'
dealer = Player('Dealer', 1300000000, bet) 



class Card:
    def __init__(self, rank, suit):
        self.rank = rank
        self.suit = suit

    def __repr__(self):
        return '{0} of {1}'.format(self.rank, self.suit)   

    def getRank(self,rank):
        return self.rank

    def getSuit(self,suit):
        return self.suit

    def values(self):
        if self.rank == 'Ace':
            return 11
        elif self.rank in ('Jack', 'Queen', 'King'):
            return 10
        else:
            return int(self.rank)

class Hand:
    def __init__(self,hand,name):
        self.name = name
        self.hand = []

        self.hidden = False

    def __repr__(self):
        if self.hidden == True:
            return '[X]'
        else:
            return '%s\n%s\n\n=====================\n' % (self.name, self.hand)

    def name(self,name):
        self.name = name
        return name

    def hand(self,hand):
        self.hand = hand
        return hand

    def hideCard(self):
        self.hidden = True    

    def addCard(self, card):
        self.hand.append(card)
        return self.hand

    def handValue(self,rank,value):
        value = value + card.values()
        return value

def shuffle_deck():
    global cards
    cards = []
    for i in range(8): #8 times for 8 decks
        for suit in ['Clubs', 'Diamonds', 'Hearts', 'Spades']: 
            for rank in ['Ace', 2, 3, 4, 5, 6, 7, 8, 9, 10, 'Jack', 'Queen', 'King']:
                card = Card(rank,suit)
                cards.append(card)

    random.shuffle(cards) #shuffles cards
    return cards #returns the cards in a list


shuffle_deck()
cut = random.randint(0,416) #cuts deck in random spot
for i in range(cut):
    cards.pop(0)


deck = Queue()
for i in range(len(cards)):
    deck.enqueue(cards[0])
    cards.pop(0)


print 'Each player will start off with $1000, the maximum bets can be $1000 and the minimum bet can be $5.'
#deal cards


import PlayerClass
print 'Each player must make a bet, starting with player 1.' 

player1.makeBet(balance,bet)
print 'Player 1 bet $', player1.bet 

player2.makeBet(balance,bet)
print 'Player 2 bet $', player2.bet

player3.makeBet(balance,bet)
print 'Player 3 bet $', player3.bet



player1Hand = Hand('Player1 Hand:', [])
player2Hand = Hand('Player2 Hand:', [])
player3Hand = Hand('Player3 Hand:', [])
dealerHand = Hand('Dealer Hand:', [])

value = 0
card = deck.dequeue()
player1Hand.addCard(card)
player1Hand.handValue(card.rank,value)
card = deck.dequeue()
player2Hand.addCard(card)
player2Hand.handValue(card.rank,value)
card = deck.dequeue()
player3Hand.addCard(card)
player3Hand.handValue(card.rank,value)
card = deck.dequeue()
dealerHand.addCard(card)
card = deck.dequeue()
player1Hand.addCard(card)
print 'Player 1 Value: ', player1Hand.handValue(card.rank,value)
card = deck.dequeue()
player2Hand.addCard(card)
print 'Player 2 Value:', player2Hand.handValue(card.rank,value)
card = deck.dequeue()
player3Hand.addCard(card)
print 'Player 3 Value:', player3Hand.handValue(card.rank,value)
card = deck.dequeue()
dealerHand.addCard(card)


print 'Player 1:', player1Hand
print 'Player 2:', player2Hand
print 'Player 3:', player3Hand
print 'dealer:', dealerHand


#Player 1 Turn
print 'Player 1 Turn: Hit or Stand'


if player1Hand.handValue(card.rank,value) <= 5: 
    player1.stand()
else:
    player1.hit()
    check_bust()

我知道代码的结尾不会在最后起作用，这是我所得到的

Answer 1

您混淆了很多关于如何表示数据的不同概念。

就卡片值而言，您可以通过两种方式执行values() 例程。首先你应该称它为value()，因为它只代表一张卡的价值。那么如果rank 不是卡片的属性（应该是），但如果不是，则可以执行如下静态方法：

@staticmethod
def value(rank):
    if rank == 'Ace':
        return 11
    elif rank in ('Jack', 'Queen', 'King'):
        return 10
    else:
        return int(rank)

如果value() 是卡的属性（应该是），那么value() 可以是：

def value(self):
    if self.rank == 'Ace':
        return 11
    elif self.rank in ('Jack', 'Queen', 'King'):
        return 10
    else:
        return int(self.rank)

注意这两个例程之间的区别。在第一种情况下，self 表示的对象没有意义，也没有通过。在第二种情况下，rank 是对象（卡片）的属性，不需要传递，因为它将通过 self 访问

这两种方法中的任何一种都可以使用，但第二种是首选。

看到更多代码后更新：

这里有一个完整的Card() 和一个Hand.value 来计算一手牌的价值。

class Card:
    def __init__(self, rank, suit):
        self._rank = rank
        self._suit = suit
        self._value = self.rank_value(rank)

    def __str__(self):
        return '{0} of {1}'.format(self._rank, self._suit)

    def __repr__(self):
        return 'Card({0}, {1}'.format(self._rank, self._suit)

    @property
    def rank(self):
        return self._rank

    @property
    def suit(self):
        return self._suit

    @property
    def value(self):
        return self._value
        
    @staticmethod
    def rank_value(rank):
        if rank == 'Ace':
            return 11
        elif rank in ('Jack', 'Queen', 'King'):
            return 10
        else:
            return int(rank)

class Hand:

    @property
    def value(self):
        return sum(card.value for card in self.hand)