简单的python纸牌游戏_Python_Playing Cards

简单的python纸牌游戏

python

简单的python纸牌游戏,python,playing-cards,Python,Playing Cards,我对python完全陌生，不知道如何使用这个程序我正在尝试建立一个迷你纸牌游戏，它可以做到以下几点有六名球员在每一手牌开始时，发给每位玩家四张牌对于每个玩家，手上的所有对都被放下。一名玩家对由两张等级低于10的牌组成的一对牌得一分（A点数大于10）。由两张等级为10或更高的牌组成的付款人可获得两分。如果手是两对的，两个都放下。玩家可以得到相应的点数（1或2）这双鞋放下后，手就结束了。（玩家实际上不会输入输入或做出决定。我告诉过你这是一个无聊的游戏。）所有的牌都会回到牌组，重新洗牌，然后

我对python完全陌生，不知道如何使用这个程序

我正在尝试建立一个迷你纸牌游戏，它可以做到以下几点

有六名球员

在每一手牌开始时，发给每位玩家四张牌

对于每个玩家，手上的所有对都被放下。一名玩家对由两张等级低于10的牌组成的一对牌得一分（A点数大于10）。由两张等级为10或更高的牌组成的付款人可获得两分。如果手是两对的，两个都放下。玩家可以得到相应的点数（1或2）

这双鞋放下后，手就结束了。（玩家实际上不会输入输入或做出决定。我告诉过你这是一个无聊的游戏。）所有的牌都会回到牌组，重新洗牌，然后开始新的牌

每轮比赛结束后，球员按总分数的降序排列。如果两名球员在相同的分数上打成平局，他们将首先打印出编号最低的球员

六轮后，比赛结束。得分列表中的第一名玩家（如上所述）赢得比赛

输出应如下所示：

Hand 1 deal:
Player 1's hand: 5D 5H KD AS
Player 2's hand: 7D 8D 9C JS
Player 3's hand: 3D 3H 6S 7C
Player 4's hand: 4C 6D 8S TH
Player 5's hand: 4H 5C 7S QC
Player 6's hand: 5S 6H 9H KH

Dropping pairs:
Player 1 dropped 1 pair.
Player 2 dropped no pairs.
Player 3 dropped 1 pair.
Player 4 dropped no pairs.
Player 5 dropped no pairs.
Player 6 dropped no pairs.

Score:
Player 1: 1
Player 3: 1
Player 2: 0
Player 4: 0
Player 5: 0
Player 6: 0

这个游戏的模块包括

纸牌

import string
import random

suits = ['S', 'C', 'D', 'H']
longsuits = ['spades', 'clubs', 'diamonds', 'hearts']

ranks = ['2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A']
longranks = ['two', 'three', 'four', 'five', 'six', 'seven', 'eight',
        'nine', 'ten', 'jack', 'queen', 'king', 'ace']

ranklist = string.join(ranks, "")

ranklookup = {}
for i in range(len(ranks)):
    ranklookup[ranks[i]] = i

suitlookup = {}
for i in range(len(suits)):
    suitlookup[suits[i]] = i

class Card:
    """
    Class to hold information about a single playing card.  The card's rank
    and suit are stored.

    The constructor takes two arguments, the rank and suit of the card.  The
    rank and suit must be values from the ranks and suits list.

    >>> c1 = Card('8', 'C')
    >>> c2 = Card('K', 'H')
    >>> print c1
    8C
    >>> print c2
    KH
    """

    def __init__(self, rank, suit):
        self.__rank = ranklookup[rank]
        self.__suit = suitlookup[suit]

    def __cmp__(self, other):
        """
        Compare two card objects.

        >>> c1 = Card('8', 'C')
        >>> c2 = Card('K', 'H')
        >>> c1<c2
        True
        >>> c1>c2
        False
        >>> c1==c2
        False
        """
        if self.__rank == other.__rank:
            return cmp(self.__suit, other.__suit)
        else:
            return cmp(self.__rank, other.__rank)

    def __str__(self):
        """
        Return a two-character string representing the card.

        >>> c1 = Card('8', 'C')
        >>> str(c1)
        '8C'
        """
        return self.shortname()
    def __repr__(self):
        """
        Return a the Python code required to construt the card.

        >>> c1 = Card('8', 'C')
        >>> print repr(c1) .split(".",1)[1]
        Card('8', 'C')
        """
        return "%s.Card('%s', '%s')" % (self.__module__, ranks[self.__rank], suits[self.__suit])

    def suit(self):
        """
        Return a character representing the card's suit.  This will be one of the
        characters from suits.

        >>> c1 = Card('8', 'C')
        >>> c1.suit()
        'C'
        """
        return suits[self.__suit]

    def rank(self):
        """
        Return a character with the card's rank.  This will be one of the
        characters from ranks.

        >>> c1 = Card('8', 'C')
        >>> c1.rank()
        '8'
        """
        return ranks[self.__rank]

    def shortname(self):
        """
        Output a short two-character description of the card.

        >>> c1 = Card('8', 'C')
        >>> c1.shortname()
        '8C'
        """
        return ranks[self.__rank] + suits[self.__suit]

    def longname(self):
        """
        Return a long English description of the card.

        >>> c1 = Card('8', 'C')
        >>> c1.longname()
        'eight of clubs'
        """
        return longranks[self.__rank] + " of " + longsuits[self.__suit]



testhand = [ Card('9', 'H'), Card('6', 'C'), Card('7', 'S'), Card('6', 'D'), Card('A', 'H') ]

def deck():
    """
    Return an *unshuffled* deck of cards (list of card objects).

    >>> d = deck()
    >>> print hand_string(d)
    2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS AS 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC AC 2D 3D 4D 5D 6D 7D 8D 9D TD JD QD KD AD 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH AH
    >>> print len(d)
    52
    """
    d = []
    for suit in range(len(suits)):
        for rank in range(len(ranks)):
            c = Card(ranks[rank], suits[suit])
            d.append(c)

    return d


def small_deck():
    """
    Return a small *unshuffled* deck of cards (list of card objects).  This is
    smaller than a regular deck and can be used for testing.

    >>> d = small_deck()
    >>> print hand_string(d)
    9S TS JS QS KS AS 9C TC JC QC KC AC 9D TD JD QD KD AD 9H TH JH QH KH AH
    >>> print len(d)
    24
    """
    d = []
    for suit in range(len(suits)):
        for rank in [7,8,9,10,11,12]:
            c = Card(ranks[rank], suits[suit])
            d.append(c)

    return d



def start_pair(hand):

    """
        Return index of first card in first pair of the hand.
        The index is for the order the hand has after sorting.
        If there are no pairs, return -1.

        Side effect:  The hand is sorted.
    """
    hand.sort()
    start = -1
    for i in range(len(hand)-1, 0, -1):
        if hand[i].rank() == hand[i-1].rank():
            start = i -1
    return start





def drop_pair(hand):
    """
    Remove a pair from the hand (list of card objects) if possible.  Return
    the new hand and the number of pairs dropped (0 or 1).  A "pair" is two
    cards with the same rank.

    If there is more than one pair, only the first is removed.

    The hand MUST be sorted by rank before this function is called.  This
    can be done with:
        hand.sort()

    >>> testhand.sort()
    >>> print hand_string(testhand)
    6C 6D 7S 9H AH
    >>> newhand, pts = drop_pair(testhand)
    >>> print hand_string(newhand)
    7S 9H AH
    >>> print pts
    1
    """
    newhand = hand[:]
    for i in range(len(newhand)-1):
        if newhand[i].rank() == newhand[i+1].rank():
            del(newhand[i+1])
            del(newhand[i])
            return newhand, 1
    return newhand, 0



def hand_string(hand):
    """
    Create a string that represents the cards in the player's hand.

    >>> hand_string(testhand)
    '6C 6D 7S 9H AH'
    >>> hand_string([])
    ''
    """

    return " ".join( [c.shortname() for c in hand] )


def _test():
    import doctest
    doctest.testmod()

if __name__ == "__main__":
    _test()

我在循环方面遇到了很大的问题，非常感谢您的帮助，提前谢谢您，您似乎根本没有使用

pointsort.py

，这很好，因为我最终不需要它来实现您的预期输出

# main.py
import cards
import random

deck = cards.small_deck()

class Player(object):
    def __init__(self, number):
        self.number = number
        self.points = 0
        self.hand = []

    def __str__(self):
        return "Player %d" % self.number

players = [Player(num + 1) for num in xrange(6)]  # create six numbered players
rounds = 6
hand_size = 4

for round_num in xrange(rounds):
    #shuffle the cards
    random.shuffle(deck)
    print "Hand %d deal:" % (round_num + 1)
    # deal cards
    for _ in xrange(hand_size):
        for player in players:
            # draw from the back instead of the front: possibly slightly more efficient
            player.hand.append(deck.pop())

    # sort player cards
    for player in players:
        player.hand.sort()
        print "%s's hand: %s" % (player, cards.hand_string(player.hand))
    print

    print "Dropping pairs:"
    for player in players:
        #removes the pairs
        new_hand, dropped_cards, pairs = cards.drop_pairs(player.hand)
        deck.extend(player.hand)  # realistically we can dump the hand now anyway.
        player.hand = []

        player.points += pairs

        how_many = pairs
        plural = "s"
        if pairs == 0:
            how_many = "no"
        elif pairs == 1:
            plural = ""
        print "%s dropped %s pair%s" % (player, how_many, plural)
    print

    print "Score:"
    for player in players:
        print "%s: %d" % (player, player.points)
    print

我还将drop_pair更改为drop_pair，并使其查找所有对，而不是仅查找一对。如果它找到了三个同类，它值2分，四个同类值3分

# in cards.py
def drop_pairs(hand):
    new_hand = hand[:]
    dropped_cards = []
    pairs = 0
    for card1, card2 in zip(hand, hand[1:]):  # look at every two-in-a-row cards
        if card1.rank() == card2.rank():
            try:
                new_hand.remove(card1)
            except ValueError:
                pass
            else:
                dropped_cards.append(card1)
            try:
                new_hand.remove(card2)
            except ValueError:
                pass
            else:
                dropped_cards.append(card2)
            pairs += 1
    return new_hand, dropped_cards, pairs

我没有查看您的所有代码，没有比“帮助循环”更具体的指导，我也帮不了多少忙，但我注意到了以下几点：

在python中，您可以直接迭代列表，而不是从0迭代到len-1并检查索引。例如：

# this will work, but it's not recommended
for suit in range(len(suits)):
    for rank in range(len(ranks)):
        c = Card(ranks[rank], suits[suit])
        d.append(c)

# this is much cleaner
for suit in suits:
    for rank in ranks:
        d.append(Card(rank, suit))

然而，有时您确实希望迭代一系列连续的数字，或者您只希望一些代码运行一定的次数，在这种情况下，您可以使用range（或者xrange，在python2中，它对于大范围更有效）

此外，如果当前数字不需要“i”变量，可以使用名称“\u1”，它经常被重新分配，是垃圾数据的好地方

您还可以嵌套列表。如果您不确定将有多少个列表，这将非常有用。也就是说，如果你有六名球员：

# no no no
player1 = []
player2 = []
player3 = []
player4 = []
player5 = []
player6 = []

# better...
players = [[], [], [], [], [], []]

# yes!
players = []
for _ in xrange(6):
    players.append([])

# There's also a shortcut called List Comprehensions, which allows us
# to be even more concise with our list definitions.
players = [[] for _ in xrange(6)]

后两个示例的优点是，您可以通过更改数字6，甚至使用变量来轻松更改游戏中的玩家数量。他们还减少了代码重复：你的逻辑为每个玩家处理他们的卡是复制粘贴6次，只有一个数字之间的变化。这是不可扩展的：如果您想添加或删除播放器，您必须从代码中添加或删除那么多重复的块。相反：

    # no! bad!
    player1 = []
    player2 = []
    player3 = []
    player4 = []
    player5 = []
    player6 = []

    player1.do_stuff()
    player2.do_stuff()
    player3.do_stuff()
    player4.do_stuff()
    player5.do_stuff()
    player6.do_stuff()

    # much easier!
    for player in players:
        player.do_stuff()

您似乎根本没有使用

pointsort.py