Python写的炸金花程序(含有特殊牌,可供2-17人重复玩耍)

下面附上运行示例

 输入1可再来一局

输入2可退出程序

下面附上源码，游戏规则在源码最后

import random

#生成一副扑克牌，除去大小王
poker1=[2,3,4,5,6,7,8,9,10,"J","Q","K","A"]
poker2=["♠","♥","♦","♣"]

shun_zi= []
count1=0
while count1<=10:
    shun_zi.append(poker1[count1:count1+3])
    count1+=1
shun_zi.insert(0,['A',2,3])
total_card_type=["豹子","同花顺","金花","顺子","对子","特殊"]

def game_entry():
    # 游戏开始,输入玩家名称
    name_list = input("请输入玩家名称:").split(",")
    while True:
        if len(set(name_list))<len(name_list):
            name_list=input("名字有重复!换个人吧!\n"+"请重新输入玩家名称:").split(",")
        elif len(name_list) < 2:
            name_list = input("人太少啦!再拉点人来!\n" + "请重新输入玩家名称:").split(",")
        elif len(name_list) > 17:
            name_list = input("人太多啦!叫些人旁观!\n" + "请重新输入玩家名称:").split(",")
        else:
            break
    return name_list

#发牌
def give_card(name):
    three_card_list=random.sample(poker_card,3)
    for x in three_card_list:
        poker_card.remove(x)
    print(f"{name}的牌是:",end="")
    for y in three_card_list:
        print(y,end=" ")
    total_card_list.append(three_card_list)
    return three_card_list

#确定牌型
def find_card_type(three_card_list):
    card_type=""

    if {d[1] for d in three_card_list}=={"A"}:
        print("牌型是豹子!")
        card_type="豹子"

    for c in shun_zi:
            if {d[1] for d in three_card_list} ==set(c):
                if len({d[0] for d in three_card_list})==1:
                    print("牌型是同花顺!")
                    card_type="同花顺"
                else:
                    print("牌型是顺子!")
                    card_type="顺子"

    if len({d[0] for d in three_card_list}) == 1 and card_type !="同花顺":
                print("牌型是金花!")
                card_type="金花"

    if len({d[1] for d in three_card_list})==2:
        print("牌型是对子!")
        card_type="对子"

    if len({d[0] for d in three_card_list})!=1 and {d[1] for d in three_card_list}=={2,3,5}:
        print("牌型是特殊!")
        card_type="特殊"

    if card_type not in total_card_type:
        print("牌型是散牌!")
        card_type="散牌"

    card_type_list.append(card_type)
    return card_type

#比牌
def compare_card(name):
    if "豹子" in card_type_list:
        if "特殊" not in card_type_list:
            print(f"让我们恭喜{name[card_type_list.index('豹子')]}成为最后的赢家!")
        else:
            index_list1=[g for g,h in enumerate(card_type_list) if h =="特殊"]
            if len(index_list1)==1:
                print(f"让我们恭喜{name[index_list1[0]]}成为最后的赢家!")
            else:
                print(f"本局游戏有{len(index_list1)}个赢家!")
                for k in index_list1:
                    print(f"恭喜{name[k]}!", end=" ")

    elif "同花顺" in card_type_list:
        index_list2=[g for g,h in enumerate(card_type_list) if h=="同花顺"]
        if len(index_list2)==1:
            print(f"让我们恭喜{name[index_list2[0]]}成为最后的赢家!")

        else:                                                       #比较多个同花顺
            ths_index_dict={}
            for l in index_list2:
                for c in shun_zi:                                       #遍历所有顺子
                    if {m[1] for m in total_card_list[l]}==set(c):
                        ths_index_dict[l]=shun_zi.index(c)          #{1:1,2:2,3:5,4:5}
            ths_max_list=[n for n in ths_index_dict.keys() if ths_index_dict[n]==max(ths_index_dict.values())]
            if len(ths_max_list)==1:                            #可能存在相同的最大同花顺
                print(f"让我们恭喜{name[ths_max_list[0]]}成为最后的赢家!")
            else:
                print(f"本局游戏共有{len(ths_max_list)}个赢家!")
                for k in ths_max_list:
                    print(f"恭喜{name[k]}!", end=" ")

# poker1=[2,3,4,5,6,7,8,9,10,"J","Q","K","A"]
    elif "金花" in card_type_list:
        index_list3=[g for g,h in enumerate(card_type_list) if h=="金花"]
        if len(index_list3)==1:
            print(f"让我们恭喜{name[index_list3[0]]}成为最后的赢家!")

        else:                                                           #金花不只一个，找出最大的金花
            poker_value_drop_dict={}
            for l in index_list3:
                poker_value_list=[m[1] for m in total_card_list[l]]
                poker_index_list=sorted([poker1.index(n) for n in poker_value_list],reverse=True)
                poker_value_drop_dict[l]=poker_index_list
            max_first=[p[0] for p in poker_value_drop_dict.values()]                                    #比较金花的第一张牌
            if max_first.count(max(max_first))==1:
                max_index_first=\
                    [k for k in poker_value_drop_dict.keys() if poker_value_drop_dict[k][0]==max(max_first)][0]
                print(f"让我们恭喜{name[max_index_first]}成为最后的赢家!")

            else:                                 #比较第二张牌#2,3,7\3,4,7/4，5，7
                del_list=[k for k in poker_value_drop_dict.keys() if poker_value_drop_dict[k][0]!=max(max_first)]
                for k in del_list:
                    del poker_value_drop_dict[k]                    #删掉比较第一张牌输掉的人
                for k in poker_value_drop_dict.values():
                    k.remove(k[0])                        #删掉剩下的人的第一张牌(都是一样的)
                max_second=[p[0] for p in poker_value_drop_dict.values()]                   #存大家的第二张牌2，3/3，4/4，5
                if max_second.count(max(max_second))==1:
                    max_index_second=\
                        [k for k in poker_value_drop_dict.keys() if poker_value_drop_dict[k][0]==max(max_second)][0]
                    print(f"让我们恭喜{name[max_index_second]}成为最后的赢家!")

                else:                                                           #比较第三张牌
                    del_list1=\
                        [k for k in poker_value_drop_dict.keys() if poker_value_drop_dict[k][0]!=max(max_second)]
                    for k in del_list1:
                        del poker_value_drop_dict[k]                #删掉比较第二张牌输掉的人
                    for k in poker_value_drop_dict.values():
                        k.remove(k[0])                  #删掉剩下的人的第二张牌(都是一样的),大家手里还剩一张牌
                    max_third=[p[0] for p in poker_value_drop_dict.values()]
                    if max_third.count(max(max_third))==1:
                        max_index_third=\
                            [k for k in poker_value_drop_dict.keys() if poker_value_drop_dict[k][0]==max(max_third)][0]
                        print(f"让我们恭喜{name[max_index_third]}成为最后的赢家!")

                    else:
                        max_index_last=\
                            [k for k in poker_value_drop_dict.keys() if poker_value_drop_dict[k][0]==max(max_third)]
                        print(f"本局游戏共有{len(max_index_last)}个赢家!")
                        for k in max_index_last:
                            print(f"恭喜{name[k]}!", end=" ")

    elif "顺子" in card_type_list:
        index_list4 = [g for g, h in enumerate(card_type_list) if h == "顺子"]
        if len(index_list4) == 1:
            print(f"让我们恭喜{name[index_list4[0]]}成为最后的赢家!")

        else:                                                       #比较多个顺子
            sz_index_dict={}
            for l in index_list4:
                for c in shun_zi:                                       #遍历所有顺子
                    if {m[1] for m in total_card_list[l]}==set(c):
                        sz_index_dict[l]=shun_zi.index(c)          #{1:1,2:2,3:5,4:5}
            sz_max_list=[n for n in sz_index_dict.keys() if sz_index_dict[n]==max(sz_index_dict.values())]
            if len(sz_max_list)==1:                            #可能存在相同的最大顺子
                print(f"让我们恭喜{name[sz_max_list[0]]}成为最后的赢家!")
            else:
                print(f"本局游戏共有{len(sz_max_list)}个赢家!")
                for k in sz_max_list:
                    print(f"恭喜{name[k]}!", end=" ")

    elif "对子" in card_type_list:
        index_list5 = [g for g, h in enumerate(card_type_list) if h == "对子"]
        if len(index_list5) == 1:
            print(f"让我们恭喜{name[index_list5[0]]}成为最后的赢家!")
        else:
            dz_index_dict = {}
            for l in index_list5:                                                                            #不止一个对子
                poker_value_list1 = [m[1] for m in total_card_list[l]]
                dz_index_dict[l]=[m for m in poker_value_list1 if poker_value_list1.count(m)==2][0]           #找出对子，构成字典
            for m,n in dz_index_dict.items():
                dz_index_dict[m]=poker1.index(n)                                            #确定牌的等值
            if list(dz_index_dict.values()).count(max(dz_index_dict.values()))==1:
                dz_winner=[m for m,n in dz_index_dict.items() if n ==max(dz_index_dict.values())][0]
                print(f"让我们恭喜{name[dz_winner]}成为最后的赢家!")

            else:                                                               #比较最后一张牌的大小
                del_list2=\
                    [m for m in dz_index_dict.keys() if dz_index_dict[m]!=max(dz_index_dict.values())]
                for l in index_list5:
                    poker_value_list2=[m[1] for m in total_card_list[l]]
                    dz_index_dict[l]=\
                        [m for m in poker_value_list2 if poker_value_list2.count(m)==1][0]     #将字典的值修改为第三张牌
                for k in del_list2:
                    del dz_index_dict[k]                                            #删掉比一次输了的人
                for m,n in dz_index_dict.items():
                    dz_index_dict[m]=poker1.index(n)
                if list(dz_index_dict.values()).count(max(dz_index_dict.values()))==1:
                    dz_winner1=[m for m,n in dz_index_dict.items() if n==max(dz_index_dict.values())][0]
                    print(f"让我们恭喜{name[dz_winner1]}成为最后的赢家!")

                else:
                    dz_winner2 = [m for m,n in dz_index_dict.items() if n == max(dz_index_dict.values())]
                    print(f"本局游戏共有{len(dz_winner2)}个赢家!")
                    for k in dz_winner2 :
                        print(f"恭喜{name[k]}!", end=" ")

    elif "散牌" in card_type_list:
        index_list3 = [g for g, h in enumerate(card_type_list) if h == "散牌"]
        poker_value_drop_dict = {}
        for l in index_list3:
            poker_value_list = [m[1] for m in total_card_list[l]]
            poker_index_list = sorted([poker1.index(n) for n in poker_value_list], reverse=True)
            poker_value_drop_dict[l] = poker_index_list
        max_first = [p[0] for p in poker_value_drop_dict.values()]  # 比较散牌的第一张牌
        if max_first.count(max(max_first)) == 1:
            max_index_first = \
            [k for k in poker_value_drop_dict.keys() if poker_value_drop_dict[k][0] == max(max_first)][0]
            print(f"让我们恭喜{name[max_index_first]}成为最后的赢家!")

        else:  # 比较第二张牌#2,3,7\3,4,7/4，5，7
            del_list =\
                [k for k in poker_value_drop_dict.keys() if poker_value_drop_dict[k][0] != max(max_first)]
            for k in del_list:
                del poker_value_drop_dict[k]  # 删掉比较第一张牌输掉的人
            for k in poker_value_drop_dict.values():
                k.remove(k[0])  # 删掉剩下的人的第一张牌(都是一样的)
            max_second = [p[0] for p in poker_value_drop_dict.values()]  # 存大家的第二张牌2，3/3，4/4，5
            if max_second.count(max(max_second)) == 1:
                max_index_second = \
                [k for k in poker_value_drop_dict.keys() if poker_value_drop_dict[k][0] == max(max_second)][0]
                print(f"让我们恭喜{name[max_index_second]}成为最后的赢家!")

            else:  # 比较第三张牌
                del_list1 =\
                    [k for k in poker_value_drop_dict.keys() if poker_value_drop_dict[k][0] != max(max_second)]
                for k in del_list1:
                    del poker_value_drop_dict[k]  # 删掉比较第二张牌输掉的人
                for k in poker_value_drop_dict.values():
                    k.remove(k[0])  # 删掉剩下的人的第二张牌(都是一样的),大家手里还剩一张牌
                max_third = [p[0] for p in poker_value_drop_dict.values()]
                if max_third.count(max(max_third)) == 1:
                    max_index_third = \
                    [k for k in poker_value_drop_dict.keys() if poker_value_drop_dict[k][0] == max(max_third)][0]
                    print(f"让我们恭喜{name[max_index_third]}成为最后的赢家!")

                else:
                    max_index_last = [k for k in poker_value_drop_dict.keys() if
                                      poker_value_drop_dict[k][0] == max(max_third)]
                    print(f"本局游戏共有{len(max_index_last)}个赢家!")
                    for k in max_index_last:
                        print(f"恭喜{name[k]}!", end=" ")

    else:                                                                       #全是散牌，最多四组
        print("本局游戏打成平局!")

if __name__=="__main__":
    print("欢迎来到炸金花游戏!理智赌博!理智消费!谢谢!")
    while True:
        poker_card=[[i,j] for i in poker2 for j in poker1]                  #每一局开始生成一副新的扑克牌
        total_card_list = []  # 存所有参加游戏的玩家的牌
        card_type_list = []  # 存所有游戏玩家的牌型
                                        #这三个变量后面要做修改不能申明为全局变量，否则玩第二局时会出问题
        name_list_=game_entry()
        for i in range(len(name_list_)):
            true_three_card_list=give_card(name_list_[i])
            find_card_type(true_three_card_list)
        print()
        compare_card(name_list_)
        go_on=input("赌博有风险,投资需谨慎!\n"+"1代表再来一局!\n"+"2代表不玩啦!\n"+"请输入您的选择:")
        while True:
            if go_on=="2":
                exit("Bye bye!")
            elif go_on=="1":
                break
            else:
                go_on=input("请输入1 or 2:")

#游戏规则
'''
一付扑克牌，去掉大小王，每个玩家发3张牌，最后比大小，看谁赢。
有以下几种牌：
豹子：三张点相同的牌，AAA、222。
同花顺：花色相同的顺子，黑桃456、红桃789。
金花：花色相同，非顺子，黑桃368，方片945。
顺子：花色不同的顺子，黑桃5红桃6方片7。顺子AKQ>KQJ……432>32A。注：KA2不是顺子。
对子：两张点相同的牌，223，334。不可能出现对子金花
散牌：三张牌不组成任何类型的牌。
特殊：花色不同的235
豹子>同花顺>金花>顺子>对子>散牌；特殊>豹子。特殊<散牌。
胜负判定
 a. 豹子〉同花顺〉金花〉顺子〉对子〉散牌
 b. 当豹子存在时，“花色不同235”〉“豹子”>金花
c. AKQ >KQJ>…234>A23。单牌大小：A>K>Q…..>2。
 d. 对子的情况，先比对，再比单。
 e. 全部为单张时，由最大的单张开始依次分别比较
1. 先生成一付完整的扑克牌
2. 给2-17个玩家随机发牌
3. 统一开牌，比大小，输出赢家是谁
'''