Python实现21点扑克牌游戏

水深无声 2023-06-29 10:59 32阅读 1赞

庄家的牌：♣ 10  ♦ Q  
    玩家的牌：♦ 4  ♥ 8  
    是否继续拿牌（y/n，缺省为y）：y
    玩家拿到的牌为：♦ 4  ♥ 8  ♥ K  
    爆掉  玩家输牌!

# **21点扑克牌游戏概述** #

21点又名黑杰克(Blackjack) ，是一种流行的扑克游戏。该游戏由两到六个人玩，使用除大小王之外的52张牌，游戏者的目标是使手中的牌的点数之和不超过21点且尽量大。

**一手扑克牌的点数的计算规则如下：**

*  2至9牌，按其原点数计算;
 *  10、J、Q、K牌都算作10点(一般记作T，即Ten) ;
 *  A牌(Ace)既可以算作1点也可以算作11点，由玩家自己决定
 *  (当玩家停牌时，点数一律视为最大而尽量不爆，如A+K为21，A+5+8为14而不是24)。

# **21点扑克牌游戏设计思路** #

按下列规则模拟21点扑克牌游戏：

1.  计算机人工智能AI作为庄家(House)，用户作为玩家(Player) 。
2.  游戏开始时， 庄家从洗好的一副牌中发牌：第1张牌发给玩家， 第2张牌发给庄家，第3张牌发给玩家，第4张牌发给庄家。
3.  然后，**询问玩家是否需要继续“拿牌”**，通过一次或多次“拿牌”，玩家尝试使手中扑克牌的点数和接近21。如果玩家手中扑克牌的点数之和超过21，则玩家输牌。
4.  当玩家决定 “停牌”(即，不再“拿牌”)，则**轮到庄家使用下列规则(“庄家规则”)“拿牌”**：如果庄家手中的最佳点数之和小于17，则必须“拿牌”:，如果点数之和大于或等于17，则“停牌”。如果庄家的点数之和超过21,则玩家获胜。
5.  最后， 比较玩家和庄家的点数。如果玩家的点数大，则获胜。如果玩家的点数小，则输牌。如果点数相同，则平局。但玩家和庄家的牌值都是21点，此时拥有blackjack (一张Ace 和一张点数为10的牌)方获胜。

**程序的流程如下：**

*  初始化一 副洗好的扑克牌，初始化庄家和玩家手中的牌为空  
    调用函数`get_shuffled_deck()`

def get_shuffled_deck():
        """初始化包括52张扑克牌的列表，并混排后返回，表示一副洗好的扑克牌"""
        # 花色suits和序号
        suits = { '♣', '♠', '♦', '♥'}
        ranks = { '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A'}
        deck = []
        # 创建一副52张的扑克牌
        for suit in suits:
            for rank in ranks:
                deck.append(suit + ' ' + rank)
        random.shuffle(deck)
        return deck

*  依次给玩家和庄家各发两张牌  
    调用函数`deal_card()`

def deal_card(deck, participant):
        """发一张牌给参与者participant"""
        card = deck.pop()
        participant.append(card)
        return card

*  玩家拿牌： 询问玩家是否继续拿牌，如果是，继续给玩家发牌(调用函数`deal_ card()`) ，并计算玩家牌点`compute_total()`，如果大于21点，输出“玩家输牌!”信息，并返回。

def compute_total(hand):
        """计算并返回一手牌的点数和"""
        values = { '2':2, '3':3, '4':4, '5':5, '6':6, '7':7, '8':8, \
                  '9':9, '10':10, 'J':10, 'Q':10, 'K':10, 'A':11}
        result = 0 #初始化点数和为0
        numAces = 0 #A的个数
    
        # 计算点数和A的个数
        for card in hand:
            result += values[card[2:]]
            if card[2] == 'A':
                numAces += 1
        
        #如果点数和>21，则尝试把A当做1来计算
        # (即减去10)，多个A循环减去10，直到点数<=21
        while result > 21 and numAces > 0:
            result -= 10
            numAces -= 1
        return result

*  庄家拿牌:庄家(计算机人工智能AI)按“庄家规则”确定是否拿牌，如果是，继续给庄家发牌(调用函数`deal_card()`) ，并计算庄家牌点`compute_total()`，如果大于21点，输出“玩家赢牌!”信息，并返回。
 *  分别计算庄家和玩家的点数，比较点数大小，输出输赢结果信息。

语义化：

*  shuffled deck，洗牌台
 *  deal，发牌

**random模块的函数使用**

*  **random.shuffle(lst)** 将序列的所有元素随机排序。  
    参数：lst 列表

**列表的函数使用**

*  **s.append(x)** 把对象x追加到列表s的尾部
 *  **s.pop(i)** 弹出下标i处元素，当省略i时弹出列表的最后一个元素

# **21点扑克牌游戏实现** #

import random
    
    def get_shuffled_deck():
        """初始化包括52张扑克牌的列表，并混排后返回，表示一副洗好的扑克牌"""
        # 花色suits和序号
        suits = { '♣', '♠', '♦', '♥'}
        ranks = { '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A'}
        deck = []
        # 创建一副52张的扑克牌
        for suit in suits:
            for rank in ranks:
                deck.append(suit + ' ' + rank)
        random.shuffle(deck)
        return deck
    
    def deal_card(deck, participant):
        """发一张牌给参与者participant"""
        card = deck.pop()
        participant.append(card)
        return card
    
    def compute_total(hand):
        """计算并返回一手牌的点数和"""
        values = { '2':2, '3':3, '4':4, '5':5, '6':6, '7':7, '8':8, \
                  '9':9, '10':10, 'J':10, 'Q':10, 'K':10, 'A':11}
        result = 0 #初始化点数和为0
        numAces = 0 #A的个数
    
        # 计算点数和A的个数
        for card in hand:
            result += values[card[2:]]
            if card[2] == 'A':
                numAces += 1
        
        #如果点数和>21，则尝试把A当做1来计算
        # (即减去10)，多个A循环减去10，直到点数<=21
        while result > 21 and numAces > 0:
            result -= 10
            numAces -= 1
        return result
    
    def print_hand(hand):
        for card in hand:
            print(card, end = ' ')
        print()
    
    def blackjack():
        """21点扑克牌游戏，计算机人工智能AI为庄家，用户为玩家"""
        # 初始化一副洗好的扑克牌，初始化庄家和玩家手中的牌为空
        deck = get_shuffled_deck()
        house = [] # 庄家的牌
        player = [] # 玩家的牌
        
        # 依次给玩家和庄家各发两张牌
        for i in range(2):
            deal_card(deck, player)
            deal_card(deck, house)
            
        # 打印一手牌
        print('庄家的牌：', end = ''); print_hand(house)
        print('玩家的牌：', end = ''); print_hand(player)
    
        # 询问玩家是否继续拿牌，如果是，继续给玩家发牌
        answer = input('是否继续拿牌（y/n，缺省为y）：')
        while answer in ('', 'y', 'Y'):
            card = deal_card(deck, player)
            print('玩家拿到的牌为：', end = ''); print_hand(player)
            # 计算牌点
            if compute_total(player) > 21:
                print('爆掉 玩家输牌!')
                return
            answer = input('是否继续拿牌（y/n，缺省为y）：')
    
        # 庄家(计算机人工智能)按“庄家规则”确定是否拿牌
        while compute_total(house) < 17:
            card = deal_card(deck, house)
            print('庄家拿到的牌为：', end =''); print_hand(house)
            # 计算牌点
            if compute_total(house) > 21:
                print('爆掉 玩家赢牌!')
                return
    
        # 分别计算庄家和玩家的点数，比较点数大小，输出输赢结果信息
        houseTotal, playerTotal = compute_total(house), compute_total(player)
        if houseTotal > playerTotal:
            print('庄家赢牌!')
        elif houseTotal < playerTotal:
            print('玩家赢牌!')
        elif houseTotal == 21 and 2 == len(house) < len(player) : # 拥有blackjack的庄家赢牌
            print('庄家赢牌!')
        elif playerTotal == 21 and 2 == len(player) < len(house) : # 拥有blackjack的玩家赢牌
            print('玩家赢牌!')
        else:
            print('平局！')
    
    if __name__ == '__main__':
        blackjack()

运行结果示例一：

庄家的牌：♣ 10  ♦ Q  
    玩家的牌：♦ 4  ♥ 8  
    是否继续拿牌（y/n，缺省为y）：y
    玩家拿到的牌为：♦ 4  ♥ 8  ♥ K  
    爆掉  玩家输牌!