"""手牌排序"""
def card_ranks(cards):
    ranks = [‘0123456789TJQKA‘.index(r) for r,s in cards]
    ranks.sort(reverse=True) #reverse实现降序排序
    return ranks

"""判读顺子"""
#注意，用set(ranks)实际上执行了一次唯一化操作，在将列表转换为集合的过程中，相同的元素只保留了一个，下同
def judge_straight(cards):
    ranks = card_ranks(cards)
    return ( max(ranks)-min(ranks) ) == 4 and len( set(ranks) )==5

"""判断是否为同花"""
def judge_flush(cards):
    hand_flush = [s for r,s in cards]
    return len( set(hand_flush) ) == 1

"""判断炸弹，三带二"""
#因为return会终止函数，所以如果在判断成对（即n=2）的时候，如果ranks中含有两对，结果只返回第一对，这也是后面判断成对的时候，为什么还出现lowpair的原因
def judge_kind(n,ranks):
    for r in ranks:
        if ranks.count(r) == n:
            return r
    return None

"""判读两对"""
#reversed()函数是返回序列seq的反向访问的迭代子。参数可以是列表，元组，字符串，不改变原对象。
#list(reversed(ranks))返回列表的反向排序的列表
#map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
def two_pair(ranks):
    pair = judge_kind(2,ranks)
    lowpair = judge_kind(2,list(reversed(ranks)))
    if pair and lowpair!=pair:
        return (pair,lowpair)
    else:
        return None

     
"""对九种牌型的总的排序"""
def hand_rank(hand):
    if type(hand)==tuple:
        hand = hand[1]

    ranks = card_ranks(hand)
    
    if judge_straight(hand) and judge_flush(hand):              #同花顺
        cards_type = "同花顺"
        return (9,max(ranks)),hand,cards_type
    elif judge_flush(hand):                                     #同花
        cards_type = "同花"
        return (8,ranks),hand,cards_type
    elif judge_kind(4,ranks):                                   #炸弹
        cards_type = "炸弹"
        return (7,judge_kind(4,ranks),judge_kind(1,ranks)),hand,cards_type
    elif judge_kind(3,ranks) and judge_kind(2,ranks):           #三带二
        cards_type = "三带二"
        return (6,judge_kind(3,ranks),judge_kind(2,ranks)),hand,cards_type
    elif judge_straight(hand):                                  #顺子
        cards_type = "顺子"
        return (5,max(ranks)),hand,cards_type
    elif judge_kind(3,ranks):                                   #三条
        cards_type = "三条"
        return (4,judge_kind(3,ranks),ranks),hand,cards_type
    elif two_pair(ranks):                                       #两对
        cards_type = "两对"
        return (3,two_pair(ranks),ranks),hand,cards_type
    elif judge_kind(2,ranks):                                   #一对
        cards_type = "一对"
        return (2,judge_kind(2,ranks),ranks),hand,cards_type
    else:                                                       #单张
        cards_type = "单张"
        return (1,ranks),hand,cards_type
    
        
"""判断扑克大小"""
#命名参数key，其为一个函数，用来指定取最大值的方法
def poker(hands):
    return(max(hands,key=hand_rank))

import random #生成随机数
import comparing_cards

"""随机生成己方手牌"""
def drawing_cards():
    #获取手牌数字
    str_tool1 = ‘0123456789TJQKA‘
    num1 =  [random.randint(2,13) for _ in range(5)]
    poker_number = [str_tool1[x] for x in num1]
    #获取手牌花色
    str_tool2 = ‘0SCDH‘
    num2 = [random.randint(1,4) for _ in range(5)]
    poker_suit = [str_tool2[x] for x in num2]
    #生成手牌组合（列表）
    cards = [poker_number[x]+poker_suit[x] for x in range(5)]
    return cards
    
    
#生成四个人的手牌
P1 = drawing_cards()
P2 = drawing_cards()
P3 = drawing_cards()
P4 = drawing_cards()
#判断牌面等级、类型
P1_type = comparing_cards.hand_rank(P1)
P2_type = comparing_cards.hand_rank(P2)
P3_type = comparing_cards.hand_rank(P3)
P4_type = comparing_cards.hand_rank(P4)

print("每个人的手牌是：")
print(‘P1‘,P1_type)
print(‘P2‘,P2_type)
print(‘P3‘,P3_type)
print(‘P4‘,P4_type)

winner = comparing_cards.poker((P1_type,P2_type,P3_type,P4_type))
print("获胜的人的手牌是：")
print(winner)