python初体验 ——>>> 模拟体育竞技

python初体验 ——>>> 模拟体育竞技

一、排球训练营

1. 简介： 模拟不同的两个队伍进行排球的模拟比赛。

2. 模拟原理： 通过输入各自的能力值(Ⅰ)，模拟比赛的进行( P )，最后输出模拟的结果( O )。

P 简介：通过产生随机数得到每局比赛的难度，若小于能力值则表示赢得本局比赛，反之输掉本局比赛。

3. 规则简介：

① 每场比赛采用 5局3胜制。

② 前四局采用25分制，每个队只有在赢得至少25分，且同时超过对方2分时才胜一局。

③ 决胜局(第五局)采用15分制，先获得15分，且同时超过对方2分为胜。

4. 准备就绪，就差代码来实现了

插入代码之前，先对代码做个简单的介绍：

函数名称	函数说明
printInfo()	打印程序的介绍信息
getInputs()	获得用户输入的参数
printResult(n, winsA, winsB)	输出模拟比赛的结果
simNGames(n, probA, probB)	模拟n场比赛
simOneGame(probA, probB)	模拟一场比赛，包括五局，采取五局三胜制
simAGame(N, probA, probB)	模拟一局比赛
GameOver(N, scoreA, scoreB)	定义一局比赛的结束条件

好了，看看代码吧，虽然有点长，但应该可以看懂 ^_^

 # -*- encoding:utf-8 -*-
 '''
 模拟排球竞技
 @author: bpf
 '''
 # 比赛规则：
 # 1. 采用5局3胜制
 # 2. 前四局采用25分制，每个队只有在赢得至少25分，且同时超过对方2分时才胜一局
 # 3. 决胜局(第五局)采用15分制，先获得15分，且同时超过对方2分为胜

 from random import random
 from time import time
 def printInfo():
     '''
     function: 打印程序的介绍信息
     '''
     print("{:*^70}".format("产品简介"))
     print("产品名称： 排球竞技模拟分析器")
     print("产品概述： 通过输入2个队伍A和B的能力值(0到1之间的小数表示)，能够模拟多次2个队伍A和B的排球竞技比赛，从而得出各自的胜率！")
     print("产品作者： 步平凡 - 04")
     print("{:*^70}".format("模拟开始"))

 def getInputs():
     '''
     function: 获得用户输入的参数
     '''
     probA = eval(input("请输入队伍A的能力值(0~1)："))
     probB = eval(input("请输入队伍B的能力值(0~1)："))
     n = eval(input("请输入需要模拟比赛的场次数："))
     return probA, probB, n

 def printResult(n, winsA, winsB):
     '''
     function: 输出模拟比赛的结果
     '''
     print("{:*^70}".format("模拟结束"))
     print("竞技分析开始，共模拟{}场比赛。".format(n))
     print(">>>队伍A获胜{}场比赛，占比{:0.1%}".format(winsA,winsA/n))
     print(">>>队伍B获胜{}场比赛，占比{:0.1%}".format(winsB,winsB/n))

 def simNGames(n, probA, probB):
     '''
     function: 模拟n场比赛
     n: 模拟n场比赛
     probA, probB: 分别为队伍A和B的能力值
     winA, winB: 队伍A和B在一场比赛中获胜的局数
     winsA, winsB: 队伍A和B赢得比赛的场数，总共n场
     '''
     winsA, winsB = 0, 0
     for _ in range(n):
         winA, winB = simOneGame(probA, probB)
         if winA > winB:
             winsA += 1
         else:
             winsB += 1
     return winsA, winsB

 def simOneGame(probA, probB):
     '''
     function: 模拟一场比赛，包括五局，采取五局三胜制
     probA, probB： 分别为队伍A和B的能力值
     return: 返回队伍A和B在本场比赛中获胜的局数
     scoreA, scoreB: 分别为队伍A和B一局比赛获得的分数
     winA, winB: 分别为队伍A和B一场比赛获胜的局数
     N: 代表本次比赛的局次
     '''
     winA, winB = 0, 0
     for N in range(5):
         scoreA, scoreB = simAGame(N, probA, probB)
         if scoreA > scoreB:
             winA += 1
         else:
             winB += 1
         if winA == 3 or winB == 3:
             break
     return winA, winB

 def simAGame(N, probA, probB):
     '''
     function: 模拟一局比赛
     N: 代表本次比赛的局次
     probA, probB： 分别为队伍A和B的能力值
     return: 返回队伍A和B在本局比赛中获得的分数
     '''
     scoreA, scoreB = 0, 0    # 分别为队伍A和B一局比赛获得的分数
     serving = 'A'            # 发球方
     while not GameOver(N, scoreA, scoreB):
         if serving == 'A':
             if random() > probA:
                 scoreB += 1
                 serving = 'B'
             else:
                 scoreA += 1
         else:
             if random() > probB:
                 scoreA += 1
                 serving = 'A'
             else:
                 scoreB += 1
     return scoreA, scoreB

 def GameOver(N, scoreA, scoreB):
     '''
     function: 定义一局比赛的结束条件
     N: 代表当前局次(第五局为决胜局)
     return: 若比赛结束的条件成立返回真，否则为假
     '''
     if N <= 4:
         return (scoreA>=25 and abs(scoreA-scoreB)>=2) or (scoreB>=25 and abs(scoreA-scoreB)>=2)
     else:
         return (scoreA>=15 and abs(scoreA-scoreB)>=2) or (scoreB>=15 and abs(scoreA-scoreB)>=2)

 if __name__ == "__main__":
     printInfo()
     probA, probB, n = getInputs()
     Time = time()
     winsA, winsB = simNGames(n, probA, probB)
     print("模拟用时: {:.1f}s".format(time()-Time))
     printResult(n, winsA, winsB)

5. 运行结果展示，为了查看方便，我在cmd中运行代码

二、足球训练基地

1. 简介： 模拟不同的两个队伍进行足球的模拟比赛。

2. 模拟原理： 通过输入各自的能力值(Ⅰ)，模拟比赛的进行( P )，最后输出模拟的结果( O )。

P 简介：通过产生随机数得到半场比赛的回合数，再通过产生随机数得到每回合比赛的难度，若小于能力值则表示赢得本局比赛，反之输掉本场比赛。

3. 规则简介：

① 比赛分为两半场，每场为45分钟。

　　上半场: 一方挑选进攻的球门，另一方获得开球权；

　　下半场: 互换攻守方向，上半场没获得开球权的一方获得开球权。

②在进球后开球时，开球方为失球一方。

③ 比赛结束时得分多的球队获胜，如果两队得分相同或均未得分，比赛为平局。

4. 代码实现

By the way, 此代码与上述主要不同之处在于： GameOver()，其他函数都类似

函数名称	函数说明
printInfo()	打印程序的介绍信息
getInputs()	获得用户输入的参数
printResult(n, winsA, winsB)	输出模拟比赛的结果
simNGames(n, probA, probB)	模拟n场比赛
simOneGame(probA, probB)	模拟一场比赛，包括上半场和下半场
simAGame(N, probA, probB)	模拟半场比赛
GameOver(N, scoreA, scoreB)	定义半场比赛的结束条件

 # -*- encoding:utf-8 -*-
 '''
 模拟足球竞技
 @author: bpf
 '''
 # 比赛规则：
 # 1. 比赛分为两场，每场为45分钟
 #       上半场: 一方挑选进攻的球门，另一方获得开球权
 #       下半场: 互换攻守方向，上半场没获得开球权的一方获得开球权
 # 2. 在进球后开球时，开球方为失球一方
 # 3. 在没有违反任何比赛规则时，进攻球队得分。
 # 4. 比赛结束时得分多的球队获胜，如果两队得分相同或均未得分，比赛为平局。

 from random import random, randint
 from time import time
 def printInfo():
     '''
     function: 打印程序的介绍信息
     '''
     print("{:*^70}".format("产品简介"))
     print("产品名称： 足球竞技模拟分析器")
     print("产品概述： 通过输入2个队伍A和B的能力值(0到1之间的小数表示)，能够模拟多次2个队伍A和B的排球竞技比赛，从而得出各自的胜率！")
     print("产品作者： 步平凡 - 04")
     print("{:*^70}".format("模拟开始"))

 def getInputs():
     '''
     function: 获得用户输入的参数
     '''
     probA = eval(input("请输入队伍A的能力值(0~1)："))
     probB = eval(input("请输入队伍B的能力值(0~1)："))
     n = eval(input("请输入需要模拟比赛的场次数："))
     return probA, probB, n

 def printResult(n, via, winsA, winsB):
     '''
     function: 输出模拟比赛的结果
     '''
     print("{:*^70}".format("模拟结束"))
     print("竞技分析开始，共模拟{}场比赛。".format(n))
     print(">>>队伍A获胜{}场比赛，占比{:0.1%}".format(winsA,winsA/n))
     print(">>>队伍B获胜{}场比赛，占比{:0.1%}".format(winsB,winsB/n))
     print(">>>两队平局{}场，占比{:0.1%}".format(via,via/n))

 def simNGames(n, probA, probB):
     '''
     function: 模拟n场比赛
     n: 模拟n场比赛
     probA, probB： 分别为队伍A和B的能力值
     winsA, winsB: 队伍A和B赢得比赛的场数，总共n场
     '''
     via, winsA, winsB = 0, 0, 0
     for _ in range(n):
         scoreA, scoreB = simOneGame(probA, probB)
         if scoreA == scoreB:
             via += 1
         elif scoreA > scoreB:
             winsA += 1
         else:
             winsB += 1
     return via, winsA, winsB

 def simOneGame(probA, probB):
     '''
     function: 模拟一场比赛, 分上半场和下半场
     probA, probB： 分别为队伍A和B的能力值
     scoreA, scoreB: 分别为队伍A和B一场比赛的分数
     return: 返回队伍A和B在本场比赛中获得的分数
     '''
     winA, winB = 0, 0
     for N in range(2):
         scoreA, scoreB = simAGame(N, probA, probB)
         winA += scoreA
         winB += scoreB
     return winA, winB

 def simAGame(N, probA, probB):
     '''
     function: 模拟半场比赛
     probA, probB： 分别为队伍A和B的能力值
     scoreA, scoreB: 分别为队伍A和B半场比赛的分数
     return: 返回队伍A和B在本半场比赛中获得的分数
     '''
     scoreA, scoreB = 0, 0
     if N == 0:
         serving = 'A'            # 发球方
     else:
         serving = 'B'
     for _ in range(gameOver()):
         if serving == 'A':
             if random() < probA:
                 scoreA += 1
                 serving = 'B'
         else:
             if random() < probB:
                 scoreB += 1
                 serving = 'A'
     return scoreA, scoreB

 def gameOver():
     '''
     function: 定义半场比赛的结束条件
     通过randint产生一个随机数作为半场比赛的回合数, 若达到半场比赛的回合数则结束比赛
     return: 若比赛结束的条件成立返回真，否则为假
     '''
     return randint(3, 10)

 if __name__ == "__main__":
     printInfo()
     probA, probB, n = getInputs()
     Time = time()
     via, winsA, winsB = simNGames(n, probA, probB)
     print("模拟用时: {:.1f}s".format(time()-Time))
     printResult(n, via, winsA, winsB)

5. 运行结果展示，为了查看方便，我仍在cmd中运行代码

三、晋级模拟

1. 简介： 前2次分别对于排球和足球的模拟比赛分析，比赛规则的差距 体现 在代码上的不同，所以本次模拟分析多支队伍进行乒乓球比赛。

2. 模拟原理： 通过输入各自的能力值(Ⅰ)，模拟比赛的进行( P )，最后输出模拟的结果( O )。

P 简介：通过产生随机数得到每局比赛的难度，若小于能力值则表示赢得本局比赛，反之输掉本局比赛。当有多个队伍时，采取两两配对，但只遍历一次，因此，本代码功能不完善，仅供参考。

3. 规则简介：

①  一场比赛： 单打：采用七局四胜制； 双打淘汰赛、团体赛：采用五局三胜制。

② 一局比赛： 先得11分为胜，10平后，多得2分为胜

③ 一局比赛： 每队发球2次后，接发球方即成为发球方，依此类推，直至该局比赛结束 或者 到双方比分都达到10分时，发球和接发次序仍然不变，但每队只轮发一次球

4. 代码实现

　　本次代码与上述不同，本次采用类的方法来实现，不过基于本人对于乒乓球不熟悉及python用法有限，本次代码的功能有所限制，只能模拟数量为偶数的队伍进行比赛。待技术提升，会对代码进行改善和加强。

 # -*- encoding:utf-8 -*-
 '''
 模拟乒乓球竞技
 @author: bpf
 '''
 # 比赛规则：
 # 1. 一场比赛： 单打：采用七局四胜制
 #              双打淘汰赛、团体赛：采用五局三胜制
 # 2. 一局比赛： 先得11分为胜，10平后，多得2分为胜
 # 3. 一局比赛： 每队发球2次后，接发球方即成为发球方,依此类推，直至该局比赛结束
 #            或者到双方比分都达到10分时，发球和接发次序仍然不变，但每队只轮发一次球

 from random import random
 from pandas import DataFrame
 from time import time
 class SportCompetitionAnalyze:

     def PrintInfo(self):
         '''
         function: 打印程序的介绍信息
         '''
         print("{:*^70}".format("产品简介"))
         print("产品名称： 乒乓球竞技模拟分析器(采取单打淘汰赛制)")
         print("产品概述： 通过输入多个队伍的能力值(0到1之间的小数表示)，能够模拟多次多个队伍的乒乓球竞技比赛，从而得出各自的胜率！")
         print("产品作者： 步平凡 - 04")
         print("{:*^70}".format("模拟开始"))

     def GetInputs_for_Singal(self):
         '''
         function: 获得用户输入的参数 获得单打各队员的能力值
         '''
         self.n = eval(input("请输入需要模拟比赛的场数："))
         self.probAbilityList_Original = list(map(eval, input("(注：通过输入的次序进行两两配对, 即前两个分别为队员A和B;以此类推。)\n\
             请输入各队员的能力值(0~1), 请用英文逗号隔开(输入个数为2的倍数): ").split(',')))
         self.probAbilityList = self.probAbilityList_Original
         self.probNum = len(self.probAbilityList)

     def GetInputs_for_Double(self):
         '''
         function: 获得用户输入的参数 获得双打各队伍各队员的能力值
         probAbilityList: 使用各队伍中两队员的平均能力值作为该队伍的能力值 --- 双打
         probAbilityList_Original: 存储原生的各队员能力值, 后续可用
         '''
         self.probAbilityList, self.probAbilityList_Original = [], []
         self.n = eval(input("请输入需要模拟比赛的场数："))
         Original = list(map(eval, input("(注：通过输入的次序进行四四配对, 即前四个为队伍A和B;以此类推。)\n\
             请输入各队员的能力值(0~1), 请用英文逗号隔开(输入个数为4的倍数): ").split(',')))
         for i in range(0, len(Original), 2):
             self.probAbilityList.append((Original[i] + Original[i+1])/2)
             self.probAbilityList_Original.append(list([Original[i], Original[i+1]]))
         self.probNum = len(self.probAbilityList)

     def PrintResult(self):
         '''
         function: 输出模拟比赛的结果
         data: 存储每支的比赛信息
         '''
         print("{:*^70}".format("模拟结束"))
         print("竞技分析结束，每组共模拟{}场比赛。".format(self.n))
         data = []
         for i in range(self.probNum):
             tmplist = []
             tmplist.append(self.probAbilityList_Original[i])  # 存储能力值
             tmplist.append(self.probwinsList[i])              # 存储获胜的场数
             tmplist.append(self.probwinsList[i]/self.n)       # 存储胜率
             data.append(tmplist)
         dataSheet = DataFrame(data , index=list(range(1, self.probNum+1)), columns=list(["Ability", "wins", "rate"]))
         #dataSheet.sort_values(by="wins", inplace=True)       # 对比赛胜率rate进行排序, 会混乱比赛队伍的关系, 因此不采用
         print(dataSheet)

     def simNGames(self, GAMES, WINS):
         '''
         function: 模拟n场比赛
         probwinsList: 存储每支队伍赢得比赛的场数 的列表
         winA, winB: 队伍A和B在一场比赛中获胜的局数
         winsA, winsB: 队伍A和B赢得比赛的场数，总共n场
         '''
         self.probwinsList = []
         for i in range(0, self.probNum, 2):
             print("队员:", i+1, 'VS' ,i+2, "比赛中...")
             winsA, winsB = 0, 0
             for _ in range(self.n):
                 winA, winB = self.simOneGame(self.probAbilityList[i], self.probAbilityList[i+1], GAMES, WINS)
                 if winA > winB:
                     winsA += 1
                 else:
                     winsB += 1
             self.probwinsList.append(winsA)
             self.probwinsList.append(winsB)

     def simOneGame(self, probA, probB, GAMES, WINS):
         '''
         function: 模拟一场比赛  》》》 GAMES局 WINS胜
                 单打比赛，包括七局，采取七局四胜制
                 双打比赛，包括五局，采取五局三胜制
         scoreA, scoreB: 分别为队伍A和B一局比赛的分数
         winA, winB: 分别为队伍A和B一场比赛赢的局数
         return: 返回双方赢的局数
         '''
         winA, winB = 0, 0
         for _ in range(GAMES):
             scoreA, scoreB = self.simAGame(probA, probB)
             if scoreA > scoreB:
                 winA += 1
             else:
                 winB += 1
             if winA >=WINS or winB >= WINS:
                 break
         return winA, winB

     def simAGame(self, probA, probB):
         '''
         function: 模拟一局比赛
         probA, probB： 分别为队伍A和B的能力值
         return: 返回队伍A和B在本局比赛中获得的分数
         '''
         scoreA, scoreB = 0, 0
         serving = 'A'              # 发球方
         servingNum = 2             # 每方的发球次数
         while not self.GameOver(scoreA, scoreB):
             if scoreA >= 10 and scoreB >= 10:
                 servingNum = 1
             for _ in range(servingNum):
                 if random() > probA:
                     scoreB += 1
                 else:
                     scoreA += 1
             serving = 'B'
             for _ in range(servingNum):
                 if random() > probB:
                     scoreA += 1
                 else:
                     scoreB += 1
             serving = 'A'
         return scoreA, scoreB

     def GameOver(self, scoreA, scoreB):
         '''
         function: 定义赢得一局的条件: 先得11分为胜，10平后，多得2分为胜
         '''
         if scoreA >= 11 or scoreB >= 11:
             return (abs(scoreA-scoreB)>=2)
         elif (scoreA == 10 and scoreB > 11) or (scoreB == 10 and scoreA > 11):
             return (abs(scoreA-scoreB)>=2)
         else:
             return 0

 def print_MENU():
     print("程序简介：模拟乒乓球竞技")
     print("程序功能：\n\t1. 模拟多队员进行单打比赛\n\t2. 模拟多队伍多队员进行双打比赛")
     while 1:
         choose = input("功能选择：NO.")
         if choose in ['', '']:
             return eval(choose)
         else:
             print("输入有误, 请重新输入!")

 def simGameMenu():
     choose = print_MENU()
     if choose == 1:
         pingpong = SportCompetitionAnalyze()
         pingpong.PrintInfo()
         pingpong.GetInputs_for_Singal()
         Time = time()
         pingpong.simNGames(7, 4)
         print("模拟用时: {:.1f}s".format(time()-Time))
         pingpong.PrintResult()
     else:
         pingpong = SportCompetitionAnalyze()
         pingpong.PrintInfo()
         pingpong.GetInputs_for_Double()
         Time = time()
         pingpong.simNGames(5, 3)
         print("模拟用时: {:.1f}s".format(time()-Time))
         pingpong.PrintResult()

 if __name__ == "__main__":
     simGameMenu()

5. 代码写好了，看一下运行效果怎么样呗 ^v^

Tips：为了使用方便，可以使用python的第三方库pyinstaller进行打包，生成exe文件，可以方便运行。

接下来，我们试一下吧~~~

① 首先要安装pyinstaller库

在cmd中输入下面一句代码，详情就不介绍了。

pip install pyinstaller

② 使用方法： pyinstaller  <文件名>    》具体使用方法《

注： 使用pyinstaller时，路径不能出现中文，否则出现编码出错；最好在上述代码的main函数的最后加上 input() 语句，防止程序一运行完就自动退出。

之后双击运行exe文件即可 ↓↓↓

好了，今天就分享到这里，学习去咯~~~