python十点半纸牌游戏教程

布满荆棘的人生 2022-03-19 02:48 336阅读 0赞

**作品：十点半 / TenPointHalf（?）  
前言：这是我的python编程作业，一个python写的纸牌游戏。**

本文适合python入门新手，都是python基础知识

> **文章底部会贴出完整代码，如不想看罗嗦教程可以直接下划**

--------------------

\*其实这个游戏我总共写了两次，  
第一次是按游戏的设计一步一步写的，那时我刚接触python，写的乱七八糟  
其实现在大概也差不多，不过有些进步就是了。。  
那么我把它写完了，结果后来老师说：用类的方法来写  
我一下子傻了  
看了看以前写的代码，简直不能看……  
又乱又长可读性还差……  
就想着干脆就直接重构它吧

**花一晚上时间，一气呵成，把它重构了**\*

**原本我写这个破游戏居然写了500行……重构之后代码量大概在240行左右（不含注释）**

文章底部会贴出完整代码

--------------------

**游戏仅涉及python基础知识**

存档、读档（python文件读写）
    python类的运用（如init方法，self）
    random库和time库（洗牌和记录存档时间）
    循环、数组、字典、函数、集合等..
    
    游戏道具：扑克牌一副

--------------------

*我先讲讲这扑克牌游戏大概是怎么一回事*

1.  游戏支持2-4人游玩（这是作业的设定，其实只要你想，几个人都能玩）：**设定游戏人数，每个玩家输入自己的名字**
2.  开局，手动选择一名庄家：**指定序号的玩家称为庄家，庄家不需要下注**

*——顺带一提，我最初制作的是所有玩家丢骰子决定谁当庄家，重构的时候嫌麻烦就没那么整了*

1.  除庄家外的玩家（称**闲家**）下注：**最低下1元最高下20元（我定的 ）**
2.  发牌，一人一张，闲家可根据情况选择是否继续要牌，**点大的玩家赢**：**但手牌总点数超过十点半就要输钱了（称爆牌）**
3.  当所有的**闲家**都选择不要牌时，**庄家**可以开始选择是否继续要牌
4.  当**庄家**也不要牌时就可以**决胜**了，所有玩家的点数放在一起对比，输赢计算方式看下方

对了，这游戏里`J/Q/K`被称为`人牌`，均代表`0.5`点

--------------------

***核心规则***：`*获胜者不能爆牌（手牌总点数不超过10.5）*`

**某玩家点数最大，且全场没有出现与之相同点数的玩家**：他单人获胜  
**某玩家点数最大，但存在其它玩家与之点数相同**：持最大点数的玩家**都获胜**

**所有玩家都爆牌，下注金额全部归作者）**

--------------------

***发奖***：`*所有获胜者都有奖金，奖金是所有玩家本轮下注之和构成的奖池*`

**闲家赢，获得奖池中的钱，且庄家需要额外向获胜闲家支付与其下注金额等量的钱**（毕竟庄家不用下注…）  
**庄家赢，获得奖池中的钱**

***多人获胜则平分奖池中的奖金***

--------------------

首先是游戏道具，一副扑克牌，`Card`类；

#扑克牌类
        class Card:
            #初始化方法，包含了扑克牌对象的3个属性
            #3个属性：{花色，牌号，所代表的点数}
            def __init__(self,suit,rank,value):
               self.suit = suit
               self.rank = rank
               self.value = value
            #创建一副全新的扑克牌
            def InitCard(self):
                #创建扑克牌盒子
                self.cards = []
                #创建花色
                for suit in ["♠","♥","♣","♦"]:
                    #创建牌号
                    for rank in ["A","2","3","4","5","6","7","8","9","10","J","Q","K"]:
                        #实例化扑克牌对象，并赋予属性，然后装进扑克牌盒子
                        self.cards.append(self.Card(suit,rank,self.Calculate(rank)))
                #引入随机模块
                from random import shuffle as refresh
                #洗牌
                refresh(self.cards)

这里用到了`Calculate`，赋予每张扑克牌点数

#牌点计算器，用于在创建扑克牌对象时提供每张牌的点数
        #输入参数：{牌号}
        def Calculate(rank):
            #字典，数据来源
            dictionary = { "A":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9,"10":10,"J":0.5,"Q":0.5,"K":0.5}
            #约定点数并返回
            value = dictionary[rank]
            return value

接着是游戏参与者，`Players`类；

class Players:
            #初始化方法，包含了玩家对象的9个属性
            #9个属性：{序号，名称，手牌，庄家标记，要牌标记，未爆牌标记，下注，金钱，牌点}
            def __init__(self,number,name,hand,banker,want,inboom,bet,money,point):
               self.number = number
               self.name = name
               self.hand = hand
               self.banker = banker
               self.want = want
               self.inboom = inboom
               self.bet = bet
               self.money = money
               self.point = point

上面我给玩家设定了很多属性，方便 后面继续写……（并不方便

--------------------

**以上是游戏核心组成部分，下面开始真正的游戏结构**

游戏从`Game`类的`Process`开始

Game.Process(Game)

上面这句是放在全局最后面用来启动游戏的，我们看看下面的`Game`类  
顺带一提，游戏的一切都包围在`Game`类里

#游戏类
    class Game:
        #一般游戏进程，从读取存档开始
        def Process(self):
            #初始回合数为0
            self.rounds = 0
            #初始Continue标记为True
            self.Continue = True
            #读取游戏
            self.Read(self)
            #当Continue标记为True时循环进行游戏
            while self.Continue:
                #创建一个玩家集合
                self.player_set = set()
                #初始化扑克牌
                self.Card.InitCard(self)
                #每轮的开始都将重置每名玩家的部分信息
                for i in range(self.player_amount):
                    self.player_set.add(i)
                    self.player_list[i].banker = False
                    self.player_list[i].want = True
                    self.player_list[i].inboom = True
                    self.player_list[i].bet = 0
                    #下面两句是加牌操作，每名玩家1张
                    self.player_list[i].hand = [self.cards[0]]
                    del self.cards[0]
                #进入叫庄环节
                self.Banker(self,self.player_amount,self.player_set)

上面这段代码会先执行到`Read`，游戏尝试读档

#读取游戏的程序
        def Read(self):
            #首先进入读取游戏的子程序，子程序将判断系统是否能够读取游戏数据
            if self.__Read(self):
                #读取游戏存档
                with open("save.txt","r") as data:
                    save = data.readlines()
                #让玩家选择是开始新游戏还是继续上一局
                if input(">>>系统检测到您已存在游戏数据：\n{}\n{}\n>>>是否要接着玩呢？输y继续玩，输其它开始新游戏：".format((save[0])[0:save[0].find("[Savetime]")],save[1])) in ("y","Y"):
                    player_name = []
                    #读取玩家数量信息
                    self.player_amount = int((save[1])[save[1].find("[Rounds]")+8:save[1].find("[Players]")])
                    #读取游戏回合信息
                    self.rounds = int((save[1])[0:save[1].find("[Rounds]")])
                    #读取玩家名称信息
                    for i in range(self.player_amount):
                        player_name.append((save[i+2])[save[i+2].find("[Num]")+5:save[i+2].find("[Name]")])
                    #初始化扑克牌
                    self.Card.InitCard(self)
                    #初始化游戏，初始化方法为1
                    self.InitGame(self,player_name,self.player_amount,1)
                    #读取玩家金钱信息
                    for i in range(self.player_amount):
                        self.player_list[i].money = int((save[i+2])[save[i+2].find("[Name]")+6:save[i+2].find("[Money]")])
                    #清除读取的save，释放内存
                    del save
                    input(">>>已恢复上局游戏数据~<<<\n\n-戳回车键查看玩家信息并继续游戏")
                    #展示所有玩家信息
                    self.Show(self,self.player_amount)
                    #初始化游戏，初始化方法为3
                    self.InitGame(self,player_name,self.player_amount,3)
                #若玩家选择不读取，则开始新游戏
                else:
                    self.Start(self)

`Read`这里最开始是进入`__Read`，判断能否读到存档  
如果读不到存档就进入`Start`（全新开始）

#读取游戏的子程序
        def __Read(self):
            try:
                #检验是否能正常读取游戏数据，若能读取则返回True
                with open("save.txt","r"):
                    return True
            #否则将直接开始新游戏
            except:
                print(">>>系统未检测到游戏数据喔，新游戏将开始<<<")
                self.Start(self)

这个是`Start`

#游戏进程，从零开始
        def Start(self):
            #初始化扑克牌
            self.Card.InitCard(self)
            #初始化玩家
            self.PlayerInit(self)

绕了一圈，现在我们回到`Read`  
如果读到了存档，程序就只用初始化扑克牌`Card.InitCard`

毕竟从存档读取到了玩家的信息，不需要用`PlayerInit`方法

既然有了玩家和扑克牌，就可以初始化游戏了

#初始化游戏，初始化方法为1
    self.InitGame(self,player_name,self.player_amount,1)

我们先来看看`InitGame`函数  
这里我们给的`Action`参数是`1`

#初始化游戏，有三种初始化方法
        #输入参数：{玩家名称列表，玩家数量，初始化方式}
        def InitGame(self,player_name,player_amount,Action):
            #Action参数小于3时执行游戏初始化
            if Action < 3:
                #创建玩家列表，玩家集合
                self.player_list = []
                self.player_set = set()
                #给每位玩家添加初始数据
                for i in range(self.player_amount):
                    self.player_list.append(self.Players(i,player_name[i],[self.cards[0]],False,True,True,0,100,0))
                    self.player_set.add(i)
                    #因为中间涉及到了发牌，所以要从牌堆删除发给玩家的牌
                    del self.cards[0]
                #若Action等于2追加执行，进入叫庄环节
                if Action == 2:
                    self.Banker(self,self.player_amount,self.player_set)
            #Action参数等于3时不进行初始化，直接进入叫庄环节（成功读取到游戏数据）
            if Action == 3:
                self.Banker(self,self.player_amount,self.player_set)

那么`InitGame`只会执行创建玩家信息并给牌的操作  
再次回到`Read`，读取每名玩家的金钱信息

为什么不在一开始就读取呢？主要是因为我流程设计的原因…只能放到后面…

接着进入`Show`，展示玩家们的信息

#展示所有玩家信息的程序
        #输入参数：{玩家数量}
        def Show(self,player_amount):
            #此Flag用于记录玩家金钱是否不足以进行下一局游戏，初始值为True
            Flag = True
            #对于所有玩家
            for i in range(self.player_amount):
                #展示玩家信息
                print("\n>>>玩家{}：[{}]\n>>>庄家：{}\n>>>手牌：".format(i + 1,self.player_list[i].name,self.player_list[i].banker),end = "")
                #若此玩家金钱不足，Flag将设定为False，游戏将结束
                if int(self.player_list[i].money) <= 0:
                    Flag = False
                #展示玩家信息
                for n in range(len(self.player_list[i].hand)):
                    print(self.player_list[i].hand[n].suit + self.player_list[i].hand[n].rank,end = " ")
                print("\n>>>手牌点数：{}\n>>>本轮下注：{}$\n>>>钱包余额：{}$".format(self.player_list[i].point,self.player_list[i].bet,self.player_list[i].money))
            return Flag

`Show`的作用有两个：一个是展示所有玩家的信息，另一个是判断玩家有没有输光  
这里玩家还是有钱的，所以展示完成后又回到`Read`，执行到下面这段

#初始化游戏，初始化方法为3
    self.InitGame(self,player_name,self.player_amount,3)

初始化函数里`Action`参数为`3`的时候其实已经不是初始化了  
这里是直接进入叫庄环节（`banker`），游戏开始了

Banker(self,self.player_amount,self.player_set)

#叫庄环节
        #输入参数：{玩家数量，玩家集合}
        def Banker(self,player_amount,player_set):
            #进入叫庄意味着游戏正式开始，回合数将加1
            self.rounds += 1
            while True:
                try:
                    #输入庄家的玩家序号
                    banker_number = int(input("第{}局游戏开始，请您选出一名庄家，庄家不需要下注哟！\n>>>请指定庄家的序号，1-{}号都可以：".format(self.rounds,self.player_amount))) - 1
                    #若玩家序号没有错误将执行子程序
                    if banker_number in range(self.player_amount):
                        self.__Banker(self,self.player_amount,banker_number,self.player_set)
                        break
                    #玩家序号输入错误则报错
                    else:
                        print(">>>请输入正确的玩家序号哟，再试一次吧！<<<")
                #若输入非数字将报出此错
                except:
                    print("\n>>>系统监测到了错误，但是系统不知道怎么解决")

`Banker`负责判断玩家序号是否输入正确，若正确则进入`__Banker`修改庄家信息

#叫庄子程序
        #输入参数：{玩家数量，庄家编号，玩家集合}
        def __Banker(self,player_amount,banker_number,player_set):
            #修改该名玩家的庄家标识符
            self.player_list[banker_number].banker = True
            #从玩家集合中除去这名庄家，将其变为闲家集合
            self.player_set -= { banker_number}
            print("\n>>>{}号玩家：[{}]通过选举成为了庄家！".format(banker_number + 1,self.player_list[banker_number].name))
            #进入下注环节
            self.Bet(self,self.player_amount,banker_number,self.player_set)

庄家被确定，游戏进入下一个环节：下注 `Bet`

#下注环节
        #输入参数：{玩家数量，庄家编号，闲家集合}
        def Bet(self,player_amount,banker_number,player_set):
            #对于每名闲家
            for i in self.player_set:
                while True:
                    try:
                        #输入下注值
                        bet = int(input("-闲家{}：[{}]，轮到你下注了！\n>>>最低下1$，最高可以下20$：".format(i + 1,self.player_list[i].name)))
                        #限制下注值在1-20范围之间
                        if bet in range(1,21):
                            #进入下注子程序
                            if self.__Bet(self,i,bet):
                                break
                        #若下注不符合范围规定则报错
                        else:
                            print(">>>下注区间是1-20$，请注意下呢！<<<")
                    #若输入非整数将报此错
                    except:
                        print("\n>>>系统监测到了错误，但是系统不知道怎么解决")
            #进入补牌环节
            self.AugmentCard(self,self.player_amount,banker_number,self.player_set)

与`Banker`一样，`Bet`这里只负责判断，真正修改下注数据需要执行`__Bet`

#下注子程序
        #输入参数：{下注者编号，下注金额}
        def __Bet(self,i,bet):
            #判断该名玩家是否下假注（钱包里根本没那么多钱）
            if (self.player_list[i].money - bet) >= 0:
                #未超额，正常下注
                self.player_list[i].money -= bet
                self.player_list[i].bet = bet
                print("\n>>>闲家{}：[{}]下了{}$，钱包还剩{}$！".format(i + 1,self.player_list[i].name,bet,self.player_list[i].money))
                return True
            #超额了，返回False给主程序，主程序将给予回应
            else:
                print(">>>您的钱不够，您只有{}$！请重新下注！".format(self.player_list[i].money))
                return False

当每名闲家下注完，程序回到`Bet`这里，开始下一个环节：补牌

#进入补牌环节
    self.AugmentCard(self,self.player_amount,banker_number,self.player_set)

补牌环节是这个游戏里相对复杂的流程

***也是这个游戏中比较能体现`[博弈]`的场景  
牌点又要大过别人，又不能超过 10.5  
而且也不知道扑克牌堆里的下一张是什么，说不定一抽就成千古恨了***

说实话我感觉自己写的不怎么样……有点长乱

#补牌环节
        #输入参数：{玩家数量，庄家编号，闲家集合}
        def AugmentCard(self,player_amount,banker_number,player_set):
            #初始化补牌轮数为0
            count = 0
            #完成补牌的玩家数为0
            success = 0
            #设定补牌未完成标识为True
            insuccess = True
            print("\n>>>补牌阶段开始，闲家优先！<<<\n")
            #若补牌未完成标识为True
            while insuccess:
                #补牌轮数加1
                count += 1
                print("-第{}轮补牌开始！".format(count))
                #对于每名闲家
                for i in self.player_set:
                    #若该名闲家的要牌标记为True且不爆牌标记为True
                    if self.player_list[i].want and self.player_list[i].inboom:
                        #玩家可决定是否补牌，若输入为Y、y将进入补牌子程序
                        if input(">>>闲家{}：[{}]轮到你选择了！\n-目前牌点为{}，若要补牌请输入y：".format(i + 1,self.player_list[i].name,self.__calculate(self,i))) in ("Y","y"):
                            self.__AugmentCard(self,i)
                        #玩家选择不补牌则将玩家的要牌标记设为False
                        else:
                            print("\n>闲家{}不敢补了。".format(i + 1))
                            self.player_list[i].want = False
                    #补牌完成了，完成补牌的玩家数量加1
                    else:
                        success += 1
                        #若所有闲家均完成补牌，则将未完成标识符设为False，循环将停止
                        if success == self.player_amount - 1:
                            insuccess = False
            #接下来轮到庄家补牌了
            i = banker_number
            while True:
                #循环条件为庄家要牌标记为True且不爆牌标记为True
                if self.player_list[i].want and self.player_list[i].inboom:
                    #玩家可决定是否补牌，若输入为Y、y将进入补牌子程序
                    if input("\n>>>庄家{}：[{}]请注意！现在轮到你选择了！\n-目前牌点为{}，若要补牌请输入y：".format(i + 1,self.player_list[i].name,self.__calculate(self,i))) in ("Y","y"):
                        self.__AugmentCard(self,i)
                    #玩家选择不补牌则将玩家的要牌标记设为False
                    else:
                        print("\n>庄家{}不敢补了。".format(i + 1))
                        self.player_list[i].want = False
                #所有玩家完成补牌，结束循环
                else:
                    break
            #进入决胜环节
            self.Fight(self,self.player_amount,banker_number)

总而言之就是闲家补完庄家补，且爆牌者即刻出局，不得参与补牌……  
这里可能 有一些……复杂的判断 …所以写的比较长乱…水平有限……

和前面一样，`AugmentCard`也只负责表面工作，真正修改扑克牌数据是在`__AugmentCard`里面进行的

#补牌子程序
        #输入参数：{要牌者玩家编号}
        def __AugmentCard(self,i):
            print("\n-玩家{}：[{}]抽到了{}{}：{}点！".format(i + 1,self.player_list[i].name,self.cards[0].suit,self.cards[0].rank,self.cards[0].value))
            #从牌堆顶摸一张牌给玩家
            self.player_list[i].hand.append(self.cards[0])
            del self.cards[0]
            #玩家得牌后计算该名玩家的手牌点数，若大于10.5则爆牌
            if self.__calculate(self,i) > 10.5:
                print(">>>目前的点数为{}！您爆了，神仙也救不了您！".format(self.player_list[i].point))
                #修改不爆牌标记
                self.player_list[i].inboom = False
            #若未爆则对赌徒进行鼓励，增加赌场的预期收入
            else:
                print(">>>目前的点数为{}！再接再励哟！".format(self.player_list[i].point))

`__AugmentCard`负责告诉玩家自己抽到牌的点数，并判断玩家是否爆牌  
若玩家爆牌则修改一下该名玩家的爆牌标记，该名玩家即刻退出补牌环节

这里调用了`__calculate`计算牌点

#玩家牌点计算器
        #输入参数：{被计算牌点的玩家编号}
        def __calculate(self,i):
            #计算前先将记录玩家牌点的属性归零，因为稍后将给予新的数值
            self.player_list[i].point = 0
            #将玩家手中每张牌的点数加起来
            for n in range(len(self.player_list[i].hand)):
                self.player_list[i].point += self.player_list[i].hand[n].value
            #返回该名玩家的牌点
            return self.player_list[i].point

`__calculate`将返回指定玩家手牌点数的总和  
好了，回到我们的`AugmentCard`，接下来要进入到最终环节`Fight`，亮牌决胜

#进入决胜环节
    self.Fight(self,self.player_amount,banker_number)

这个环节同样比较长，比较复杂…… 也许只是我写的比较复杂而已……

#决胜环节
        #输入参数：{玩家数量，庄家编号}
        def Fight(self,player_amount,banker_number):
            #为了方便决出胜负，创建点数列表用于存放所有玩家的牌点
            point_list = []
            #创建奖金，初始值为0
            bouns = 0
            #对所有玩家进行操作
            for i in range(self.player_amount):
                #奖金为玩家下注总和
                bouns += self.player_list[i].bet
                #若玩家未爆牌（手牌点数和小于10.5）
                if self.player_list[i].point <= 10.5:
                    #则在点数列表中添加相应玩家的手牌点数
                    point_list.append(self.player_list[i].point)
                else:
                    #否则为这名玩家添加大小为"-1"的点数
                    point_list.append(-1)
            #判断玩家是否全爆，判断依据为："-1"数量是否小于玩家的总数
            if point_list.count(-1) < self.player_amount:
                #玩家未全爆，则找出点数最大值
                biggest = max(point_list)
                #若点数最大值出现重复现象
                if point_list.count(biggest) > 1:
                    #创建获胜玩家列表，重复且最高的玩家都将获胜
                    winner = [i for i,repeat in enumerate(point_list) if repeat == biggest]
                    print("\n>>>本轮游戏共有{}名玩家获胜：".format(len(winner)))
                    #对于每名获胜玩家，进入发奖子程序
                    for i in winner:
                        self.__Bouns(self,i,bouns/len(winner),banker_number)
                #若点数最大值未出现重复现象
                else:
                    #获胜者为该最大点数的所有者
                    i = point_list.index(biggest)
                    print("\n>>>恭喜玩家{}：[{}]获得本轮的胜利！<<<".format(i + 1,self.player_list[i].name))
                    #进入发奖子程序
                    self.__Bouns(self,i,bouns,banker_number)
            #若所有玩家都爆牌将不进行任何发奖
            else:
                print(">>>\n你们都爆了，这里的{}$谁也拿不走！".format(bouns),banker_number)
            #程序将在此停顿，接到回车键命令后继续进行
            input("\n>>>戳回车键展示所有玩家的数据<<<\n")
            #保存游戏数据
            self.Save(self,self.player_amount)
            #进入Show程序，程序在展示玩家数据的同时将判断是否有玩家输光，若未出现输光情况则可以继续进行下一轮游戏
            if self.Show(self,self.player_amount):
                if input("\n>>>还来一把？\n-输入n可以结束游戏，不输n继续游戏：") in ("n","N"):
                    #若玩家选择不继续，将结束游戏
                    self.GameExit(self)
            #若Show程序发现有玩家已经输光
            else:
                print(">>>啊哦，好像有人输光了！<<<")
                #结束游戏
                self.GameExit(self)

`Fight`主要的工作是判断获胜者，处理奖金，并将获胜者交给`__Bouns`颁奖  
对于多名玩家获胜的判断，这里用到了一点链表

下面是`__Bouns`

#发奖子程序
        #输入参数：{获奖者玩家编号，奖金，庄家编号}
        def __Bouns(self,i,bouns,banker_number):
            #若该名获奖者不是庄家
            if not self.player_list[i].banker:
                #从庄家的钱包中扣除该名获奖者在本轮中的下注金额，并将其加入奖池
                self.player_list[banker_number].money -= self.player_list[i].bet
                bouns += self.player_list[i].bet
                print("\n>>>闲家获胜，庄家要额外付给他与他下注同样多的钱，总共{}$！".format(self.player_list[i].bet))
            #发奖给获奖者
            self.player_list[i].money += bouns
            print(">>>玩家{}：[{}]共获得{}$奖金，钱包余额为{}$！".format(i + 1,self.player_list[i].name,bouns,self.player_list[i].money))

`__Bouns`的工作很简单，判断一下然后发钱就行了，再顺便告诉一下玩家自己赢（输）了多少钱

奖发完了，同时宣告这轮游戏正式结束，程序进入`Save`尝试保存游戏数据

#保存游戏的程序
        #输入参数：{玩家数量}
        def Save(self,player_amount):
            #首先进入保存游戏的子程序，子程序将判断系统是否能够保存游戏数据
            if self.__Save(self):
                #引入时间库，记录存档时间
                import datetime as date
                #重新格式化时间文本
                time = date.datetime.now().strftime("%Y.%m.%d-%H:%M:%S")
                #保存数据
                with open("save.txt","w+") as data:
                    #游戏数据：保存时间、游戏回合、玩家数量
                    data.writelines("{}[Savetime]\n{}[Rounds]{}[Players]\n".format(time,self.rounds,self.player_amount))
                    #玩家数据：玩家序号、玩家名称、玩家金钱
                    for i in range(self.player_amount):    
                        data.writelines("{}[Num]{}[Name]{}[Money]\n".format(self.player_list[i].number,self.player_list[i].name,int(self.player_list[i].money)))

`__Save`与`__Read`一样，就是用来测试能否读写文件的，其实这俩函数合并成一个就行了……

#保存游戏的子程序，用于判断能否保存游戏数据
        def __Save(self):
            try:
                with open("save.txt","w+"):
                    #若执行成功程序将返回True
                    return True
            #执行失败将报错
            except:
                print("\n>>>不知为何，系统无法保存游戏数据<<<")

`Save`运行后在py运行目录下写出一个txt存档，然后我们回到`Fight`，进行到执行`Show`了

#进入Show程序，程序在展示玩家数据的同时将判断是否有玩家输光，若未出现输光情况则可以继续进行下一轮游戏
            if self.Show(self,self.player_amount):
                if input("\n>>>还来一把？\n-输入n可以结束游戏，不输n继续游戏：") in ("n","N"):
                    #若玩家选择不继续，将结束游戏
                    self.GameExit(self)
            #若Show程序发现有玩家已经输光
            else:
                print(">>>啊哦，好像有人输光了！<<<")
                #结束游戏
                self.GameExit(self)

前面也提到过`Show`的两个作用，展示数据，以及判断玩家是否输光

如果存在任意一名玩家输光了钱，那当然是强制结束游戏，赶出赌场了，进入`GameExit`

当然，如果所有玩家都还有钱，还是可以主动选择是否结束游戏（`GameExit`）的

#结束游戏的程序
        def GameExit(self):
            self.Continue = False
            input("\n>>>十点半游戏到此结束！\nCopyright ©2018 武澳博\n>>>有问题的话欢迎来找我交流！\n\n-请按回车键结束程序")

当然，如果选择不结束，游戏会不断循环进行，直到有玩家输光，或者玩到你不想玩了为止

控制循环的部分在`Game.Process`，由一个`Continue`标记决定，回去上面看看吧

--------------------

到这本文也就结束了，作者刚读大一，水平有限，欢迎交流指正  
以前总看别人的文章，这下自己也写个一篇，继续努力

**下面贴出这个十点半游戏的完整代码：  
https://blog.csdn.net/qq\_26373925/article/details/87288054**

*原创*