zoukankan html css js c++ java

羽毛球竞技模拟

一、体育竞技模拟分析简要介绍

体育竞技模拟分析，是个IPO问题，大致过程如下：

输入：两个球员（球员A和B）的能力概率，模拟比赛的场次

处理：模拟比赛过程

输出：球员A和B分别赢得球赛的概率

二、程序设计方法

程序设计有自顶向下和自底向上两种方法，此处重点介绍自顶向下。

自顶向下的基本思想：以一个总问题出发，试图把它表达为很多小问题组成的解决方案，再用同样的技术依次攻破每个小问题，最终问题变得非常小，也就是化整为零。然后把所有的碎片组合起来，就可以得到一个程序。

自顶向下设计：

1.顶层设计

体育竞技分析从用户处得到模拟参数，最后输出结果，以下是一个基础设计的4个步骤。

步骤一：打印程序的介绍性信息。 printIntro()函数

def main():
    printIntro()

步骤二：获得程序运行需要的参数，即probA、porbB、n。 getInputs()函数

def main():
    printIntro()
    probA,probB,n=getInputs()

步骤三：利用球员A和B的能力值probA和probB,模拟n次比赛。（核心函数） simNGames()函数

def main():
    printIntro()
    probA,probB,n=getInputs()
    winA,winB=simNGames(n,probA,probB)

步骤四：输出球员A和B获得比赛的场次及概率。 printSummary()函数

def main():
    printIntro()
    probA,probB,n=getInputs()
    winA,winB=simNGames(n,probA,probB)
    printSummary(winsA,winsB)

2.第n层设计

（1）simNGames()函数是整个函数的核心，其基本思路是模拟n场比赛，并跟踪记录每个球员赢得了多少比赛。

def simNGames(n,probA,porbB):
    winsA,winsB=0,0
    for i in range(n):
        scoreA,scoreB=simOneGame(porbA,porbB)
        if scoreA>scoreB:
            winsA+=1
        else:
            winsB+=1
            reture winsA,winsB

代码中设计了sinOneGame()函数，用于模拟一场比赛，这个函数需要知道每个球员的概率，返回两个球员的最终得分　

（2）接下来实现simOneGame()函数。模拟一场比赛，需要根据比赛规则来编写代码。

以下是羽毛球的比赛规则：

1. 21 分制，3局2胜为佳
2. 每球得分制
3. 每回合中，取胜的一方加 1 分
4. 当双方均为 20 分时，领先对方 2 分的一方赢得该局比赛
5. 当双方均为 29 分时，先取得 30 分的一方赢得该局比赛
6. 一局比赛的获胜方在下一局率先发球

def simOneGame(probA,porbB):
    scoreA,score=0,0
    serving="A"
    while not gameOver(scoreA,scoreB):
        if serving =="A":
            if random()<porbA:
                scoreA+=1
            else:
                serving="B"
        else:
            if random()<probB:
                scoreB+=1
            else:
                serving="A"
    return scoreA,scoreB

3.整个程序如下：

#体育竞技
from random import random
def printInfo():
    print("这个程序模拟两个选手A和B的羽毛球竞技比赛")
    print("程序需要两个选手的能力值0-1")
    print("规则：三局两胜--21分制")
    print("作者：17杨宇平")
 
def getInput():
    a = eval(input("请输入选手A的能力值(0-1):"))
 
    b = eval(input("请输入选手B的能力值(0-1):"))
 
    m=eval(input("比赛的局数："))
 
    n = eval(input("模拟比赛的场次:"))
    return a,b,m,n
 
 
def printSummary(winsA,winsB):
 
    n = winsA + winsB
 
    print("竞技分析开始,共模拟{}场比赛".format(n))
 
    print("选手A获胜{}场比赛,占比{:0.1%}".format(winsA,winsA/n))
           
    print("选手B获胜{}场比赛,占比{:0.1%}".format(winsB,winsB/n))
 
 
def simNGames(m,n,probA,probB):
 
    winsA,winsB = 0,0
    wa,wb=0,0
 
    for i in range(n):
        for i in range(m):
 
            scoreA,scoreB = simOneGame(probA,probB)
 
            if scoreA > scoreB:
                 wa += 1
            else:
                wb += 1
 
            if wa==2:
                winsA+=1
                wa,wb=0,0
                break
            if wb==2:
                winsB+=1
                wa,wb=0,0
                break
  
 
    return winsA,winsB
         
     
def simOneGame(probA,probB):
 
    scoreA,scoreB = 0,0
 
    serving = "A"
    while not gameOver(scoreA,scoreB):
 
        if serving == "A":
 
            if random() < probA:
 
                scoreA += 1
            else:
                serving = "B"
        else:
            if random() < probB:
                scoreB += 1
            else:
                serving = "A"
    return scoreA,scoreB
def gameOver(a,b):
    if(a>=20 or b>=20):
        if(abs(a-b)==2 and a<=29 and b<=29):
            return True
        else:
            return a==30 or b==30
    else:
        return False
     
def main():
    printInfo()
    probA,probB,m,n = getInput()
    winsA,winsB = simNGames(m,n,probA,probB)
    printSummary(winsA,winsB)
  
main()

运行结果：

三、程序打包

使用pyinstaller打包，把Python脚本打包成可执行的文件。即把.py文件打包成.exe文件。

四、足球训练基地

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用法有限，本次代码的功能有所限制，只能模拟数量为偶数的队伍进行比赛。待技术提升，会对代码进行改善和加强。

  1 # -*- encoding:utf-8 -*-
  2 '''
  3 模拟乒乓球竞技
  4 @author: bpf
  5 '''
  6 # 比赛规则：
  7 # 1. 一场比赛： 单打：采用七局四胜制
  8 #              双打淘汰赛、团体赛：采用五局三胜制
  9 # 2. 一局比赛： 先得11分为胜，10平后，多得2分为胜
 10 # 3. 一局比赛： 每队发球2次后，接发球方即成为发球方,依此类推，直至该局比赛结束
 11 #            或者到双方比分都达到10分时，发球和接发次序仍然不变，但每队只轮发一次球
 12 
 13 from random import random
 14 from pandas import DataFrame
 15 from time import time
 16 class SportCompetitionAnalyze:
 17 
 18     def PrintInfo(self):
 19         '''
 20         function: 打印程序的介绍信息
 21         '''
 22         print("{:*^70}".format("产品简介"))
 23         print("产品名称： 乒乓球竞技模拟分析器(采取单打淘汰赛制)")
 24         print("产品概述： 通过输入多个队伍的能力值(0到1之间的小数表示)，能够模拟多次多个队伍的乒乓球竞技比赛，从而得出各自的胜率！")
 25         print("产品作者： 步平凡 - 04")
 26         print("{:*^70}".format("模拟开始"))
 27     
 28     def GetInputs_for_Singal(self):
 29         '''
 30         function: 获得用户输入的参数 获得单打各队员的能力值
 31         '''
 32         self.n = eval(input("请输入需要模拟比赛的场数："))
 33         self.probAbilityList_Original = list(map(eval, input("(注：通过输入的次序进行两两配对, 即前两个分别为队员A和B;以此类推。)

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

 47             请输入各队员的能力值(0~1), 请用英文逗号隔开(输入个数为4的倍数): ").split(',')))
 48         for i in range(0, len(Original), 2):
 49             self.probAbilityList.append((Original[i] + Original[i+1])/2)
 50             self.probAbilityList_Original.append(list([Original[i], Original[i+1]]))
 51         self.probNum = len(self.probAbilityList)
 52     
 53     def PrintResult(self):
 54         '''
 55         function: 输出模拟比赛的结果
 56         data: 存储每支的比赛信息
 57         '''
 58         print("{:*^70}".format("模拟结束"))
 59         print("竞技分析结束，每组共模拟{}场比赛。".format(self.n))
 60         data = []
 61         for i in range(self.probNum):
 62             tmplist = []
 63             tmplist.append(self.probAbilityList_Original[i])  # 存储能力值
 64             tmplist.append(self.probwinsList[i])              # 存储获胜的场数
 65             tmplist.append(self.probwinsList[i]/self.n)       # 存储胜率
 66             data.append(tmplist)
 67         dataSheet = DataFrame(data , index=list(range(1, self.probNum+1)), columns=list(["Ability", "wins", "rate"]))
 68         #dataSheet.sort_values(by="wins", inplace=True)       # 对比赛胜率rate进行排序, 会混乱比赛队伍的关系, 因此不采用
 69         print(dataSheet)
 70 
 71     def simNGames(self, GAMES, WINS):
 72         '''
 73         function: 模拟n场比赛
 74         probwinsList: 存储每支队伍赢得比赛的场数 的列表
 75         winA, winB: 队伍A和B在一场比赛中获胜的局数
 76         winsA, winsB: 队伍A和B赢得比赛的场数，总共n场
 77         '''
 78         self.probwinsList = []
 79         for i in range(0, self.probNum, 2):
 80             print("队员:", i+1, 'VS' ,i+2, "比赛中...")
 81             winsA, winsB = 0, 0
 82             for _ in range(self.n):
 83                 winA, winB = self.simOneGame(self.probAbilityList[i], self.probAbilityList[i+1], GAMES, WINS)
 84                 if winA > winB:
 85                     winsA += 1
 86                 else:
 87                     winsB += 1
 88             self.probwinsList.append(winsA)
 89             self.probwinsList.append(winsB)
 90 
 91     def simOneGame(self, probA, probB, GAMES, WINS):
 92         '''
 93         function: 模拟一场比赛  》》》 GAMES局 WINS胜
 94                 单打比赛，包括七局，采取七局四胜制
 95                 双打比赛，包括五局，采取五局三胜制
 96         scoreA, scoreB: 分别为队伍A和B一局比赛的分数
 97         winA, winB: 分别为队伍A和B一场比赛赢的局数
 98         return: 返回双方赢的局数
 99         '''
100         winA, winB = 0, 0
101         for _ in range(GAMES):
102             scoreA, scoreB = self.simAGame(probA, probB)
103             if scoreA > scoreB:
104                 winA += 1
105             else:
106                 winB += 1
107             if winA >=WINS or winB >= WINS:
108                 break
109         return winA, winB
110 
111     def simAGame(self, probA, probB):
112         '''
113         function: 模拟一局比赛
114         probA, probB： 分别为队伍A和B的能力值
115         return: 返回队伍A和B在本局比赛中获得的分数
116         '''
117         scoreA, scoreB = 0, 0
118         serving = 'A'              # 发球方
119         servingNum = 2             # 每方的发球次数
120         while not self.GameOver(scoreA, scoreB):
121             if scoreA >= 10 and scoreB >= 10:
122                 servingNum = 1
123             for _ in range(servingNum):
124                 if random() > probA:
125                     scoreB += 1
126                 else:
127                     scoreA += 1
128             serving = 'B'
129             for _ in range(servingNum):
130                 if random() > probB:
131                     scoreA += 1
132                 else:
133                     scoreB += 1
134             serving = 'A'
135         return scoreA, scoreB
136 
137     def GameOver(self, scoreA, scoreB):
138         '''
139         function: 定义赢得一局的条件: 先得11分为胜，10平后，多得2分为胜
140         '''
141         if scoreA >= 11 or scoreB >= 11:
142             return (abs(scoreA-scoreB)>=2)
143         elif (scoreA == 10 and scoreB > 11) or (scoreB == 10 and scoreA > 11):
144             return (abs(scoreA-scoreB)>=2)
145         else:
146             return 0
147     
148 def print_MENU():
149     print("程序简介：模拟乒乓球竞技")
150     print("程序功能：
	1. 模拟多队员进行单打比赛
	2. 模拟多队伍多队员进行双打比赛")
151     while 1:
152         choose = input("功能选择：NO.")
153         if choose in ['1', '2']:
154             return eval(choose)
155         else:
156             print("输入有误, 请重新输入!")
157     
158 def simGameMenu():
159     choose = print_MENU()
160     if choose == 1:
161         pingpong = SportCompetitionAnalyze()
162         pingpong.PrintInfo()
163         pingpong.GetInputs_for_Singal()
164         Time = time()
165         pingpong.simNGames(7, 4)
166         print("模拟用时: {:.1f}s".format(time()-Time))
167         pingpong.PrintResult()
168     else:
169         pingpong = SportCompetitionAnalyze()
170         pingpong.PrintInfo()
171         pingpong.GetInputs_for_Double()
172         Time = time()
173         pingpong.simNGames(5, 3)
174         print("模拟用时: {:.1f}s".format(time()-Time))
175         pingpong.PrintResult()
176 
177 if __name__ == "__main__":
178     simGameMenu()

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

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

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

① 首先要安装pyinstaller库

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

pip install pyinstaller

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

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

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

查看全文

相关阅读:
第四次作业
 软工第三次作业
 第三次作业
 第二次作业
 团队第三次作业：Alpha版本发布
 软件工程团队作业--Alpha版本第二周小结
 软件工程团队作业--Alpha版本第一周小结
 团队第二次作业
 C++多态性总结
 第四次作业：结对编程

原文地址：https://www.cnblogs.com/alinger/p/10934167.html