Python實現炸金花遊戲的示例代碼
今天的第二個作品，哈哈哈哈，搞起來感覺還挺有意思的，不過代碼裡紙牌J，Q，K，A幾個數字被我替換成瞭11，12，13，14……主要是沒有想到簡單的辦法讓其比較，索性都用數字瞭，我太菜瞭，希望有大佬指點一下。
代碼如下：
import random #導入隨機數函數
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):
"""
判斷隨機生成的三張撲克類型，對不同類型的牌 底分進行相應的翻倍
其中num參數返回的是對玩傢牌型計算後的分數。
（最小單張是：2，
11，12，13，14 分別代表：J，Q，K，A）
:param num:
:return:
"""
user_list1 = [] #用於存儲牌的花色
user_list2 = [] #用於存儲牌的數字
global list4 #聲明調用外部全局變量
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]) #將遍歷後的數字添加進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]: #判斷三張數字是否相同
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]: #判斷是否有兩個一樣的數字
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 = [] #定義新列表，存放玩傢數量
gamers = int(input('請輸入玩傢數量（隻能2 - 9名）：'))
if gamers >= 2 and gamers <= 9: #判斷用戶輸入的人數是否在規定范圍內
for i in range(gamers): # 玩傢數量由用戶定義，代表整體循環的次數
list4 = [] # 用於存儲每名玩傢隨機得到的三張牌
for j in range(3):
sun = random.randint(1, len(puke()) - 1) # 以隨機數為撲克整體的下標進行查找對應的牌
list4.append(puke()[sun]) # 添加進列表
puke().remove(puke()[sun]) # 把已經發出去的牌在撲克牌整體中進行刪除
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('你輸入的人數不合理，請重新輸入。')
old_grade = [] #定義一個新列表，用於存放以玩傢排序的分數
new_grade = [] #定義一個新列表，用於存放以大小排序後的分數
for i in gamer: #遍歷玩傢分數列表
old_grade.append(i)
new_grade.extend(old_grade)
old_grade.sort(reverse=True) #降序排列後的分數列表
user = 1
for j in new_grade: #遍歷玩傢順序的列表
if j == old_grade[0]:
print(f'{user}號玩傢獲勝，得分：{old_grade[0]}') #最終贏傢的分數沒有實際意義，僅為瞭判斷最大值
else:
user += 1
補充：示例2
一、Poker 類（撲克牌）
Card = collections.namedtuple('Card', ['rank', 'suit'])
class Poker(MutableSequence):
# 撲克牌的相關定義
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): # 僅僅實現瞭__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
一副撲克牌有 54 張牌，其中 52 張是正牌，另2張是副牌（大王和小王）。本程序中未涉及到大小王。52 張正牌又均分為 13 張一組，並以黑桃、紅桃、梅花、方塊四種花色表示各組，每組花色的牌包括從 2-10 以及 J、Q、K、A 標示的 13 張牌。
二、Player 類（玩傢）
Own_Poker = collections.namedtuple('Own_Poker', ['id', 'rank', 'suit', 'score'])
class Player():
'''
牌型 豹子：三張同樣大小的牌。 順金：花色相同的三張連牌。 金花：三張花色相同的牌。
順子：三張花色不全相同的連牌。 對子：三張牌中有兩張同樣大小的牌。 單張：除以上牌型的牌。
'''
def __init__(self, id, poker):
self.id = id
self.poker = poker #一副撲克牌
self.pokers = [] #玩傢手中的牌
self.type = 0 # 每個人初始都假定為三張毫無關系的牌，也就是撲克牌贏法中的“單張”
def set_card_score(self, card):
'''
按照點數判定撲克牌的大小
:param card:撲克牌卡片
:return:撲克牌點數大小
'''
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):
'''
通過值減下標的方式分組,如果三個值連續則被分配到同一個g中
比如說ll=[3,4,5,7,8]，分組時，enumerate(ll)=[(0,3),(1,4),(2,5),(3,7),(4,8)],fun函數值減下標，結果一樣的，就歸為一組
在本程序中，如果是三張連續的撲克牌，則應該是同一個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): # 返回一個產生按照fun進行分組後的值集合的迭代器.
if len([v for i, v in g]) == 3:
return True
return False
def judge_type(self):
'''
玩傢隨機發完三張牌後，根據撲克牌玩法進行區分，對手中的牌進行判別屬於哪種類型
: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()
每位玩傢都有一個名稱，用同一副撲克牌，炸金花遊戲要求每人手中有三張牌，根據手中的牌，程序初步判斷屬於哪種牌型，用於後續遊戲取勝機制做判斷。
三、Winner 類（遊戲取勝機制）
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):
'''
當牌型是對子的時候，經過匹配找出是對子的牌和單個的牌，這裡返回的是牌的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):
'''
當牌型為單牌時，計算手中的牌相加後的值大小
: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
# 先比較玩傢手中的牌型，大的勝出,玩牌的規則暫時不涉及到牌色，如有修改可以在此基礎上調整
# 豹子> 順金 > 金花 > 順子 > 對子 > 單張
if player1.type > player2.type:
return player1
elif player1.type < player2.type:
return player2
else: # 當玩傢雙方手中的牌型一致時，根據贏法一一判斷
if player1.type == 5 or player1.type == 4 or player1.type == 2: # 豹子、順金、順子 規則說明：按照比點
if self.get_max_card(player1) > self.get_max_card(player2):
return player1
else:
return player2
elif player1.type == 1: # 對子 規則說明：先比較相同兩張的值的大小，誰大誰勝出；如果對子相同，再比較單個
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: # 單牌，金花 規則：比較所有牌的點數大小，不區分牌色
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): ''' 發牌人（荷官）給兩位玩傢輪替發牌，發出去的牌都需要從這副撲克牌中剔除出去 :param poker: 那一副撲克牌 :param player1:玩傢1 :param player2:玩傢2 :return:整理後的撲克牌 ''' def distribute_card(player): card = choice(poker) # 發牌 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
詳細代碼可以訪問 https://github.com/Acorn2/fluentPyStudy/blob/master/chapter01/Poker_Demo.py
到此這篇關於Python實現炸金花遊戲的示例代碼的文章就介紹到這瞭,更多相關Python 炸金花遊戲內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！