Python基础综合训练二（21点扑克牌大战）

1 游戏规则

百度参考21点的游戏规则。

2 目的

1. 学习类中私有属性构建方法（封装内部属性，只允许外部访问，防止外部篡改值）；
2. 学习继承父类；
3. 学习对抽象类的具体化方法；
4. 学习多态的实现方法。

3 代码

#!/usr/bin/python3.7
# -*- coding: utf-8 -*-
# @Time    : 2021/6/24 15:05
# @Author  : Yujie_Xue
# @Email   : xyj19970628@163.com
# @File    : 9.5 puke.py
# @Software: PyCharm 2019.1
import random
from time import sleep

class Card(object):
    '''一张牌'''
    def __init__(self, suite, face):
        self._suite = suite
        self._face = face

    # 我懂了，为什么要利用这个私有化方法，用这个只能让外界访问，而不能让外界修改这个值！
    @property
    def face(self):
        return self._face

    @property
    def suite(self):
        return self._suite

    def __str__(self):
        if self._face == 1:
            face_str = 'A'
        elif self._face == 11:
            face_str = 'J'
        elif self._face == 12:
            face_str = 'Q'
        elif self._face == 13:
            face_str = 'K'
        else:
            face_str = str(self._face)
        return(f'{self._suite}{face_str}')

    def __repr__(self):
        return self.__str__()

class Poker(object):
    '''一副牌'''

    def __init__(self):
        self._cards = [Card(suite, face)
                       for suite in '♠♥♣♦'
                       for face in range(1, 14)]
        self._current = 0

    @property
    def cards(self):
        return self._cards

    def shuffle(self):
        '''"""洗牌(随机乱序)"""'''
        self._current = 0
        random.shuffle(self._cards)

    @property
    def next(self):
        """发牌"""
        card = self._cards[self._current]
        self._current += 1
        return card

    @property
    def has_next(self):
        return self._current < len(self._cards)

class Player(object):
    '''玩家'''

    def __init__(self, name, score = 20):
        self._name = name
        self._cards_on_hand = []
        self._score = score

    @property
    def name(self):
        return self._name

    @property
    def score(self):
        return self._score

    @property
    def cards_on_hand(self):
        return self._cards_on_hand

    @property
    def all_face(self): # 统计所有牌的总点数
        fen = []
        for c in self._cards_on_hand:
            fen.append(c.face)
        return sum(fen)

    @property
    def lose(self): # 输了之后扣分
        self._score -= 5
        return self._score

    @property
    def win(self): # 赢了之后加分
        self._score += 3
        return self._score

    def get(self, card):
        """摸牌"""
        self._cards_on_hand.append(card)

    def arrange(self, card_key): # 按照一定的顺序？
        """玩家整理手上的牌"""
        self._cards_on_hand.sort(key=card_key)

# 排序规则-先根据点数再根据花色排序
def get_key(card):
    return (card.face, card.suite)

# 获取点数最高的玩家
def get_winner(players):
    scores = len(players) * [0]
    for i in range(len(players)):
        scores[i] = players[i].score
    max_score = max(scores)
    return [p for p in players if p.score == max_score]

if __name__ == '__main__':
    p = Poker() # 创建一个扑克牌
    p.shuffle() # 把牌打乱
    players = [Player('小龙'),Player('小马'), # 创建四个玩家
               Player('小强'),Player('小陈')]

    round = 0
    while(len(players) != 1):
        round += 1
        p._current = 0
        p.shuffle()  # 把牌打乱

        for _ in range(3):
            for player in players:
                player.get(p.next)

        for player in players:
            no_loss = []
            if player.all_face > 21:
                now = player.lose
                print(f'{player.name}爆了，还剩余积分{now}.')
                if now < 0:
                    print(f'{player.name}出局了！！')
                    players.remove(player)
            else:
                winners = get_winner(players)
                for w in winners:
                    print(f'{w.name}赢了,还剩余积分{w.win}.')

        print(f'=========第{round}轮结束。=========')
        sleep(0.8)
    print(f'最终的胜利者是：{players[0].name}.')

    # for _ in range(13):
    #     for player in players:
    #         player.get(p.next)
    #
    # for player in players:
    #     print(player.name + ':', end = ' ')
    #     player.arrange(get_key) # 每个玩家自己内部整理牌
    #     print(player.cards_on_hand)

4 输出