当两张扑克牌有价值和花色时，我如何比较它们的价值？ Python3

Question

我正在尝试制作基于文本的面向对象的纸牌游戏。两名玩家从一副牌中各抽一张牌，拥有最强牌的玩家获胜。我为这个游戏设置了四个类：Card、Deck、Player、Game。我的问题是：我如何比较每个玩家的牌并确定最强的牌。欢迎有关代码的所有其他建议。最好的问候 HWG。

这是我的代码：

卡片

class Card():

    values = [None, None, 2, 3, 4, 5, 6, 7, 8, 9, 10, "Jack", "Queen", "King",
        "Ace"]
    suits = ["hearts", "spades", "diamond", "clubs"]

    def __init__(self, value, suit):
        self.value = value
        self.suit = suit

    def __repr__(self):
        return str(self.values[self.value]) + " of " + str(self.suits[self.suit])

甲板

from random import shuffle
from card import Card

class Deck():

    def __init__(self):
        self.cards = []
        for v in range(2, 15):
            for s in range(4):
                self.cards.append(Card(v, s))
        shuffle(self.cards)

播放器

from deck import Deck

class Player():

    def __init__(self, name):
        self.name = name
        self.card = None
        self.wins = 0

游戏

from player import Player
from deck import Deck
import getch

class Game():

    def __init__(self):
        player1_name = input("Player One Name: ")
        player2_name = input("Player Two Name: ")
        self.deck = Deck()
        self.player1 = Player(player1_name)
        self.player2 = Player(player2_name)
        self.cards = self.deck.cards

    def game_loop(self):
        while len(self.cards) >= 2:
            print("\nPress enter to draw")
            getch.getch()
            player1_card = self.cards.pop()
            player2_card = self.cards.pop()

Answer 1

这是一种方法的草图。您可以轻松地将其与您自己的方法结合起来，最大的变化是 Card 类。在这里，我使用namedtuple 创建了一个Card 类，但是您当前的类可以简单地包装一个tuple 值：

import enum
from functools import total_ordering
from collections import namedtuple

@total_ordering
class OrderedEnum(enum.Enum):
    def __lt__(self, other):
        if isinstance(other, type(self)):
            return self.value < other.value
        return NotImplemented

Rank = OrderedEnum('Rank', ['one', 'two', 'three', 'four', 'five', 'six',
                    'seven', 'eight', 'nine', 'jack', 'queen','king', 'ace'])

Suit = OrderedEnum('Suit', ['clubs', 'diamonds', 'hearts', 'spades'])

Card = namedtuple('Card', ['rank', 'suit'])

c1 = Card(Rank.four, Suit.clubs)
c2 = Card(Rank.four, Suit.spades)
c3 = Card(Rank.ace, Suit.diamonds)

现在，行动起来：

>>> c1
Card(rank=<Rank.four: 4>, suit=<Suit.clubs: 1>)
>>> c2
Card(rank=<Rank.four: 4>, suit=<Suit.spades: 4>)
>>> c1 < c2
True
>>> c1 > c3
False

元组排序是字典顺序的！不错！

>>> hand = [c2, c1, c3]
>>> hand
[Card(rank=<Rank.four: 4>, suit=<Suit.spades: 4>), Card(rank=<Rank.four: 4>, suit=<Suit.clubs: 1>), Card(rank=<Rank.ace: 13>, suit=<Suit.diamonds: 2>)]
>>> sorted(hand)
[Card(rank=<Rank.four: 4>, suit=<Suit.clubs: 1>), Card(rank=<Rank.four: 4>, suit=<Suit.spades: 4>), Card(rank=<Rank.ace: 13>, suit=<Suit.diamonds: 2>)]
>>>

注意，我使用了total_ordering 装饰器，它只是一个快捷方式，而且确实，我认为手动完成整个课程可能会更好。 Here's 一个食谱。

编辑 所以，详细地说，这里是我将如何实现你的 Card 和 Deck 类。请注意，当您使用 enum 和 namedtuple 时，您的代码的可读性会提高多少。

import enum
from functools import total_ordering
from collections import namedtuple
from random import shuffle 

@total_ordering
class OrderedEnum(enum.Enum):
    def __lt__(self, other):
        if isinstance(other, type(self)):
            return self.value < other.value
        return NotImplemented

Rank = OrderedEnum('Rank', ['one', 'two', 'three', 'four', 'five', 'six',
                    'seven', 'eight', 'nine', 'jack', 'queen','king', 'ace'])
Suit = OrderedEnum('Suit', ['clubs', 'diamonds', 'hearts', 'spades'])
CardValue = namedtuple('CardValue', ['rank', 'suit'])

@total_ordering
class Card(object):
    def __init__(self, rank, suit):
        self.value = CardValue(rank, suit)
    def __repr__(self):
        return "Card({:s}, {:s})".format(self.value.rank, self.value.suit)
    def __lt__(self, other):
        if isinstance(other, __class__):
            return self.value < other.value
        return NotImplemented
    def __eq__(self, other):
        if isinstance(other, __class__):
            return self.value == other.value
        return NotImplemented

class Deck(object):
    def __init__(self):
        self.cards = []
        for rank in Rank:
            for suit in Suit:
                self.cards.append(Card(rank, suit))
        shuffle(self.cards)

现在，行动起来：

>>> deck = Deck()
>>> c1 = deck.cards.pop()
>>> c2 = deck.cards.pop()
>>> c1
Card(Rank.queen, Suit.hearts)
>>> c2
Card(Rank.king, Suit.clubs)
>>> c1 == c2
False
>>> c1 > c2
False
>>> c1 < c2
True
>>> c1.value
CardValue(rank=<Rank.queen: 11>, suit=<Suit.hearts: 3>)
>>> c2.value
CardValue(rank=<Rank.king: 12>, suit=<Suit.clubs: 1>)

另外，请注意__repr__ 应该尝试表示对象，如果您想要漂亮的消息，请使用__str__。见this question

Answer 2

您可以为您的 Card 类实现运算符 __gt__(), __lt__(), 等等...

您可以使用一些标准库函数，例如 max() 来确定更高价值的卡片或牌组，甚至可以使用 sort() 来简单地对“手”进行排序，例如列表 [Card, Card, .. .].

Answer 3

枚举 (https://docs.python.org/3.5/library/enum.html) 将是合适的。对于丰富的比较（和排序），您还应该考虑在 @ 上实现部分或全部 __eq__、__ne__、__lt__、__le__、__gt__、__ge__ 方法（来自 https://docs.python.org/3/reference/datamodel.html） 987654329@班级。

Answer 4

我建议您将每张卡片的值存储为 int，以便您可以比较它们，并且不要使用诸如“King”或“Ace”之类的字符串。您可以这样做并更改 repr() 以使用这些字符串打印人类可读的版本。

Card 类可能如下所示：

class Card(object):
     suits = ["Clubs", "Diamonds", "Hearts", "Spades"] #list of suits
     values = [None, "Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"] #list of card values

     def __init__(self, suit= 0, value= 2):
         """
         Initializes card
         :param suit: Suit of card int value 0-3
         :param value: Value of card int value 0-13
         """
         self.suit = suit
         self.value = value

     def __str__(self):
         """
         Returns a readable format of the card
         """
         return "%s of %s" %(Card.values[self.value],
                             Card.suits[self.suit])

注意卡的值是如何一直存储为 int 的。

在 Game 类中，你可以有一个比较两张牌的函数，我不确定你想怎么做，但它可能看起来像这样：

def compare(card1, card2):
     """
     Compares the value of two cards and returns the greater of the two
     :param card1: A card object
     :param card2: A second card object
     :return: The higher value card, if tie returns 0
     """
     if card1.value > card2.value:
         return card1
     elif card2.value == card1.value:
         return 0
     else:
         return card2