The Approach<\/h2>\n\n\n\n
Clearly, such a complex project couldn’t be coded in a simple script. I would need to really embrace OOP<\/a>(Object-Oriented Programming) for this. I decided to create 4 main classes: the Player<\/strong>, Team<\/strong>, Game<\/strong>, and GUI<\/strong>. <\/p>\n\n\n\n Finally, the main loop will read the data for each player, and then start the GUI. <\/p>\n\n\n\n I had a lot of really fine-grained data at my disposal. Namely, the shooting percentages, number of shot attempts, and number of made shots from 5 different zones on the court. To begin, I created a Player class, and put this data in the constructor:<\/p>\n\n\n Here, I added all the data available for each player into the constructor. Now, I needed to make all this data attributes of the Player class, so they can be used later. <\/p>\n\n\n The In order to simplify the rest of the code, I decided to make a player do two very simple things. Shoot a two-pointer, or shoot a three-pointer. Thus, I need to combine all these fine-grained data points into the attempts, made shots, and percentage for two-pointers and three-pointers. <\/p>\n\n\n Above, I calculated the total 2-point attempts and 3-point attempts by adding up the attempts from each zone which it belongs to. <\/p>\n\n\n Now, I calculated the 2-point and 3-point shooting percentages by dividing the amount of shots made by the amount of shots attempted in each zone. If no shots were attempted by a player in a certain zone (this usually happens with three-pointers), the shooting percentage automatically equals zero. <\/p>\n\n\n Here, I’ve initialized the attributes which will be updated, and then reset during and after every simulated <\/strong>game. (M refers to shots made, and A refers to shots attempted. So Here I calculated the total amount of shots a player takes per game. This will be useful down the line when we have to allocate shot attempts to different players. <\/p>\n\n\n There’s a lot to unpack here. Let’s start on the outside, and go in. <\/p>\n\n\n\n random.choices<\/a>, according to the documentation, “Return(s) a k<\/em> sized list of elements chosen from the population<\/em> with replacement. If the population<\/em> is empty, raises What is being chosen here. Either a 1 or a 0, which we can see in the list What’s actually happening here? <\/em>300 shot attempts, from both 2-point and 3-point zones, have been simulated. Why 300? Realistically, no one player is going to shoot more than 30-40 times in a game. Normally, both teams <\/em>combine for around 200 shot attempts. These simulated shot attempts will be used later, when the game is being “played”.<\/p>\n\n\n These are some helpful functions that act as getters <\/em>and setters<\/em>. In object-oriented programming, you don’t want a class to expose its attributes. Instead, it’s a good idea to write functions which encapsulate this action. The function The functions Compared to the Player, which had a lot of complex logic and arguments being passed into it, there isn’t much going on in a Team. It’s just wrapper functions for managing players, and keeping track of its score. <\/p>\n\n\n First, I created the Team class, and passed the team name, percentage of shots that are 2-pointers percentage of shots that are three-pointers, and possessions per game in the constructor. (Note: the variables pct2PA and pct3PA are not actually being used. They are for future expansion). <\/p>\n\n\n\n In the constructor the name is passed in and becomes an attribute, as well as the 2-pointer and 3-pointer shooting splits. An empty list is also initialized, which will store the team’s players. <\/p>\n\n\n This is the rest of the Team class. <\/p>\n\n\n\n A Game takes in 2 Team objects in a list, a list of all player objects that can exist<\/em>, and the number of possessions(every time a team gets the ball and attempts to score) as parameters. In the constructor, each team is assigned to team1 or team2, and each team’s score is also set to zero.<\/p>\n\n\n\n Furthermore, the list of all players, and the number of possessions are both made into attributes of the Game. An empty list named The first function in Game is Now that we have our teams, we can dole out shot attempts to all the players who are playing. The dictionary playerFGAs stores a player’s name as the key and that player’s average shot attempts as the value. It will be used for determining how many shot attempts each player should get, relative to one another. Furthermore, totalFGA is used to count the number of shot attempts that would happen, if you merely added up the attempts for each player. The for-loops iterate over each team’s players to find these values. <\/p>\n\n\n Now that we know the theoretical number of shot attempts, we can normalize this to the number of shot attempts we want the game to actually have. <\/p>\n\n\n\n Basically, if you had a team of five Michael Jordans, in a vacuum they would take far too many shots for a normal game. In this case, the normFactor would be between 0 and 1 because each Michael Jordan has to take less shots. On the other hand, if you had a team of five benchwarmers, who do not get a lot of playing time, the normalization factor for their shot attempts would be greater than 1, since they would normally not take enough shots. <\/p>\n\n\n\n This is a phenomenon found a lot in real NBA basketball. It’s fairly common to see a team’s #2 option step up their game in the absence of their team’s alpha player.<\/p>\n\n\n Now that we have calculated the normalization factor for shot attempts, we first complete the normalization of the shot attempts in the first for-loop. <\/p>\n\n\n\n In the second section, the outer for-loop iterates through the name of each player playing in the game. The inner for-loop appends a player’s name the amount of times they are supposed to have the ball. For example, let’s just say there are 2 players right now, LeBron James and James Harden. The playerFGAs dictionary reads:<\/p>\n\n\n Now, allAttempts, which is basically of who would shoot on each possession, looks like this:<\/p>\n\n\n According to this, LeBron would take the first three shots, and James Harden would take the last four. But that’s clearly not how it usually works. In order to make this more realistic, we need to shuffle the list:<\/p>\n\n\n Wait a minute! This isn’t shuffling! It’s sampling! But, with a closer look, you can see that the sample is the same size as the original list. Thus, this random sample is basically the same thing as shuffling: It randomly picks players until there are none left.<\/p>\n\n\n\n There’s one more edge case we have to consider, though: What if the number of possessions in the game is longer than the fgaOrder we have already determined? <\/p>\n\n\n Here we loop the number of times that fgaOrder has to be appended to. Since a for-loop stops 1 before the end of the range we need to add 1. Then, we add a random player to the end of The function Next, we move on to the real essence of the Game, which is the logic for playing a turn(also referred to as a possession here, and in basketball lingo):<\/p>\n\n\n The first thing that we do in Now, we first need to figure out which player has the ball. Thus, we first look up the list The string turnoutcome is the message the user will see in the GUI. By default, we assume that the player with the ball does not score. However, if the player does make a basket this string will be updated. <\/p>\n\n\n Here, the player is randomly either going to shoot a 3-pointer or a 2-pointer. Right now, there is a 50\/50 chance of getting either, which is reasonably close to how the NBA really operates, however, this can be changed to be a weighted choice. <\/p>\n\n\n Now, this section essentially is simulating the process of shooting a 3-pointer. <\/strong>First, the variable “make”, which is boolean, determines whether the player makes the shot or not. Remember, the function shoot3pt() uses the precomputed list The exact same process is repeated if the player with the ball shoots a 2-pointer. (You may have noticed we crossed 500 lines of code in this code snippet. That’s because the line numbers include comments, old code, and whitespace. In reality there are 498 lines of actually functioning code).<\/p>\n\n\n Finally, at the end of To wrap up the Game class, we have some getter functions that will be used in conjunction with the GUI class. <\/p>\n\n\n Finally, both of these setter functions deletes a Finally, we have We can see that each column header is a certain type of value, such as age, Paint_FGA, or name. We want to get this data into a bunch of Player objects, so each row will correspond with a Player. Now that we have figured out what to do, let’s see how it’s done. <\/p>\n\n\n First, we define the main function, and then define two lists: First, we open a file reader object, named as rawData. Then we create a csv DictReader object which will allow us to easily parse the file, without having to write a lot of complex parsing and logic code. Then, it’s as simple as iterating over every row(remember, that’s every player) in the CSV file. If there is a dash in the row, indicating a blank value, that player is skipped with the Next, we create a Finally, we write the parameters for the teams and game. Try editing the code so that you can change the team name in the GUI! <\/p>\n\n\n Finally, we initialize each team, the game, and the GUI. The You may have noticed that I haven’t covered the GUI class yet. That’s because a GUI is quite subjective with how the creator wants it to look like. I have actually written this both in Java and Python, and in both, the GUIs are extremely different. <\/p>\n\n\n\n As you can see, even though both of these GUIs accomplish the exact same functions, their visual layout is completely different. There are many design decisions that had to be made in order to deal with the constrains that both Java and Python GUIs allow. <\/p>\n\n\n\n You can find the full code for the Python basketball simulator(Manav’s Basketball Association, or the MBA) on GitHub here<\/a>. This repo also contains the code for the Web detective which pulls the data. <\/p>\n\n\n\n The Java version<\/a> contains some extra features such as a year selector. In this repo I’ve prepared data CSV files going from the 2011-12 season to the 2020-21 season. There are also executable JAR files under Releases<\/a> so you can try it out without compiling. Credit to Dev Kodre<\/a> for building the GUI for this project. <\/p>\n\n\n\n Thanks for reading! If you have any questions, don’t hesitate to put them in the comments!<\/strong><\/p>\n\n\n\n Introduction Basketball is one of my primary interests. I’ve always been attracted to not only the highlight plays, but also the wealth of interesting statistical tidbits out there. Sites like FiveThirtyEight and others do a great job of digging up advanced stats to prove a point. After creating a program to automatically pull NBA stats […]<\/p>\n","protected":false},"author":1,"featured_media":233,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[14,12,13],"tags":[15,16,17,18],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/archive.gagvani.com\/index.php\/wp-json\/wp\/v2\/posts\/141"}],"collection":[{"href":"https:\/\/archive.gagvani.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/archive.gagvani.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/archive.gagvani.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/archive.gagvani.com\/index.php\/wp-json\/wp\/v2\/comments?post=141"}],"version-history":[{"count":30,"href":"https:\/\/archive.gagvani.com\/index.php\/wp-json\/wp\/v2\/posts\/141\/revisions"}],"predecessor-version":[{"id":197,"href":"https:\/\/archive.gagvani.com\/index.php\/wp-json\/wp\/v2\/posts\/141\/revisions\/197"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/archive.gagvani.com\/index.php\/wp-json\/wp\/v2\/media\/233"}],"wp:attachment":[{"href":"https:\/\/archive.gagvani.com\/index.php\/wp-json\/wp\/v2\/media?parent=141"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/archive.gagvani.com\/index.php\/wp-json\/wp\/v2\/categories?post=141"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/archive.gagvani.com\/index.php\/wp-json\/wp\/v2\/tags?post=141"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}Coding the Player<\/strong><\/h2>\n\n\n\n
![\"\"](\"https:\/\/static01.nyt.com\/images\/2020\/01\/13\/sports\/13nba-kyrieWEB1\/merlin_167052225_82cee84c-d59e-45f2-80c6-2b7cbaaa6461-superJumbo.jpg\")
<\/figure>\n\n\n\n\n#Class defining the parameters of the player\nclass Player:\n def __init__(self, name,RestrictArea_FGpercent,Paint_FGpercent,MidRange_FGpercent,LeftCorner3_FGpercent,RightCorner3_FGpercent,AboveBreak3_FGpercent,\\\n RestrictArea_FGA,Paint_FGA,MidRange_FGA,LeftCorner3_FGA,RightCorner3_FGA,Totals_FGA,AboveBreak3_FGA,\\\n RestrictArea_FGM,Paint_FGM,MidRange_FGM,LeftCorner3_FGM,RightCorner3_FGM,AboveBreak3_FGM,Totals_FGM):\n<\/pre><\/div>\n\n\n
\n self.name = name.strip() # Remove any whitespace\n self.RestrictArea_FGpercent = float(RestrictArea_FGpercent)\n self.Paint_FGpercent = float(Paint_FGpercent)\n self.MidRange_FGpercent = float(MidRange_FGpercent)\n self.LeftCorner3_FGpercent = float(LeftCorner3_FGpercent)\n self.RightCorner3_FGpercent = float(RightCorner3_FGpercent)\n self.AboveBreak3_FGpercent = float(AboveBreak3_FGpercent)\n\n self.RestrictArea_FGA = float(RestrictArea_FGA)\n self.Paint_FGA = float(Paint_FGA)\n self.MidRange_FGA = float(MidRange_FGA)\n self.LeftCorner3_FGA = float(LeftCorner3_FGA)\n self.RightCorner3_FGA = float(RightCorner3_FGA)\n self.Totals_FGA = float(Totals_FGA)\n self.AboveBreak3_FGA = float(AboveBreak3_FGA)\n\n self.RestrictArea_FGM = float(RestrictArea_FGM)\n self.Paint_FGM = float(Paint_FGM)\n self.MidRange_FGM = float(MidRange_FGM)\n self.LeftCorner3_FGM = float(LeftCorner3_FGM)\n self.RightCorner3_FGM = float(RightCorner3_FGM)\n self.AboveBreak3_FGM = float(AboveBreak3_FGM)\n self.Totals_FGM = float(Totals_FGM) \n<\/pre><\/div>\n\n\n
self.<\/code> in each of these lines is saying that each of these attributes is an attribute of an instance <\/em>of that class, rather than the class in general. This allows each Player to have different shooting percentages. The reason why each parameter has to be converted into a float is because they are read as strings, but Python can’t do math on those. <\/p>\n\n\n\n\n self.total2PA=self.RestrictArea_FGA+self.Paint_FGA+self.MidRange_FGA\n self.total3PA=self.LeftCorner3_FGA+self.RightCorner3_FGA+self.AboveBreak3_FGA\n<\/pre><\/div>\n\n\n
\n if self.total2PA == 0: # prevent division by zero\n self.TwoPTpercent=0\n else:\n self.TwoPTpercent = (self.RestrictArea_FGM+self.Paint_FGM+self.MidRange_FGM)\/(self.total2PA)\n if self.total3PA == 0:\n self.ThreePTpercent=0\n else: \n self.ThreePTpercent = (self.LeftCorner3_FGM+self.RightCorner3_FGM+self.AboveBreak3_FGM)\/(self.total3PA)\n\n<\/pre><\/div>\n\n\n
\n self.pointsScored = 0\n self.twoPTM = 0\n self.twoPTA = 0\n self.threePTM = 0\n self.threePTA = 0\n<\/pre><\/div>\n\n\n
self.threePTM<\/code>, for example, is referring to the amount of three pointers the player made during a simulated game.)<\/p>\n\n\n\n self.fga=self.RestrictArea_FGA+self.Paint_FGA+self.MidRange_FGA+self.LeftCorner3_FGA+self.RightCorner3_FGA+self.AboveBreak3_FGA\n<\/pre><\/div>\n\n\n
\n self.lotsOfShots2=random.choices([1,0],weights=[self.TwoPTpercent,1-self.TwoPTpercent],k=300)\n self.lotsOfShots3=random.choices([1,0],weights=[self.ThreePTpercent,1-self.ThreePTpercent],k=300)\n<\/pre><\/div>\n\n\n
IndexError<\/code><\/a>.” Essentially, it’s choosing something from a list with certain weights k <\/em>times. <\/p>\n\n\n\n[1,0]<\/code>. A 1 corresponds with a made shot, and a 0 is a missed shot. Now, what would the weights for a made or missed shot be? Clearly, they should be the player’s shooting percentages, which they are. The weight for a 1, or made shot is equal to the 2 or 3-point percentage, while the probability of missing is 1 minus that(a simple probability rule). <\/p>\n\n\n\n\n def reset_score(self):\n self.pointsScored=0\n\n def get_score(self):\n return self.pointsScored\n\n def get_splits(self):\n return(self.twoPTM,self.twoPTA,self.threePTM,self.threePTA)\n\n def reset_splits(self):\n self.twoPTM = 0\n self.twoPTA = 0\n self.threePTM = 0\n self.threePTA = 0\n<\/pre><\/div>\n\n\n
reset_score()<\/code> changes the Player’s pointsScored<\/code> attribute back to zero. get_score()<\/code> returns the attribute pointsScored<\/code>. In Python, it’s not possible to declare a variable private, but in another language it should be private. The functions get_splits() and reset_splits() are a getter and setter for the player’s simulated game stats. <\/p>\n\n\n\n def shoot2pt(self,turn):\n if self.lotsOfShots2[turn] == 1: #Selecting one shot out of the lots of shots\n return True #Make shot\n else:\n return False\n def shoot3pt(self,turn):\n if self.lotsOfShots3[turn] == 1: #Selecting one shot out of the lots of shots\n return True #Make shot\n else:\n return False\n<\/pre><\/div>\n\n\n
shoot2pt() <\/code>and shoot3pt()<\/code> are essentially wrapping the data that is stored in lotsOfShots2 <\/code>and lotsOfShots3<\/code>. They take the current turn(possession number, in basketball terms) and figure out whether the player would have made the shot(1, so return True<\/code>), or not made the shot(0, so return False<\/code>). Since we don’t want the actual game simulation to access the lotsOfShots <\/code>attributes directly, this function is needed to act as a getter function.<\/p>\n\n\n\nCoding the Team<\/h2>\n\n\n\n
![\"\"](\"https:\/\/nothinbutnets.com\/wp-content\/uploads\/getty-images\/2021\/02\/1297525742.jpeg\")
<\/figure>\n\n\n\n\nclass Team:\n def __init__(self,name,pct2PA,pct3PA): #team name, %of shots 2pt, %of shots 3pt, possessions per game\n self.name = name\n self.players = []\n self.pct2PA = pct2PA\n self.pct3PA = pct3PA\n<\/pre><\/div>\n\n\n
\n def addPlayer(self,player):\n self.players.append(player) #should be a player object\n def reset_scores(self):\n for player in self.players:\n player.reset_score()\n def get_scores(self):\n scores = []\n for player in self.players:\n scores.append(player.get_score())\n return scores\n def get_shooting_splits(self):\n splits = []\n for player in self.players:\n splits.append(player.get_splits())\n return splits\n def reset_splits(self):\n for player in self.players:\n player.reset_splits()\n<\/pre><\/div>\n\n\n
addPlayer()<\/code> takes a Player object and appends it to the list of players which the Team stores.<\/li>reset_scores()<\/code> and get_scores()<\/code> are very representative of Object-Oriented structure. Instead of the Game or GUI class calling methods of Player, they instead call a function from the class right under it. So, the Game calls function from Team, and the Team calls functions from Player. <\/li>Creating the Game logic<\/h2>\n\n\n\n
![\"picture](\"https:\/\/www.ctvnews.ca\/polopoly_fs\/1.5052524.1596660348!\/httpImage\/image.jpg_gen\/derivatives\/landscape_1020\/image.jpg\")
<\/figure>\n\n\n\n#game logic\nclass Game:\n def __init__(self,teams,players,numPossessions): #players is the list of ALL PLAYER OBJECTS. \n self.team1=teams[0]\n self.team2=teams[1]\n self.teams=teams\n \n self.team1Score=0\n self.team2Score=0\n\n self.players=players\n self.numPossessions=numPossessions\n self.turnsPlayed=0\n\n self.fgaOrder=[]\n\n<\/pre><\/div>\n\n\n
fgaOrder <\/code>is also initialized. What is it? It will be used to determine which player<\/strong> will shoot the ball<\/strong> on each turn<\/strong>.<\/p>\n\n\n\n def add_players_to_teams(self,team1players,team2players):\n\n for playerName in team1players:\n for playerObj in self.players:\n if playerObj.name == playerName:\n self.team1.addPlayer(playerObj)\n break\n\n for playerName in team2players:\n for playerObj in self.players:\n if playerObj.name == playerName:\n self.team2.addPlayer(playerObj)\n break\n<\/pre><\/div>\n\n\n
add_players_to_teams()<\/code>. Of course, there can’t be a game without players on each team. This function takes two lists of player names<\/em> as parameters(not to be confused with Player objects). Then, in each of the for-loops, a list of all <\/em>Player objects is iterated through, and if there is a match between the given player name and the Player object, then that Player object is added to team1 or team2. (This does make it possible for there to be the same player on two teams. However, in this case the instance of the Player is the same in both lists so that player’s score counts for both teams.)<\/p>\n\n\n\n #Once teams are know figure out distribution of possessions for players\n playerFGAs={} # <name> : <fga>\n allAttempts=[]\n \n allPlayerNames=team1players+team2players\n totalFGA=0 #FOR BOTH TEAMS\n for playerName in allPlayerNames:\n for player in self.team1.players:\n if player.name == playerName:\n playerFGAs[player.name] = player.fga\n totalFGA+=player.fga\n\n for player in self.team2.players:\n if player.name == playerName:\n playerFGAs[player.name] = player.fga\n totalFGA+=player.fga\n<\/pre><\/div>\n\n\n\n normFactor=self.numPossessions\/totalFGA\n<\/pre><\/div>\n\n\n
\n for playerName in allPlayerNames:\n normFGA=int(round(normFactor*playerFGAs[playerName]))\n playerFGAs[playerName]=normFGA #filling out the dict: Now it is normalized\n\n for playerName in allPlayerNames:\n for attemptNumber in range(1,playerFGAs[playerName]):\n allAttempts.append(playerName) \n<\/pre><\/div>\n\n\n
\n{"LeBron James":3, "James Harden":4}\n<\/pre><\/div>\n\n\n\n["LeBron James", "LeBron James", "LeBron James", "James Harden", "James Harden", "James Harden", "James Harden"]\n<\/pre><\/div>\n\n\n
\n self.fgaOrder=random.sample(allAttempts,len(allAttempts))\n<\/pre><\/div>\n\n\n
\n # if numPossession is more than length of fgaOrder, add at the end\n for i in range(1 + self.numPossessions - len(self.fgaOrder)):\n randomPlayerName = random.choice(allPlayerNames)\n self.fgaOrder.append(randomPlayerName)\n<\/pre><\/div>\n\n\n
fgaOrder <\/code>until there are enough field goal attempts. <\/p>\n\n\n\n def init_game(self):\n self.team1Score=0\n self.team2Score=0\n self.turnsPlayed=0\n self.team1.reset_scores()\n self.team2.reset_scores()\n self.team1.reset_splits()\n self.team2.reset_splits()\n self.team1.players = []\n self.team2.players = []\n<\/pre><\/div>\n\n\n
init_game()<\/code> simply resets the scores and shooting numbers, and empties each teams’ players <\/code>list so it can be re-populated with 2 new sets of Players. <\/p>\n\n\n\n\n def play_turn(self):\n if self.turnsPlayed >= self.numPossessions:\n return False #ERROR\n<\/pre><\/div>\n\n\n
play_turn()<\/code> is check if we have already played enough turns. If we have, then there is no reason to continue and play_turn() <\/code>will return False<\/code>, signaling an error. <\/p>\n\n\n\n playerNameWithBall = self.fgaOrder[self.turnsPlayed]\n for player in self.team1.players + self.team2.players:\n if player.name == playerNameWithBall:\n playerWithBall = player\n break\n<\/pre><\/div>\n\n\n
fgaOrder <\/code>for the current turn, in order to find out the name of the player who is supposed to shoot. Then, we iterate over each player which is playing in the game. If the names match, we can set a variable, playerWithBall<\/code>, which is the corresponding Player object.<\/p>\n\n\n\n turnoutcome = f"{playerWithBall.name} did not score"\n<\/pre><\/div>\n\n\n\n position=random.choice(("3","2")) #Goes to 3pt line or 2pt\n<\/pre><\/div>\n\n\n\n if position == "3": #if they are going to shoot a 3\n make=playerWithBall.shoot3pt(self.turnsPlayed)\n if make == True: #true is make\n #print(f"{playerWithBall.name} made a 3")\n turnoutcome = f"{playerWithBall.name} made a 3"\n if playerWithBall in self.team1.players: \n self.team1Score +=3\n playerWithBall.pointsScored+=3\n playerWithBall.threePTM += 1\n playerWithBall.threePTA += 1\n playerWithBall=random.choice(self.team2.players) #Inbound ball to person on other team\n elif playerWithBall in self.team2.players:\n self.team2Score +=3\n playerWithBall.pointsScored+=3\n playerWithBall.threePTM += 1\n playerWithBall.threePTA += 1\n playerWithBall=random.choice(self.team1.players)\n else:\n #print("Apparently the ball went to the ref or something.")\n pass\n elif make == False: #Miss shot\n playerWithBall.threePTA += 1\n playerWithBall=random.choice(self.team1.players+self.team2.players)\n<\/pre><\/div>\n\n\nlotsOfShots <\/code>to find whether or not a player would make the shot on the given turn number. If the Player did make the shot, the turnoutcome string is updated to reflect that. Then, the appropriate team score, player score and shooting splits are updated. Then, since the player made a shot, the ball should be given to a player on the other team to inbound. However, if the player misses, then that player records a three point field goal attempt. The ball is rebounded by any player on the court. However, in practice, there is a higher chance that it will go to the defensive team. (See offensive and defensive rebounding % for advanced statistics on this). <\/p>\n\n\n\n if position == "2": #if they are going to shoot a 2\n make=playerWithBall.shoot2pt(self.turnsPlayed)\n if make == True: #true is make\n #print(f"{playerWithBall.name} made a 2")\n turnoutcome = f"{playerWithBall.name} made a 2"\n if playerWithBall in self.team1.players: \n self.team1Score +=2\n playerWithBall.pointsScored+=2\n playerWithBall.twoPTM += 1\n playerWithBall.twoPTA += 1\n playerWithBall=random.choice(self.team2.players)\n elif playerWithBall in self.team2.players:\n self.team2Score +=2\n playerWithBall.pointsScored+=2\n playerWithBall.twoPTM += 1\n playerWithBall.twoPTA += 1\n playerWithBall=random.choice(self.team1.players)\n else:\n #print("Apparently the ball went to the ref or something.")\n pass\n elif make == False:\n playerWithBall.twoPTA += 1\n playerWithBall=random.choice(self.team1.players+self.team2.players)\n<\/pre><\/div>\n\n\n\n self.turnsPlayed+=1 \n\n # print(self.team1Score,self.team2Score,turnoutcome)\n return [self.team1Score,self.team2Score,turnoutcome]\n<\/pre><\/div>\n\n\n
play_turn()<\/code>, we increment the amount of turns played by one, and return each team’s score along with the turn’s outcome. <\/p>\n\n\n\n def get_team1_scores(self):\n return self.team1.get_scores()\n\n def get_team2_scores(self):\n return self.team2.get_scores()\n\n def get_team1_splits(self):\n return self.team1.get_shooting_splits()\n\n def get_team2_splits(self):\n return self.team2.get_shooting_splits()\n<\/pre><\/div>\n\n\n
\n def del_from_team1(self,playerName):\n idx= 0\n for player in self.team1.players:\n if player.name == playerName:\n print("In Team 1 Delete for player " + playerName)\n del self.team1.players[idx]\n break\n idx+=1\n\n def del_from_team2(self,playerName):\n idx= 0\n for player in self.team2.players:\n if player.name == playerName:\n print("In Team2 Delete for player " + playerName)\n del self.team2.players[idx]\n break\n idx+=1\n<\/pre><\/div>\n\n\nPlayer <\/code>from a Team<\/code>, given a string which is the player’s name. It does this by iterating through the Players <\/code>until the one to be deleted is found. And that’s it! Our Game class is complete!<\/p>\n\n\n\n![\"Game](\"https:\/\/archive.gagvani.com\/wp-content\/uploads\/2021\/08\/unnamed-file-1024x683.jpg\")
<\/figure>\n\n\n\nThe main() function – It’s all about the data<\/h2>\n\n\n\n
main()<\/code>, the function Python actually calls when this code is run. As the heading says, a large part of this function is collecting the player’s data. As stated previously, I created a Python script that used Selenium to automatically find player’s data from stats.nba.com<\/a>. It produces a SQL database as well as a CSV data file. For simplicity, we will be working with the CSV. Here’s what it looks like (If it’s too small on your screen, view it using the download button):<\/p>\n\n\n\n![\"\"](\"https:\/\/archive.gagvani.com\/wp-content\/uploads\/2021\/08\/image-1024x335.png\")
<\/figure>\n\n\n\n\ndef main():\n \n #Getting REAL data\n players=[]#list of the objects of every NBA player\n playernames=[] #list of all player names FOR GUI\n<\/pre><\/div>\n\n\n
players <\/code>and playernames<\/kbd><\/code>. The former will be passed into a Game<\/code> object later, and the playernames<\/code> will be shown in the GUI, so the user can select players to join each team. <\/p>\n\n\n\n with open("players.csv") as rawData:\n csv_reader=csv.DictReader(rawData,delimiter = ",")\n line_count=0\n for row in csv_reader:\n #print(row["Name"])\n if "-" in row.values():\n continue\n playernames.append(row["Name"].strip())\n<\/pre><\/div>\n\n\ncontinue <\/code>operator. Then, the player’s name is appended to the playernames <\/code>list. .strip() <\/code>is a function which removes any extra whitespace in the front and back of a string. <\/p>\n\n\n\n p=Player(row["Name"],row["RestrictArea_FGpercent"],row["Paint_FGpercent"],row["MidRange_FGpercent"],\n row["LeftCorner3_FGpercent"],row["RightCorner3_FGpercent"],row["AboveBreak3_FGpercent"],\n row["RestrictArea_FGA"],row["Paint_FGA"],row["MidRange_FGA"],row["LeftCorner3_FGA"], \n row["RightCorner3_FGA"],row["Totals_FGA"],row["AboveBreak3_FGA"],row["RestrictArea_FGM"],\n row["Paint_FGM"],row["MidRange_FGM"],row["LeftCorner3_FGM"],row["RightCorner3_FGM"],\n row["AboveBreak3_FGM"],row["Totals_FGM"])\n players.append(p)\n<\/pre><\/div>\n\n\n
Player <\/code>object p<\/code>, and appended it to the list players<\/code>. Of course, all that parameters that a Player requires is passed into the constructor through the CSV file reader. <\/p>\n\n\n\n team1name="The Easy Breezies"\n team1_2pct2PA=0.5\n team1_2pct3PA=0.5\n\n team2name="The Jolly Follies"\n team2_2pct2PA=0.5\n team2_2pct3PA=0.5\n \n poss= 200\n<\/pre><\/div>\n\n\n
\n team1=Team(team1name,team1_2pct2PA,team1_2pct3PA)\n team2=Team(team2name,team2_2pct2PA,team2_2pct3PA) \n \n teams=[team1,team2]\n\n game=Game(teams,players,poss) #initialize a game\n\n #GUI\n gui=GUI(game)\n\n gui.add_players(playernames)\n gui.start_gui()# gui starts in end because it takes over \n \n\n\n\nif __name__ == "__main__":\n main()\n\n<\/pre><\/div>\n\n\n
if __name__ == \"__main__\"<\/code> section at the end allows us to know if the file is being run. Otherwise, the main()<\/code> function will not run, and this code would have to be imported as a library to be called in a separate program. <\/p>\n\n\n\nWrapping it up<\/h2>\n\n\n\n
![\"\"](\"https:\/\/archive.gagvani.com\/wp-content\/uploads\/2021\/08\/allstarsim.jpg\")
<\/figure><\/li>![\"\"](\"https:\/\/archive.gagvani.com\/wp-content\/uploads\/2021\/08\/mba.jpg\")
<\/figure><\/li><\/ul>![\"Damian](\"https:\/\/media1.giphy.com\/media\/VapWo1dvqJquP3frRb\/giphy.gif\")
<\/figure>\n","protected":false},"excerpt":{"rendered":"