python炸金花并对比结果

#!usr/bin/env python
# -*- coding: utf-8 -*-
"""
编写炸金花游戏程序

自己写一个程序，实现发牌、比大小判断输赢。

#### 游戏规则：

一付扑克牌，去掉大小王，每个玩家发3张牌，最后比大小，看谁赢。

有以下几种牌：

豹子：三张一样的牌，如3张6.

顺金：又称同花顺，即3张同样花色的顺子， 如红桃 5、6、7

顺子：又称拖拉机，花色不同，但是顺子，如红桃5、方片6、黑桃7，组成的顺子

对子：2张牌一样

单张：单张最大的是A

这几种牌的大小顺序为， **豹子>顺金>顺子>对子>单张**
"""
import random


def gen_all_cards():
    """
    生成所有扑克牌
    :return:
    """
    colors = ["diamond", "club", "heart", "spade"]
    card_enumerate = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
    all_card_dict = {}
    for color in colors:
        for index, item in enumerate(card_enumerate):
            card = "{}{}".format(color, item)
            # 借助数组的顺序来判定牌的大小
            all_card_dict[card] = [index, color]
    return all_card_dict


def allocate_playing_cards(all_cards, player_num):
    """
    给指定个数玩家分配纸牌
    :param all_cards:
    :param player_num:
    :return:
    """
    gen_all_cards()
    player_index_result = {}
    for player_index in range(1, player_num + 1):
        card_result = random.sample(all_cards, 3)
        player_index_result[player_index] = card_result
        for card in card_result:
            all_cards.remove(card)
    return player_index_result


def is_consecutive_numbers(card_index_list):
    """
    是否是连续的三个数字
    :param card_index_list:
    :return:
    """
    result = False
    _card_index_list = sorted(card_index_list)
    if _card_index_list[0] + 1 == _card_index_list[1] and _card_index_list[0] + 2 == _card_index_list[2]:
        result = True
    return result


def gen_level_and_score(player_card_result, all_cards_dict):
    """
    生成牌的类别和得分
    :param player_card_result:
    :param all_cards_dict:
    :return:
    """
    level = 0
    card_index_list = []
    color_set = set()
    same_card_index_score = 0
    for card in player_card_result:
        card_index, color = all_cards_dict[card]
        if card_index in card_index_list:
            same_card_index_score = card_index
        card_index_list.append(card_index)
        color_set.add(color)
    score = max(card_index_list)
    color_num = len(color_set)
    card_index_set_num = len(set(card_index_list))

    if card_index_set_num == 1:
        level = 5  # 豹子
    elif color_num == 1:
        if is_consecutive_numbers(card_index_list):
            # 顺金
            level = 4
        else:
            # 金花
            level = 3
    elif is_consecutive_numbers(card_index_list):
        # 顺子
        level = 2
    elif card_index_set_num == 2:
        # 对子
        level = 1
        # 只有这个特殊,需要获取对子的下标值作为得分,其余都是按最大牌算得分
        score = same_card_index_score
    return level, score


def main():
    all_cards_dict = gen_all_cards()
    all_cards = list(all_cards_dict.keys())
    player_index_result = allocate_playing_cards(all_cards, player_num=5)
    print(player_index_result)
    max_level = 0
    level_score_list = []
    for player_index, player_card_result in player_index_result.items():
        level, score = gen_level_and_score(player_card_result, all_cards_dict)
        print(player_card_result, level, score)
        level_score_list.append([level, score, player_index])
    _level_score_list = sorted(level_score_list, reverse=True)
    print(_level_score_list)
    print('第{}号玩家取胜'.format(_level_score_list[0][-1]))


if __name__ == '__main__':
    main()