python简单编程小游戏,扑克牌python类的写法

　　德州扑克，我不知道你是否玩过。它是一种起源于美国德克萨斯州的纸牌游戏，英文名为Texas Hold em Poker。本文将使用Python实现这个游戏，需要的可以参考。

　　00-1010德州扑克简介德州扑克游戏规则有哪些德州扑克游戏python实现流程简介德州扑克游戏游戏初始化及赢家选择游戏主题功能游戏体验及显示模块不足及后续改进

目录

德州扑克简要介绍

　　德州扑克，不知道你有没有玩过。它是一种起源于美国德克萨斯州的纸牌游戏，英文名为Texas Hold em Poker。游戏分为常规桌(现金)、单桌(SNG)和多桌锦标赛(MTT)。虽然扑克有很多种，但扑克的基本规则通常是一致的。这是一个考验心态和策略的游戏。

什么是德州扑克

　　一、使用道具

　　一副标准的扑克牌是去掉52张王后和皇后牌后玩的。

　　二、游戏人数

　　一般2-10人，偶尔12人。

　　三、游戏目的

　　赢得其他玩家的筹码

　　四、下注宗旨

　　玩家在同一时间继续看牌或比牌时，需要下注相同数量的筹码。筹码不足的玩家可以观看整场比赛，全押后参与比赛。

　　五、发牌下注

　　通常，许可分为五个步骤，即：

　　Perflop——先下大盲注和小盲注，然后给每位玩家2张牌。大盲注后面的第一个玩家选择跟注、加注或弃牌放弃。按照顺时针方向，其他玩家依次表态，大盲注玩家最后表态。如果玩家已经加注，前面已经跟注的玩家需要再次甚至多次表态。

　　Flop——同时发三张公共牌，从小盲注开始(如果小盲注已经盖牌，从后面最近的玩家开始，以此类推)。根据顺时针位置，玩家可以选择下注、加注或弃牌放弃。

　　Turn——发第四张牌，从小盲注开始，按顺时针方向依次陈述。

　　River——发了第五张牌，从小盲注开始，顺时针做陈述。玩家可以选择下注、加注或弃牌放弃。

　　在对Bi3354进行前四轮发牌和下注后，剩下的玩家开始显示Bi3354的大小，牌最大的玩家赢得池底。

　　六、比牌方法

　　将自己的2张牌和5张公牌组合，选择5张牌。不管你用多少张牌(甚至不需要你手里的牌)，你都可以把最大的牌做出来和其他玩家对比。

　　先把牌和牌对比，大牌比小牌大。一般有10种牌，从大到小：

游戏规则简要介绍

德州扑克游戏的python实现过程

　　#调用随机库中的sample函数，用于从牌堆中随机抽取牌。

　　从随机进口样品中

　　#使用列表存储卡片的颜色和数量

　　Color=[黑桃，红心，梅花，方块]

　　number=[2 ， 3 ， 4 ， 5 ， 6 ， 7 ， 8 ， 9 ， 10 ， J ， Q ， K ， A]

　　在随机库中导入sample函数，然后用它从牌堆中随机选择牌。同时，利用链表将卡片的颜色和数量分别存储在颜色和数量中。

　　#PokerGenerator函数用于生成一组卡片。

　　def PokerGenerator():

　　#在列表中储存卡片

　　扑克=[]

　　#用字典表示牌，在扑克列表中加入52张空白牌。

　　对于范围(0，52):内的I

　　T={number 33600， color 3360}

　　 Poker.append(t)

　　 #对每张卡牌进行赋值，每种花色各有13种花色，共四种花色，52张卡牌。

　　 for i in range(0,52):

　　 Poker[i].update({数字:number[i%13],花色:color[i//13]})

　　 #将存储有52张卡牌的列表Poker返回

　　 return Poker

　　函数PokerGenerator用于生成一副新的扑克牌，德州扑克所采用的扑克牌标准牌组，包含四种花色（‘黑桃’,‘红桃’,‘梅花’,‘方块’），每种花色有’2’到’A’等13张卡牌，共52张扑克，不包含大小王。

#根据玩家人数分发卡牌
　　def Pokerinitial(playersum):
　　 Playerpoker = []
　　 Poker = PokerGenerator()#初始化一副新的卡牌
　　 num = 52
　　 for i in range(0,playersum):
　　 Pripoker = sample(Poker,2)#从卡牌中随机抽取两张卡牌作为一名玩家的手牌
　　 Playerpoker.append(Pripoker)#所抽取的卡牌以元组形式假加入Playerpoker列表中，以Playerpoker的下标序号代表玩家的序号
　　 #将每位玩家所抽取的卡牌从卡牌堆中删除，即实现不放回抽样
　　 for n in [0,1]:
　　 for m in range(0,num):
　　 if Poker[m] == Pripoker[n]:
　　 del Poker[m]
　　 num -=1
　　 break 
　　 Publicpoker = sample(Poker,3)#从牌堆中再抽取三张牌作为公共牌
　　 #将所抽取的公共牌从牌堆中删除
　　 for n in [0,1,2]:
　　 for m in range(0,num):
　　 if Poker[m] == Publicpoker[n]:
　　 del Poker[m]
　　 num -=1
　　 break
　　 #将每位玩家的手牌与公共牌输出显示
　　 for i in range(0,playersum):
　　 print("玩家 %d"%(i+1)+"：牌1："+str(Playerpoker[i][0])+" 牌2："+str(Playerpoker[i][1]))
　　 print("")
　　 print("")
　　 print("") 
　　 print("公共牌: "+str(Publicpoker)+" ")
　　 return [Playerpoker,Poker,Publicpoker]#将玩家手牌，剩余的牌堆，公共牌组返回
　　

　　给每位玩家分发两张手牌，分发游戏开始时的三张公共牌，并将每位玩家的手牌情况与公共情况输出显示，利用字典表示扑克牌。

评选赢家

　　实现德州扑克最关键的一步便是计算出那位玩家的手牌最大，确定最终的赢家，若最终赢家有多位则平分奖池。我用0到8等9个数字分别代表高牌到同花顺等四个等级，我不专门为皇家同花顺列一个等级，若场上同时出现两个同花顺，则根据同花顺中最大的卡牌数字来确定赢家，接下来开始介绍判断各种手牌类别的方法。

#判断玩家的牌与公共牌是否构成顺子
　　def judgestraight(finalpoker):
　　    result = [0, 0]#用于储存结果，result[0]中储存此位玩家最好的五张牌的类别，从高牌到皇家同花顺编号为0到9。result[1]储存当前开组中数字最大的牌
　　    pokernum = []#存储卡牌的数字
　　    for i in range(0, len(finalpoker)):
　　        pokernum.append(number.index(finalpoker[i][数字]))
　　    pokernum.sort()#将卡牌号码从小到大进行排序
　　    #判断玩家卡牌与公共卡牌的组合是否能构成顺子
　　    maxp = minp = 0
　　    for i in range(1, len(finalpoker)):
　　        if (pokernum[i - 1] + 1) == pokernum[i]:
　　            maxp = i
　　        else:
　　            minp = i
　　        if (maxp - minp) == 4:
　　            result[0] = 4
　　            result[1] = max(pokernum[minp:maxp + 1])
　　    return result

　　judgestraight函数用于判断玩家手牌与五张公共牌是否能构成顺子，需要输入参数finalpoker。finalpoker应接受一个列表对象，其内应包含玩家手牌与最终的公共牌，总计7张牌。而后判断其中是否有顺子，并将判断结果返回。结果中包含了两个信息：result[0]若为4则表明其内包含有顺子，为0则不包含。若包含顺子result[1]中会存储顺子中最大的卡牌数字。

#判断卡组中是否存在同花
　　def judgeflush(finalpoker):
　　 result = [0, 0]
　　 pokernum = []
　　 flush = []#用于存储相同花色的卡牌
　　 while len(finalpoker) >= 5:
　　 #抽出卡组中同花色的卡牌
　　 flush.append(finalpoker[0])
　　 for i in range(1, len(finalpoker)):
　　 if finalpoker[i][花色] == finalpoker[0][花色]:
　　 flush.append(finalpoker[i])
　　 #若同花色卡牌不少于五张，那么卡组存在同花
　　 if len(flush) >= 5:
　　 result[0] = 5
　　 for ele in flush:
　　 pokernum.append(number.index(ele[数字]))
　　 result[1] = max(pokernum)
　　 for ele in flush:
　　 finalpoker.remove(ele)
　　 flush.clear()
　　 return result
　　

　　judgeflush函数用于判断玩家的手牌中是否包含有同花，并将结果返回。同上，judgestraight函数所返回的结果包含两个信息，玩家的手牌与公共拍的组合中是否包含有同花，若有同花则同时将同花中的最大数字返回。

#判断卡组中是否存在四条、三条、两对或一对
　　def judgesame(finalpoker):
　　 result = [0, 0]
　　 four = -1 #记录卡组中是否存在四条
　　 three = -1 #记录卡组中是否存在三条
　　 two = [-1, -1] #记录卡组中是否存在两对与一对
　　 count = 1
　　 pokernum = []
　　 bottom = 0
　　 #将卡组的所有卡牌号存储进pokernum中，并进行排序
　　 for i in range(0, len(finalpoker)):
　　 pokernum.append(number.index(finalpoker[i][数字]))
　　 pokernum.sort()
　　 #判断卡组中是否存在四条、三条、两对或一对等，并将所对应最大的卡牌数字进行存储
　　 for i in range(1, len(finalpoker)):
　　 if pokernum[i] == pokernum[bottom]:
　　 count += 1
　　 else:
　　 if count == 2:
　　 if pokernum[bottom] > min(two):
　　 numid = two.index(min(two))
　　 two[numid] = pokernum[bottom]
　　 if count == 3:
　　 if pokernum[bottom] > three:
　　 three = pokernum[bottom]
　　 if count == 4:
　　 four = pokernum[bottom]
　　 bottom = i
　　 count = 1
　　 #判断卡组中所存在的最大的组合牌类型
　　 if four >= 0:
　　 result[0] = 7
　　 result[1] = four
　　 elif three >= 0 and max(two) >= 0:
　　 result[0] = 6
　　 t = three * 10 + max(two)
　　 result[1] = t
　　 elif three >= 0:
　　 result[0] = 3
　　 result[1] = three
　　 elif min(two) >= 0:
　　 result[0] = 2
　　 result[1] = max(two)
　　 elif max(two) >= 0:
　　 result[0] = 1
　　 result[1] = max(two)
　　 return result
　　

　　这个函数相较于上面两个函数相对长很多，因为它一个函数实现了三个功能，判断玩家手牌与公共牌的组合中是否含有一对、两对、三条或四条。与上述函数功能相似，judgesame会判断所接受卡组中是否含有上述四种情况，若有则将等级最高的情况返回，同时将该情况中所含最大的卡牌数字返回。

#计算出玩家所持卡组中最大的组合牌类型
　　def computeresult(Playerpoker, Publicpoker):
　　 finalresult = [0, 0]
　　 finalpoker = []
　　 finalpoker = Playerpoker + Publicpoker
　　 a = finalpoker.copy()
　　 b = finalpoker.copy()
　　 c = finalpoker.copy()
　　 #分别存储同花、顺子、四条、三条（即数字相同的个数与情况）等的判断结果
　　 result_1 = judgeflush(a)
　　 result_2 = judgestraight(b)
　　 result_3 = judgesame(c)
　　 #判断是否是同花顺
　　 if result_1[0] != 0 and result_2[0] != 0:
　　 finalresult[0] = 8
　　 finalresult[1] = result_2[1]
　　 #若不是同花顺，则判断玩家手牌与公共牌所在组成的最大卡组种类
　　 else:
　　 t_0 = result_1[0]
　　 t_1 = result_1[1]
　　 if result_2[0] > t_0:
　　 t_0 = result_2[0]
　　 t_1 = result_2[1]
　　 if result_3[0] > t_0:
　　 t_0 = result_3[0]
　　 t_1 = result_3[1]
　　 #确定最终结果，即玩家所拥有的最大卡牌种类
　　 finalresult[0] = t_0
　　 finalresult[1] = t_1
　　 return finalresult
　　

　　我最终利用computeresult函数计算出每位玩家最终所拥有的最高等级卡组。在此函数中我分别调用了以上三个函数，通过比较得出玩家所拥有的最高等级卡组，并将结果返回。

游戏主题函数

　　我们编写的函数已能够实现游戏初始化与游戏结果的计算，接下来我们便利用以上函数编写德州扑克游戏的真正的主体。

#游戏函数主体
　　def gamestart(playersum):
　　 finalresult = []#用于存储每个玩家的最大手牌
　　 [playerpoker,Poker,Publicpoker] = Pokerinitial(playersum)#根据玩家数初始化一副卡牌，并给每位玩家分发两张手牌，并分发初始的三张公共牌
　　 playerlist = list(range(1,playersum+1))#记录每轮回合过后还剩下的玩家
　　 playerlist_t = []
　　 Playerpoker = []
　　 while len(Publicpoker) < 5 and len(playerlist) > 1:#当公共牌数为5或仅剩一个玩家时，游戏结束进行结算
　　 tag = 0 #标识符，标注所输入的继续游戏的玩家是否有误，若有误则重新输入
　　 playerkeep = input("请输入继续游戏的玩家:")
　　 playerlist_t = eval(playerkeep)
　　 if isinstance(playerlist_t,int):
　　 if playerlist_t in playerlist:
　　 winplayer = playerlist_t
　　 print("game over. The winner is "+str(winplayer))#若选择继续游戏的玩家仅有一人，则游戏结束进行结算
　　 return
　　 playerlist.clear()
　　 else:
　　 print("输入有误，请重新输入")#若输入玩家在本回合中不存在则报错并重新输入
　　 elif isinstance(playerlist_t, tuple):
　　 playerlist_t = list(playerlist_t)
　　 for i in playerlist_t:
　　 if i not in playerlist:
　　 tag = 1
　　 if tag == 1:
　　 print("输入有误，请重新输入")#若输入的玩家中有玩家在本回合中不存在则报错并重新输入
　　 else:
　　 playerlist = playerlist_t
　　 pokerkeep = sample(Poker,1)#从剩余卡牌中再抽取一张作为公共牌
　　 Publicpoker += pokerkeep
　　 pokerkeep = pokerkeep[0]
　　 print("公共牌: "+str(Publicpoker)+" ")#将本回合的公共牌进行显示
　　 for n in range(0,len(Poker)):#将所抽取的公共牌从剩余卡牌中删除
　　 if Poker[n] == pokerkeep:
　　 del Poker[n] 
　　 break
　　 for i in playerlist:
　　 Playerpoker.append(playerpoker[i-1])
　　 for ppoker in Playerpoker:
　　 finalresult.append(computeresult(ppoker, Publicpoker))#将每位玩家的手牌与公共牌代入计算最终结果
　　 finalscore = []
　　 finalscore_t = []
　　 finalplayer = []
　　 winner = []
　　 for t in range(0, len(finalresult)):
　　 finalscore.append(finalresult[t][0])
　　 maxscore = max(finalscore)#判断此时所有玩家中最大的组合牌类型
　　 #若有多位玩家同时拥有最大类型的组合牌，则对他们最大的牌数字进行比较
　　 for t in range(0, len(finalresult)):
　　 if finalscore[t] == maxscore:
　　 finalplayer.append(t) 
　　 for t in finalplayer:
　　 finalscore_t.append(finalresult[t][1])
　　 maxscore_t = max(finalscore_t) 
　　 for t in finalplayer:
　　 if finalresult[t][1] == maxscore_t:
　　 winner.append(playerlist[t])
　　 ##输出最终玩家
　　 print("game over.The winner is:")
　　 for t in winner:
　　 print("玩家:"+str(t))
　　 return 
　　

　　gamestart函数唯一需要输出的参数便是玩家的人数。在游戏的开始，我们利用Pokerinitial函数获得一副新卡牌，为每位玩家分发两张手牌，并分发三张初始公共牌。当玩家人数在游戏中途仅剩1时，我们认为游戏已结束，并显示最终赢家。若游戏正常进行到最后（有两位及以上玩家坚持到最后回合），则对每位玩家所拥有的最高等级卡牌组合进行计算与比较，得出最终赢家。若中途输入继续游戏的玩家并不在当前玩家队伍中时，系统会报错并提示重新输入。好了，话不多说，接下来我们便开始体验游戏吧！

游戏体验与展示

from Texas_Hold_em_Poker import gamestart
　　

　　我们首先导入我们所写的德州扑克游戏模块，并且仅需其中的gamstart函数。

n = input(请输入要进行的游戏的玩家人数:)
　　gamestart(int(n))
　　

　　接着我们便通过编写input函数从控制台获取进行游戏的玩家人数。

　　我们将参与游戏的玩家人数定为5

　　接着屏幕上便出现了每个玩家的手牌与公共牌。

　　接着我们输入继续游戏的玩家

　　接着出现了下一回合的公共牌，我们接着让1，2，3号玩家继续游戏

　　可以看到出现了最后回合的公共牌，并计算出了最终赢家。此时我们尝试输入上一回合并未继续参与游戏的玩家号，看看会出现什么。

　　我们仍然将游戏玩家人数定为5，并仍在第一回合让1，2，3号玩家继续游戏

　　但我们在下一回合输入已经退出游戏的玩家4号与5号

　　可以看到系统报错，并提示重新输入，此时我们只需要输入正确的玩家号码便可以得到正确的结果。

模块不足与后续改进

　　在游戏展示中我们可以看到玩家的手牌是公开的，而在实际中的德州扑克中，每位玩家的手牌都是完全保密的，这显然不符合实际要求。但由于此代码仅能在控制台中输出显示，所以也没有很好的办法对每位玩家的手牌进行保密，若接下来能实现可视化便可通过设置密钥的方式分别输出每位玩家的手牌，实现很好的保密作用，或者在此基础上将它发展成一个最终的小游戏也是能实现保密性的。

　　除此以外在德州扑克中需要有不停的加注与跟注，这也可以写成一个函数，这个等过段时间我稍微空了点可以补上去哈哈哈，有想法的朋友也可以自己来写着试试。

　　到此这篇关于利用Python编写简易版德州扑克小游戏的文章就介绍到这了,更多相关Python德州扑克内容请搜索盛行IT软件开发工作室以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT软件开发工作室！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。