Python-比较权重

炸金花

实现逻辑：

1、定义好牌面、花色、牌型权重，后续需要把这个3个权重相加，得到最后的权重值；

2、使用循环产生一副牌；

3、将牌分发给玩家；

4、开牌，将每个玩家的牌面按花色、点数从大到小排序；

5、统计各个玩家的权重值；

6、输出权重值最高的玩家；

#!/usr/bin/python
# coding:utf-8
# @Author:Rauck

import random


class Player:
    def __init__(self, name=""):
        self.card = list()  # 玩家拥有的牌存储在card里面，元素类型为元组
        self.name = name  # 玩家姓名
        self.type = ()  # 牌型
        self.scores = 0


class WhoIsBig:
    """
    炸金花
    """
    # 玩家5个
    names = ['#Player1', '#Player2', '#Player3', '#Player4', '#Player5']

    # 每个玩家发牌张数
    circle = 3

    #  花色：方块 < 梅花 < 红心 < 黑桃，数值是权重
    colors_dict = {'方块♦': 0.1, '梅花♣': 0.2, '红心♥': 0.3, '黑桃♠': 0.4}

    # 牌面，数值是权重
    faces_dict = {'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8,
                  '9': 9, '10': 10, 'J': 11, 'Q': 12, 'K': 13, 'A': 14}

    # 牌型
    # 豹子:三张一样的牌，如3张6
    # 同花顺:即3张同样花色的顺子，如红桃5、6、7
    # 顺子:又称拖拉机，花色不同，但是顺子，如红桃5、方片6、黑桃7，组成的顺子
    # 对子:2张牌一样
    # 单张: 单张最大的是A
    # 这几种牌的大小顺序为， 豹子>同花顺>同花>顺子>对子>单张
    types_dict = {
        'baozi': ('豹子', 600),
        'tonghuashun': ('同花顺', 500),
        'tonghua': ('同花', 400),
        'shunzi': ('顺子', 300),
        'duizi_before2': ('对子-前二张', 200),
        'duizi_after2': ('对子-后二张', 200),
        'danzhang': ('单张', 100)
    }

    def __init__(self):
        # 牌列表
        self.cards = list()
        self.players = list()

    def create_cards(self):
        """
        生成一副完整的扑克牌，列表[元组]
        :return:
        """
        for f in self.faces_dict:  # 遍历牌面值
            for c in self.colors_dict:  # 遍历花色
                self.cards.append((f"{c}{f}", self.colors_dict[c], self.faces_dict[f]))
        # print(self.cards)

    def create_players(self):
        """
        初始化玩家列表
        :return:
        """
        for name in self.names:
            self.players.append(Player(name))

    def deal_cards(self):
        """
        发牌
        :return:
        """
        # 玩家
        print('轮数/玩家 ', end='')
        for p in self.players:
            print("%15s" % p.name, end='')
        print()

        for i in range(self.circle):
            print('第{0}轮发牌'.format((i + 1)), end='')
            for p in self.players:
                temp = random.choice(self.cards)  # 随机抽牌
                self.cards.remove(temp)  # 从牌组移除这张牌
                p.card.append(temp)  # 将牌加入玩家的card列表里面
                print("%13s" % temp[0], end='')  # 打印牌名称
            print()
        print()

    def get_winner(self):
        """
        整理牌面、计算权重、输出赢家
        :return:
        """
        winner = None
        print("玩家开牌，分别是：")
        for p in self.players:
            p.card = self._sort_one(p.card)
            p.scores, p.type = self._scores_one(p.card)
            print("%-13s %-10s %-10s %-10s 权重：%0.1f(%s)" % (
                p.name, p.card[0][0], p.card[1][0], p.card[2][0], p.scores, p.type[0]))
            if winner is None:
                winner = p
            elif winner.scores < p.scores:
                winner = p

        print(f'\n赢家是：{winner.name}\n')

    def _scores_one(self, card):
        """
        计算单个玩家权重
        :param card:
        :return:
        """
        scores = 0
        if card[0][2] == card[1][2] == card[2][2]:
            # 豹子
            scores += self.types_dict['baozi'][1]
            scores += card[0][1] + card[0][2]
            type_tup = self.types_dict['baozi']

        elif card[0][1] == card[1][1] == card[2][1]:
            if card[0][2] - 1 == card[1][2] and card[1][2] - 1 == card[2][2]:
                # 同花顺
                scores += self.types_dict['tonghuashun'][1]
                scores += card[0][1] + card[0][2]
                type_tup = self.types_dict['tonghuashun']
            else:
                # 同花
                scores += self.types_dict['tonghua'][1]
                scores += card[0][1] + card[0][2]
                type_tup = self.types_dict['tonghua']

        elif card[0][2] - 1 == card[1][2] and card[1][2] - 1 == card[2][2]:
            # 顺子
            scores += self.types_dict['shunzi'][1]
            scores += card[0][1] + card[0][2]
            type_tup = self.types_dict['shunzi']

        elif card[0][2] == card[1][2]:
            # 对子：前二张牌一样
            scores += self.types_dict['duizi_before2'][1]
            scores += card[0][1] + card[0][2]
            type_tup = self.types_dict['duizi_before2']

        elif card[1][2] == card[2][2]:
            # 对子：后二张牌一样
            scores += self.types_dict['duizi_after2'][1]
            scores += card[1][1] + card[1][2]
            type_tup = self.types_dict['duizi_after2']

        else:
            # 单张
            scores += self.types_dict['danzhang'][1]
            scores += card[0][1] + card[0][2]
            type_tup = self.types_dict['danzhang']
        return scores, type_tup

    def _sort_one(self, card):
        """
        单个玩家牌面排序
        :param card:
        :return:
        """
        for i in range(0, self.circle):
            tmp = i
            for j in range(i + 1, self.circle):
                if card[tmp][2] < card[j][2]:
                    # 比较牌面大小
                    tmp = j
                elif card[tmp][2] == card[j][2] and card[tmp][1] < card[j][1]:
                    # 牌面大小相同，则比较花色
                    tmp = j
            if tmp != i:
                change = card[i]
                card[i] = card[tmp]
                card[tmp] = change
        return card

    def main(self):
        self.create_cards()
        self.create_players()
        self.deal_cards()
        self.get_winner()
        pass


if __name__ == '__main__':
    WhoIsBig().main()