import random ? #導(dǎo)入隨機數(shù)函數(shù)
def puke():
? ? """
? ? 生成一副52張的撲克牌（除去大小王）
? ? :return:
? ? """
? ? list1 = ['黑桃', '紅桃', '方塊', '梅花']
? ? list2 = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
? ? list3 = []
? ? for i in list1:
? ? ? ? for j in list2:
? ? ? ? ? ? dict1 = {i: j}
? ? ? ? ? ? list3.append(dict1)
? ? return list3
def func(num):
? ? """
? ? 判斷隨機生成的三張撲克類型，對不同類型的牌 底分進行相應(yīng)的翻倍
? ? 其中num參數(shù)返回的是對玩家牌型計算后的分數(shù)。
? ? （最小單張是：2，
? ? 11，12，13，14 ?分別代表：J，Q，K，A）
? ? :param num:
? ? :return:
? ? """
? ? user_list1 = [] ? ? #用于存儲牌的花色
? ? user_list2 = [] ? ? #用于存儲牌的數(shù)字
? ? global list4 ? ? #聲明調(diào)用外部全局變量
? ? for i in list4:
? ? ? ? user_list1.append(list(i.keys()))
? ? ? ? for j in i:
? ? ? ? ? ? user_list1.append(list(i.values()))
? ? user_list2.append(user_list1[1]) ? ? ? ?#將遍歷后的數(shù)字添加進user_list2中
? ? user_list2.append(user_list1[3])
? ? user_list2.append(user_list1[5])
? ? user_list2 = [int(x) for item in user_list2 for x in item] ? ? ?#合并列表
? ? user_list2.sort() ? ? ? #列表排序
? ? if user_list2[0] == user_list1[1] == user_list1[2]: ? ? #判斷三張數(shù)字是否相同
? ? ? ? num = user_list1[1][0] * 100000 + zhadan
? ? elif user_list1[0] == user_list1[2] == user_list1[4] and user_list2[2] - user_list2[1] == user_list2[1] - \
? ? ? ? ? ? user_list2[0] == 1: ? ? #判斷三張花色是否相同且連號
? ? ? ? num = user_list2[1] * 10000 + shunjin
? ? elif user_list2[2] - user_list2[1] == user_list2[1] - user_list2[0] == 1: ? ? ? #判斷是否連號
? ? ? ? num = user_list2[1] * 1000 + shunzi
? ? elif user_list2[0] == user_list2[1] or user_list2[1] == user_list2[2] or user_list2[2] == user_list2[0]: ? ? ? ?#判斷是否有兩個一樣的數(shù)字
? ? ? ? if user_list2[0] == user_list2[1]:
? ? ? ? ? ? num = user_list2[0] * 100 + duizi
? ? ? ? if user_list2[0] == user_list2[2]:
? ? ? ? ? ? num = user_list2[2] * 100 + duizi
? ? ? ? if user_list2[2] == user_list2[1]:
? ? ? ? ? ? num = user_list2[1] * 100 + duizi
? ? elif user_list2[0] != user_list2[1] != user_list2[2]: ? ? ? #最后一種可能，單張
? ? ? ? num = user_list2[2] * 10 + user_list2[1] + danzhang
? ? return num ? ? ?#返回計算后的分值
# ? ?定義玩家牌型的底分
zhadan = 100
shunjin = 80
shunzi = 60
duizi = 40
danzhang = 20
?
gamer = [] ? ? ?#定義新列表，存放玩家數(shù)量
gamers = int(input('請輸入玩家數(shù)量（只能2 - 9名）：'))
if gamers >= 2 and gamers <= 9: ? ? ? ?#判斷用戶輸入的人數(shù)是否在規(guī)定范圍內(nèi)
? ? for i in range(gamers): ?# 玩家數(shù)量由用戶定義，代表整體循環(huán)的次數(shù)
? ? ? ? list4 = [] ?# 用于存儲每名玩家隨機得到的三張牌
? ? ? ? for j in range(3):
? ? ? ? ? ? sun = random.randint(1, len(puke()) - 1) ?# 以隨機數(shù)為撲克整體的下標進行查找對應(yīng)的牌
? ? ? ? ? ? list4.append(puke()[sun]) ?# 添加進列表
? ? ? ? ? ? puke().remove(puke()[sun]) ?# 把已經(jīng)發(fā)出去的牌在撲克牌整體中進行刪除
? ? ? ? print(f'{i + 1}號玩家的底牌：{list4}')
? ? ? ? if i == 0:
? ? ? ? ? ? user_1 = func(0)
? ? ? ? ? ? gamer.append(user_1)
? ? ? ? elif i == 1:
? ? ? ? ? ? user_2 = func(0)
? ? ? ? ? ? gamer.append(user_2)
? ? ? ? elif i == 2:
? ? ? ? ? ? user_3 = func(0)
? ? ? ? ? ? gamer.append(user_3)
? ? ? ? elif i == 3:
? ? ? ? ? ? user_4 = func(0)
? ? ? ? ? ? gamer.append(user_4)
? ? ? ? elif i == 4:
? ? ? ? ? ? user_5 = func(0)
? ? ? ? ? ? gamer.append(user_5)
? ? ? ? elif i == 5:
? ? ? ? ? ? user_6 = func(0)
? ? ? ? ? ? gamer.append(user_6)
? ? ? ? elif i == 6:
? ? ? ? ? ? user_7 = func(0)
? ? ? ? ? ? gamer.append(user_7)
? ? ? ? elif i == 7:
? ? ? ? ? ? user_8 = func(0)
? ? ? ? ? ? gamer.append(user_8)
? ? ? ? elif i == 8:
? ? ? ? ? ? user_9 = func(0)
? ? ? ? ? ? gamer.append(user_9)
else:
? ? print('你輸入的人數(shù)不合理，請重新輸入。')
?
old_grade = [] ? ? ? #定義一個新列表，用于存放以玩家排序的分數(shù)
new_grade = [] ? ? ? ? #定義一個新列表，用于存放以大小排序后的分數(shù)
for i in gamer: ? ? ? ? #遍歷玩家分數(shù)列表
? ? old_grade.append(i)
new_grade.extend(old_grade)
old_grade.sort(reverse=True) ? ? #降序排列后的分數(shù)列表
?
user = 1
for j in new_grade: ? ? #遍歷玩家順序的列表
? ? if j == old_grade[0]:
? ? ? ? print(f'{user}號玩家獲勝，得分：{old_grade[0]}') ? ? #最終贏家的分數(shù)沒有實際意義，僅為了判斷最大值
? ? else:
? ? ? ? user += 1

Card = collections.namedtuple('Card', ['rank', 'suit'])

class Poker(MutableSequence):
? ? # 撲克牌的相關(guān)定義
? ? ranks = [str(n) for n in range(2, 11)] + list('JQKA')
? ? suits = 'spades hearts diamonds clubs'.split() ?# 黑桃，紅桃，方塊，梅花
? ? suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)#黑桃最大，紅桃次之，方塊再次之，梅花最小

? ? def __init__(self):
? ? ? ? self._cards = [Card(rank, suit) for rank in self.ranks
? ? ? ? ? ? ? ? ? ? ? ??? ??? ??? ??? ??? ?for suit in self.suits]

? ? def __len__(self):
? ? ? ? return len(self._cards)

? ? def __getitem__(self, position): ?# 僅僅實現(xiàn)了__getitem__方法，該對象就變成可迭代的
? ? ? ? return self._cards[position]

? ? def __setitem__(self, position, value):
? ? ? ? self._cards[position] = value

? ? def __delitem__(self, position):
? ? ? ? del self._cards[position]

? ? def insert(self, position, value):
? ? ? ? self._cards[position] = value

Own_Poker = collections.namedtuple('Own_Poker', ['id', 'rank', 'suit', 'score'])

class Player():
? ? '''
? ? 牌型　　豹子：三張同樣大小的牌?！　№樈穑夯ㄉ嗤娜龔堖B牌?！　〗鸹ǎ喝龔埢ㄉ嗤呐??！?
? ? 順子：三張花色不全相同的連牌?！　ψ樱喝龔埮浦杏袃蓮埻瑯哟笮〉呐啤！　螐垼撼陨吓菩偷呐?。
? ? '''

? ? def __init__(self, id, poker):
? ? ? ? self.id = id
? ? ? ? self.poker = poker ?#一副撲克牌
? ? ? ? self.pokers = []?? ?#玩家手中的牌
? ? ? ? self.type = 0 ?# 每個人初始都假定為三張毫無關(guān)系的牌，也就是撲克牌贏法中的“單張”

? ? def set_card_score(self, card):
? ? ? ? '''
? ? ? ? 按照點數(shù)判定撲克牌的大小
? ? ? ? :param card:撲克牌卡片
? ? ? ? :return:撲克牌點數(shù)大小
? ? ? ? '''
? ? ? ? rank_value = Poker.ranks.index(card.rank)
? ? ? ? suit_values = Poker.suit_values
? ? ? ? return rank_value * len(suit_values) + suit_values[card.suit]

? ? def sort_card_index(self, rank_index_list):
? ? ? ? '''
? ? ? ? 通過值減下標的方式分組,如果三個值連續(xù)則被分配到同一個g中
? ? ? ? 比如說ll=[3,4,5,7,8]，分組時，enumerate(ll)=[(0,3),(1,4),(2,5),(3,7),(4,8)],fun函數(shù)值減下標，結(jié)果一樣的，就歸為一組
? ? ? ? 在本程序中，如果是三張連續(xù)的撲克牌，則應(yīng)該是同一個g中，此時返回為Ture，否則為False
? ? ? ? :param rank_index_list:
? ? ? ? :return:
? ? ? ? '''
? ? ? ? fun = lambda x: x[1] - x[0]
? ? ? ? for k, g in groupby(enumerate(rank_index_list), fun): ?# 返回一個產(chǎn)生按照fun進行分組后的值集合的迭代器.
? ? ? ? ? ? if len([v for i, v in g]) == 3:
? ? ? ? ? ? ? ? return True
? ? ? ? return False

? ? def judge_type(self):
? ? ? ? '''
? ? ? ? 玩家隨機發(fā)完三張牌后，根據(jù)撲克牌玩法進行區(qū)分，對手中的牌進行判別屬于哪種類型
? ? ? ? :return:
? ? ? ? '''
? ? ? ? suit_list = []
? ? ? ? rank_list = []
? ? ? ? score_list = []
? ? ? ? for poker in self.pokers:
? ? ? ? ? ? suit_list.append(poker.suit)
? ? ? ? ? ? rank_list.append(poker.rank)
? ? ? ? ? ? score_list.append(poker.score)

? ? ? ? rank_index_list = [] ?# 撲克牌卡片在Poker中rank中的index
? ? ? ? for rank in rank_list:
? ? ? ? ? ? index = self.poker.ranks.index(rank)
? ? ? ? ? ? rank_index_list.append(index)

? ? ? ? if len(set(rank_list)) == 1:
? ? ? ? ? ? self.type = 5 ?# 豹子
? ? ? ? elif len(set(suit_list)) == 1:
? ? ? ? ? ? if self.sort_card_index(rank_index_list):
? ? ? ? ? ? ? ? self.type = 4 ?# 順金
? ? ? ? ? ? else:
? ? ? ? ? ? ? ? self.type = 3 ?# 金花
? ? ? ? elif self.sort_card_index(rank_index_list):
? ? ? ? ? ? self.type = 2 ?# 順子
? ? ? ? elif len(set(rank_list)) == 2:
? ? ? ? ? ? self.type = 1 ?# 對子

? ? def play(self):
? ? ? ? self.judge_type()

class Winner():
? ? def __init__(self, player1, player2):
? ? ? ? self.player1 = player1
? ? ? ? self.player2 = player2

? ? def get_max_card(self, player):
? ? ? ? '''
? ? ? ? 篩選出三張牌中最大的牌，這里返回的是在ranks中的index
? ? ? ? :param player:
? ? ? ? :return:
? ? ? ? '''
? ? ? ? ranks = Poker.ranks
? ? ? ? rank_index_list = [] ?# 撲克牌卡片在Poker中rank中的index
? ? ? ? for poker in player.pokers:
? ? ? ? ? ? index = ranks.index(poker.rank)
? ? ? ? ? ? rank_index_list.append(index)
? ? ? ? return max(rank_index_list)

? ? def get_card_suit(self, player):
? ? ? ? '''
? ? ? ? 返回撲克牌花色大小
? ? ? ? :param player:
? ? ? ? :return:
? ? ? ? '''
? ? ? ? suit_values = Poker.suit_values
? ? ? ? suit = player.pokers[0].suit
? ? ? ? return suit_values[suit]

? ? def get_card_value(self, player):
? ? ? ? '''
? ? ? ? 當(dāng)牌型是對子的時候，經(jīng)過匹配找出是對子的牌和單個的牌，這里返回的是牌的index，便于比較大小
? ? ? ? :param player:
? ? ? ? :return:
? ? ? ? '''
? ? ? ? ranks = Poker.ranks
? ? ? ? rank_index_dict = {} ?# 撲克牌卡片在Poker中rank中的index
? ? ? ? repeat_rank_value = 0 ?# 成對的兩張撲克牌的大小
? ? ? ? single_rank_value = 0 ?# 單個的撲克牌的大小
? ? ? ? for poker in player.pokers:
? ? ? ? ? ? index = ranks.index(poker.rank)
? ? ? ? ? ? if index in rank_index_dict:
? ? ? ? ? ? ? ? rank_index_dict[index] += 1
? ? ? ? ? ? else:
? ? ? ? ? ? ? ? rank_index_dict[index] = 1
? ? ? ? rank_index_dict = sorted(rank_index_dict.items(), key=lambda d: d[1], reverse=True)
? ? ? ? n = 0
? ? ? ? for key in rank_index_dict:
? ? ? ? ? ? if n == 0:
? ? ? ? ? ? ? ? repeat_rank_value = key
? ? ? ? ? ? else:
? ? ? ? ? ? ? ? single_rank_value = key
? ? ? ? ? ? n += 1
? ? ? ? return repeat_rank_value, single_rank_value

? ? def get_player_score(self, player):
? ? ? ? '''
? ? ? ? 當(dāng)牌型為單牌時，計算手中的牌相加后的值大小
? ? ? ? :param player:
? ? ? ? :return:
? ? ? ? '''
? ? ? ? ranks = Poker.ranks
? ? ? ? score = 0
? ? ? ? for poker in player.pokers:
? ? ? ? ? ? index = ranks.index(poker.rank) ?# 撲克牌卡片在Poker中rank中的index
? ? ? ? ? ? score += index
? ? ? ? return score

? ? def get_winner(self):
? ? ? ? player1, player2 = self.player1, self.player2
? ? ? ? # 先比較玩家手中的牌型，大的勝出,玩牌的規(guī)則暫時不涉及到牌色，如有修改可以在此基礎(chǔ)上調(diào)整
? ? ? ? # 豹子> 順金 > 金花 > 順子 > 對子 > 單張
? ? ? ? if player1.type > player2.type:
? ? ? ? ? ? return player1
? ? ? ? elif player1.type < player2.type:
? ? ? ? ? ? return player2
? ? ? ? else: ?# 當(dāng)玩家雙方手中的牌型一致時，根據(jù)贏法一一判斷
? ? ? ? ? ? if player1.type == 5 or player1.type == 4 or player1.type == 2: ?# 豹子、順金、順子 規(guī)則說明：按照比點
? ? ? ? ? ? ? ? if self.get_max_card(player1) > self.get_max_card(player2):
? ? ? ? ? ? ? ? ? ? return player1
? ? ? ? ? ? ? ? else:
? ? ? ? ? ? ? ? ? ? return player2
? ? ? ? ? ? elif player1.type == 1: ?# 對子 規(guī)則說明：先比較相同兩張的值的大小，誰大誰勝出；如果對子相同，再比較單個
? ? ? ? ? ? ? ? repeat_rank_value1, single_rank_value1 = self.get_card_value(player1)
? ? ? ? ? ? ? ? repeat_rank_value2, single_rank_value2 = self.get_card_value(player1)
? ? ? ? ? ? ? ? if repeat_rank_value1 > repeat_rank_value2:
? ? ? ? ? ? ? ? ? ? return player1
? ? ? ? ? ? ? ? elif repeat_rank_value1 < repeat_rank_value2:
? ? ? ? ? ? ? ? ? ? return player2
? ? ? ? ? ? ? ? else:
? ? ? ? ? ? ? ? ? ? if single_rank_value1 > single_rank_value2:
? ? ? ? ? ? ? ? ? ? ? ? return player1
? ? ? ? ? ? ? ? ? ? elif single_rank_value1 < single_rank_value2:
? ? ? ? ? ? ? ? ? ? ? ? return player2
? ? ? ? ? ? ? ? ? ? else:
? ? ? ? ? ? ? ? ? ? ? ? return None ?# 平局，大家手上的牌一樣大
? ? ? ? ? ? else: ?# 單牌，金花 ? 規(guī)則：比較所有牌的點數(shù)大小，不區(qū)分牌色
? ? ? ? ? ? ? ? if self.get_player_score(player1) > self.get_player_score(player2):
? ? ? ? ? ? ? ? ? ? return player1
? ? ? ? ? ? ? ? elif self.get_player_score(player1) < self.get_player_score(player2):
? ? ? ? ? ? ? ? ? ? return player2
? ? ? ? ? ? ? ? else:
? ? ? ? ? ? ? ? ? ? return None

def compare_card(card1, card2):
? ? '''
? ? 比較兩種撲克牌是否相同
? ? :param card1:
? ? :param card2:
? ? :return: 相同返回為True，否則為False
? ? '''
? ? if card1.rank == card2.rank and card1.suit == card2.suit:
? ? ? ? return True
? ? return False


def dutch_official_work(poker, player1, player2):
? ? '''
? ? 發(fā)牌人（荷官）給兩位玩家輪替發(fā)牌，發(fā)出去的牌都需要從這副撲克牌中剔除出去
? ? :param poker: 那一副撲克牌
? ? :param player1:玩家1
? ? :param player2:玩家2
? ? :return:整理后的撲克牌
? ? '''
? ? def distribute_card(player):
? ? ? ? card = choice(poker) ?# 發(fā)牌
? ? ? ? player.pokers.append(Own_Poker(player.id, card.rank, card.suit, player.set_card_score(card)))
? ? ? ? for i in range(len(poker)):
? ? ? ? ? ? if compare_card(card, poker[i]):
? ? ? ? ? ? ? ? poker.__delitem__(i)
? ? ? ? ? ? ? ? break

? ? shuffle(poker) ?# 洗牌
? ? for k in range(3):
? ? ? ? distribute_card(player1)
? ? ? ? distribute_card(player2)

? ? return poker