利用Python编写简易版德州扑克小游戏

目录

• 德州扑克简要介绍
• 什么是德州扑克
• 游戏规则简要介绍
• 德州扑克游戏的python实现过程
• 游戏初始化
• 评选赢家
• 游戏主题函数
• 游戏体验与展示
• 模块不足与后续改进

德州扑克简要介绍

什么是德州扑克

德州扑克不知道大家是否玩过，它是起源于美国的得克萨斯州的一种博弈类卡牌游戏，英文名叫做Texas Hold’em Poker。玩法上又分为常规桌(Cash, 现金局)，单桌赛(SNG)和多桌锦标赛(MTT)。虽然扑克种类繁多，但基本的扑克规则通常保持一致。它是一种考验心态与谋略的游戏。

游戏规则简要介绍

一、使用道具

一副标准扑克牌去掉大小王后的52张牌进行游戏。

二、游戏人数

一般2-10个玩家，个别情况有12个玩家的。

三、游戏目的

赢取其他玩家筹码

四、下注宗旨

玩家之间同时继续看牌或比牌需要下同样注额筹码，筹码不足的玩家all-in全下后可以看到底并参与比牌。

五、发牌下注

发牌一般分为5个步骤，分别为，

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

Flop——同时发三张公牌，由小盲注开始（如果小盲注已盖牌，由后面最近的玩家开始，以此类推），按照顺时针方向依次表态，玩家可以选择下注、加注、或者盖牌放弃。

Turn——发第4张牌，由小盲注开始，按照顺时针方向依次表态。

River——发第五张牌，由小盲注开始，按照顺时针方向依次表态，玩家可以选择下注、加注、或者盖牌放弃。

比牌——经过前面4轮发牌和下注，剩余的玩家开始亮牌比大小，成牌最大的玩家赢取池底。

六、比牌方法

用自己的2张底牌和5张公共牌结合在一起，选出5张牌，不论手中的牌使用几张（甚至可以不用手中的底牌），凑成最大的成牌，跟其他玩家比大小。

比牌先比牌型，大的牌型大于小的牌型，牌型一般分为10种，从大到小为：

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

游戏初始化

#调用random库中的sample函数，用于从卡牌堆中随机抽取卡牌
from random import sample

#利用列表存储卡牌的花色与数字
color = ['黑桃','红桃','梅花','方块']
number = ['2','3','4','5','6','7','8','9','10','J','Q','K','A']

导入random库中的sample函数，后续用于从卡牌堆中随机抽取卡牌。同时利用列表分别将卡牌的颜色与数字存储在color与number中。

#PokerGenerator函数用于生成一组卡牌
def PokerGenerator():
    #将卡牌存储于列表中
    Poker = []
    # 用字典表示卡牌，在Poker列表中添加52张空白的卡牌
    for i in range(0,52):
        t = {'数字':0,'花色':''}
        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德州扑克内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！