每季度按比赛次数生成NBA比赛

Question

我试着每季度都能得到NBA的每场比赛.

我是如何做到这一点的:一支球队会在四分之一的时间里得到多少分，然后创造出满足这些分数的战术。

所以，假设我选择了A队，在四分之一的时间里得到5分。我创建了一个生成示例列表的算法：

[“2指针”、“开关”、“漏2分”、“进攻性反弹”、“停留”、“3分”、“切换”]

(这个列表比实际生成的要简单得多。除了抢断和失误之外，我还增加了更多的助攻和篮板。

“switch”的意思是交换财产，而“留下”则意味着当前的球队保持持有权。每个“切换”都需要在另一个团队的列表中至少有一个操作可用，而每个“停留”都需要在当前团队的列表中至少有一个操作可用。

现在，当我为两个不同的团队创建两个列表时，他们的列表可能会有不同的长度，因为其中一个队的得分可能会高于其他队。

当我试图将两个列表结合起来创建逐局模拟时，这可能会导致一个团队在另一个团队出现“开关”时没有动作。

我的问题是如何在任何团队列表中添加额外的“切换”或“停留”，以便每个“切换”都在另一支球队的列表中有一个动作，而每一个“停留”都会在当前团队的列表中有一个动作。

我的第一个想法是在列表中添加随机的失误和抢断(结果是“切换”)，并希望它能起作用，但我想不出有什么方法可以做到。

而且，只要名单符合所需的得分点数，初始球队名单的顺序就无关紧要了。

到目前为止，这就是我所拥有的：

def join_steals_tov(teamA_list，teamB_list)：

overall_list = []

possession = 'Team A'

print(len(teamA_list))
print(len(teamB_list))

while teamA_list and teamB_list:
    
    if possession == 'Team A':
        play = teamA_list.pop(0)
        play.insert(0,'Team A')
        overall_list.append(play)
        print(f"Team A: {play}")
        
        if play[-1] == 'SWITCH':
            possession = 'Team B'
    else:
        play = teamB_list.pop(0)
        play.insert(0,'Team B')
        overall_list.append(play)
        print(f"Team B: {play}")
        
        if play[-1] == 'SWITCH':
            possession = 'Team A'
    
return teamA_list, teamB_list, overall_list

Answer 1

这里有一种可能的方法来生成一个四分之一的逐局列表，从两个得分事件的列表开始。

teamA_scores = ['A2', 'A3']          
teamB_scores = ['B3', 'B3', 'B2']

步骤1:将列表合并成一个列表，并对合并的列表进行洗牌。

scores: ['A3', 'B3', 'A2', 'B3', 'B2']
          ^^ --- team A scores 3 points

第二步:当同一支球队连续两次得分时，另一支球队必须有一个不得分的事件。因此，创建一个新的播放列表，其中包括那些强制切换播放。

switch: ['A3', 'B3', 'A2', 'B3', 'AS', 'B2']
                                  ^^ --- team A gives the ball back to team B without scoring

第三步:在列表中添加一个季度末的播放(只是为了使下一步更容易)。

end Q:  ['A3', 'B3', 'A2', 'B3', 'AS', 'B2', 'AQ']
                                              ^^ --- time runs out with team A in possession

第四步:现在添加一些额外的非得分的发挥，以填写本季度。在示例代码中，播放列表被填充到任意长度的10。为了真实起见，您需要为每个剧本分配一段时间，然后填充列表，直到总时间为12分钟。

plays:  ['AK', 'A3', 'B3', 'AS', 'BS', 'A2', 'B3', 'AS', 'B2', 'AQ']
          ^^ --- team A keeps the ball, e.g. missed shot, offensive rebound
                            ^^ --- team A loses the ball
                                  ^^ --- team B loses the ball

下面是一些示例代码，它展示了如何将所有操作组合在一起，从两个得分游戏列表中创建10个播放列表：

from random import shuffle
from random import randrange
from random import randint

# helper functions
def getTeam(event):
    return event[0]

def makeSameTeamItem(event, item):
    if getTeam(event) == 'A':
        return 'A' + item
    else:
        return 'B' + item

def makeOtherTeamItem(event, item):
    if getTeam(event) == 'B':
        return 'A' + item
    else:
        return 'B' + item

# start with a list of scores for each team
teamA_scores = ['A2', 'A3']
teamB_scores = ['B3', 'B3', 'B2']

# step 1: combine and shuffle to create an overall list of scores
scores = teamA_scores + teamB_scores
shuffle(scores)
print 'scores:', scores

# step 2: create list of plays including mandatory SWITCH plays
plays = []
plays.append(scores[0])
for i in range(1, len(scores)):
   if getTeam(scores[i]) == getTeam(scores[i-1]):
      plays.append(makeOtherTeamItem(scores[i], 'S'))
   plays.append(scores[i])
print 'switch:', plays

# step 3: add the end of quarter play
plays.append(makeOtherTeamItem(scores[-1], 'Q'))
print 'end Q: ', plays

# step 4: insert additional non-scoring plays to fill the quarter
quarter = 10
while len(plays) < quarter:
   index = randrange(0, len(plays))
   if quarter - len(plays) == 1 or randint(1,2) == 1:
      plays.insert(index, makeSameTeamItem(plays[index], 'K'))
   else:
      plays.insert(index, makeOtherTeamItem(plays[index], 'S'))
      plays.insert(index, makeOtherTeamItem(plays[index], 'S'))
print 'plays: ', plays

Answer 2

我认为这是玩马尔可夫链的好方法。看一看这里

基本思想是，对于每个当前国家，都有进入下一个国家的可能性。您可以创建当前状态的概率矩阵，以及下一个状态的概率矩阵。然后使用这些权重从random.choices中拉出。你可以让它变得你想要的那么复杂。关键是从简单开始，让它开始工作，然后你可以添加更多并修饰它(例如，我打算添加3分漏失和3分的状态，(你还必须包括2分漏掉的概率，2分made...or，你可以把它作为投篮漏球和投篮的扩展)，但我想我会把它留给你去处理并加进去。你也可以加上进攻和防守犯规，如果是防守犯规，投篮的概率有助攻，等等)

这只是一个问题，建立一些功能，以保持所有的跟踪和“发挥”的控球。

下面是我的例子：

1.为每个团队创建概率矩阵。索引将是Curent State，列是下一个状态。

注:您希望每一行的和为1

import pandas as pd
import random

prob_matrix_A = pd.DataFrame([
[0, 0.05,   0.1,    0.375,  0.475,  0,  0,  0],
[0, 0,  0,  0,  0,  0,  0,  1],
[0, 0,  0,  0,  0,  0,  0,  1],
[0, 0.02,   0,  0,  0,  0.19,   0.79,   0],
[0, 0,  0,  0,  0,  0,  0,  1],
[1, 0,  0,  0,  0,  0,  0,  0],
[0, 0,  0,  0,  0,  0,  0,  1],
[0, 0, 0, 0, 0, 0, 0, 0]],
columns = ['Possession', 'Unforced Turnover','Steal','Miss Shot','Made Shot','Off Reb','Def Rebound', 'Change Possession'],
index = ['Possession', 'Unforced Turnover','Steal','Miss Shot','Made Shot','Off Reb','Def Rebound', 'Change Possession'])


prob_matrix_B = pd.DataFrame([
[0, 0.05,   0.1,    0.475,  0.375,  0,  0,  0],
[0, 0,  0,  0,  0,  0,  0,  1],
[0, 0,  0,  0,  0,  0,  0,  1],
[0, 0.02,   0,  0,  0,  0.09,   0.89,   0],
[0, 0,  0,  0,  0,  0,  0,  1],
[1, 0,  0,  0,  0,  0,  0,  0],
[0, 0,  0,  0,  0,  0,  0,  1],
[0, 0, 0, 0, 0, 0, 0, 0]],
columns = ['Possession', 'Unforced Turnover','Steal','Miss Shot','Made Shot','Off Reb','Def Rebound', 'Change Possession'],
index = ['Possession', 'Unforced Turnover','Steal','Miss Shot','Made Shot','Off Reb','Def Rebound', 'Change Possession'])

这是A组的概率矩阵：

print (prob_matrix_A.to_string())
                   Possession  Unforced Turnover  Steal  Miss Shot  Made Shot  Off Reb  Def Rebound  Change Possession
Possession                  0               0.05    0.1      0.375      0.475     0.00         0.00                  0
Unforced Turnover           0               0.00    0.0      0.000      0.000     0.00         0.00                  1
Steal                       0               0.00    0.0      0.000      0.000     0.00         0.00                  1
Miss Shot                   0               0.02    0.0      0.000      0.000     0.19         0.79                  0
Made Shot                   0               0.00    0.0      0.000      0.000     0.00         0.00                  1
Off Reb                     1               0.00    0.0      0.000      0.000     0.00         0.00                  0
Def Rebound                 0               0.00    0.0      0.000      0.000     0.00         0.00                  1
Change Possession           0               0.00    0.0      0.000      0.000     0.00         0.00                  0

2.设置如何跟踪得分和哪个队有球：

team_score_limit = 25


# game setup
game_dict = {'team_a':{'score':0, 'possession':False, 'prob_matrix': prob_matrix_A},
             'team_b':{'score':0, 'possession':False, 'prob_matrix': prob_matrix_B},
             'score_limit':team_score_limit}

# Do a jump ball to see who starts with ball
# Lets say team_a has 55% of getting the jump, and team_b 45%
wins_jump = random.choices(['team_a','team_b'], weights=[.55,.45], k=1)[0]
game_dict[wins_jump]['possession'] = True
print('%s: Wins the jump ball' %wins_jump)

3.创建函数以确定谁拥有(即。谁在进攻，谁防守)：

# Function to return who has possession
def possession(game_dict):
    for k, v in game_dict.items():
        if type(v) == dict:
            if v['possession'] == True:
                offense_team = k
            if v['possession'] == False:
                defense_team = k
    return offense_team, defense_team

4.创建基于概率：的函数来显示拥有权

def play(current_state, game_dict):
    # Determine who has possession and get their prob matrix
    offense, defense = possession(game_dict)
    prob_matrix = game_dict[offense]['prob_matrix']
    states_list = prob_matrix.columns.tolist()
    weights = prob_matrix.loc[current_state,:].tolist()
    
    # Based on current state weights, get the next state
    new_state = random.choices(states_list, weights=weights, k=1)[0]
    
    if 'Possession' not in new_state:
        if new_state in ['Def Rebound', 'Steal']:
            print ('%s: %s by %s' %(offense, new_state, defense))
        else:
            print ('%s: %s' %(offense, new_state))
    current_state = new_state
    

    if current_state == 'Made Shot':
        game_dict[offense]['score'] += 2
        
        # if team_a score reached the limit, we'll return False to stop the game
        if game_dict['team_a']['score'] >= game_dict['score_limit']:
            return False
 
    # if it's a change of possession, we'll update our game_dict
    if new_state == 'Change Possession':
        game_dict[offense]['possession'] = False
        game_dict[defense]['possession'] = True
    
    # else the team who currently possess the ball didn't change from the previous outcome (Ie. Offensive rebound), then they get another possession play 
    else:
        play(current_state, game_dict)

current_state 5.将初始的设置为启动“游戏”并播放它：

# Play the first quarter 
current_state = 'Possession'   
continue_play = True   
while continue_play != False:    
    continue_play = play(current_state, game_dict)    
    
    
    
print ('\nEnd of 1st Quarter!\n')
print ('**************************')
print ('team_a: %s\tteam_b: %s' %(game_dict['team_a']['score'],game_dict['team_b']['score']))

输出：

runfile('test.py', wdir='C:/test')
team_a: Wins the jump ball
team_a: Made Shot
team_b: Miss Shot
team_b: Off Reb
team_b: Made Shot
team_a: Made Shot
team_b: Made Shot
team_a: Miss Shot
team_a: Def Rebound by team_b
team_b: Miss Shot
team_b: Def Rebound by team_a
team_a: Steal by team_b
team_b: Miss Shot
team_b: Def Rebound by team_a
team_a: Miss Shot
team_a: Def Rebound by team_b
team_b: Made Shot
team_a: Miss Shot
team_a: Def Rebound by team_b
team_b: Steal by team_a
team_a: Made Shot
team_b: Made Shot
team_a: Made Shot
team_b: Made Shot
team_a: Made Shot
team_b: Steal by team_a
team_a: Made Shot
team_b: Miss Shot
team_b: Def Rebound by team_a
team_a: Unforced Turnover
team_b: Made Shot
team_a: Steal by team_b
team_b: Made Shot
team_a: Unforced Turnover
team_b: Steal by team_a
team_a: Made Shot
team_b: Unforced Turnover
team_a: Miss Shot
team_a: Off Reb
team_a: Made Shot
team_b: Miss Shot
team_b: Def Rebound by team_a
team_a: Made Shot
team_b: Miss Shot
team_b: Def Rebound by team_a
team_a: Made Shot
team_b: Made Shot
team_a: Made Shot
team_b: Miss Shot
team_b: Def Rebound by team_a
team_a: Miss Shot
team_a: Off Reb
team_a: Made Shot
team_b: Miss Shot
team_b: Def Rebound by team_a
team_a: Made Shot

End of 1st Quarter!

**************************
team_a: 26      team_b: 16