def pull_data(self): data = playergamelog.PlayerGameLog(self.player, season=self.season) player_df = pd.DataFrame(data.get_normalized_dict()['PlayerGameLog']) player_df['GAME_DATE'] = pd.to_datetime(player_df['GAME_DATE']) player_df.sort_values(by='GAME_DATE', ascending=True, inplace=True) player_df.drop('VIDEO_AVAILABLE', axis=1, inplace=True) return player_df
def careerLog(cls, player): try: playerDetails = player.details() findGames = playergamelog.PlayerGameLog( player_id=playerDetails[ID], season=SeasonAll.all) careerLog = findGames.get_data_frames()[0] return careerLog except: return NA
def getGamesPlayed(lis, wkStart): gp = pd.DataFrame(columns=['PlayerID', 'GTBP']) for x in range(len(lis)): df = pgl.PlayerGameLog(lis[x]).get_data_frames()[0] df.GAME_DATE = pd.to_datetime(df.GAME_DATE) df = df[df.GAME_DATE >= wkStart + timedelta(dateAdvance)] gp = gp.append({'PlayerID': lis[x], 'GTBP': len(df)}, ignore_index=True) Time.sleep(delay) if x % 8 == 0: print(str(x) + ' seconds has passed') print() return gp
def get_games(request): if request.method == 'GET': id = request.GET['id'] year = request.GET['season'] type = request.GET['seasonType'] games = playergamelog.PlayerGameLog(player_id=id, season_all=year, season_type_all_star=type) games = games.get_normalized_json() return HttpResponse(games) # Sending a success response else: return HttpResponse("Request method is not a GET")
def show_graph(player_name): player_dict = players.get_players() player_df = [player for player in player_dict if player['full_name'] == player_name][0] player_id = player_df['id'] gamelog_player_all = playergamelog.PlayerGameLog(player_id=player_id, season = SeasonAll.all) gamelog_player_all_df = gamelog_player_all.get_data_frames()[0] fig, ax = plt.subplots() ax.scatter(gamelog_player_all_df['FG3A'], gamelog_player_all_df['FG3M'], c='blue', alpha=0.5) return fig
def get_gamelog_data(player_id): df = playergamelog.PlayerGameLog( player_id=player_id).get_data_frames()[0][[ 'GAME_DATE', stat, 'MATCHUP', 'WL', 'FG_PCT' ]] df = df.rename(columns={'WL': 'Win/Lose'}) df['size'] = df['FG_PCT'] * 10 df['date'] = pd.to_datetime(df['GAME_DATE']) df = df.sort_values(by=['date']) df['stat'] = stat df['avg'] = df[stat].ewm(com=0.9).mean() return df
def getStatsByPlayerAndGame(playerID, gameDate): time.sleep(1) games = playergamelog.PlayerGameLog(player_id=playerID) #it returns a list df = games.get_data_frames()[0] df['GAME_DATE'] = pd.to_datetime(df['GAME_DATE'], utc=True) #filter to just the correct date df = df.loc[df['GAME_DATE'] == gameDate] if (len(df) > 0): df['PR'] = df['PTS'] + df['REB'] df['PRA'] = df['PTS'] + df['REB'] + df['AST'] df['BS'] = df['BLK'] + df['STL'] df['PR'] = df['PTS'] + df['REB'] df['RA'] = df['REB'] + df['AST'] return df.squeeze()
def __get9CatStats(player_name, type, season): p_id = __getPlayerId(player_name) p_gamelog = playergamelog.PlayerGameLog(player_id=p_id, season=season) p_df = p_gamelog.get_data_frames()[0] if type == 'total': # this line extract all of the necessary counting stats from the sum p_9cat = p_df[['PTS', 'STL', 'AST', 'BLK', 'REB', 'TOV', 'FG3M']].sum() if type == 'average': # this line gets the average of all counting stats p_9cat = p_df[['PTS', 'STL', 'AST', 'BLK', 'REB', 'TOV', 'FG3M']].mean() # these lines get percentages p_9cat['FG%'] = (p_df['FGM'].sum()) / (p_df['FGA'].sum()) p_9cat['FT%'] = (p_df['FTM'].sum()) / (p_df['FTA'].sum()) p_9cat['GP'] = len(p_df) return p_9cat
def getLastTwoWeeksAveragePoints_nbaapi(playerObj): playerName = playerObj.name dateIndex = 1 #counter to keep track of how many days back we are going totalGamesPlayed = 0 totalFantasyPoints = 0 today = datetime.datetime.today().strftime('%m/%d/%Y') dateToPull = (datetime.datetime.now() - datetime.timedelta(14)).strftime('%m/%d/%Y') nba_player = players.find_players_by_full_name(playerName) playerId = None if len(nba_player) != 1: lastName = playerName[playerName.find(" ") + 1:] firstName = playerName[0:playerName.find(" ")] for tmp_player in nba_player: if tmp_player['first_name'] == firstName and tmp_player[ 'last_name'] == lastName: playerId = tmp_player['id'] if playerId == None: print "Unable to determine player id for {}".format(playerName) #TODO - instead of using the static nba api should do dynamic to get these players ID and get their return 0 else: playerId = nba_player[0]['id'] attempts = 0 while attempts < 5: try: gameLog = playergamelog.PlayerGameLog( playerId, date_from_nullable=dateToPull, date_to_nullable=today) except: print "nba api timed out, waiting 10 minutes then trying again. Attempt {} of 5".format( attempts) attempts += 1 time.sleep(600) if gameLog == None: raise Exception( "NBA API still not working after 5 attempts and waiting 10 minutes, bailing" ) gameLogDf = gameLog.get_data_frames()[0] totalFantasyPoints = getFantasyPointsFromDF(gameLogDf) if len(gameLogDf) == 0: print "{} played 0 games!".format(playerName) return 0 return totalFantasyPoints / len(gameLogDf)
def pts_of_player(player_id): pts = 0 player_log = playergamelog.PlayerGameLog( player_id).get_normalized_dict()["PlayerGameLog"] player_log_by_date = [ stat for stat in player_log if datetime.datetime.strptime(stat["GAME_DATE"], "%b %d, %Y") < date_time ] pts += np.sum([stat["AST"] for stat in player_log_by_date]) pts += np.sum([stat["REB"] for stat in player_log_by_date]) pts += np.sum([stat["PTS"] for stat in player_log_by_date]) pts += np.sum([stat["BLK"] for stat in player_log_by_date]) pts += np.sum([stat["STL"] for stat in player_log_by_date]) pts += np.sum([stat["PTS"] for stat in player_log_by_date]) / np.sum( [stat["MIN"] for stat in player_log_by_date]) return pts / 100
def get_player_stats_detail(player_name): player_dict = players.get_players() player_df = [player for player in player_dict if player['full_name'] == player_name][0] player_id = player_df['id'] gamelog_player_all = playergamelog.PlayerGameLog(player_id=player_id, season = SeasonAll.all) gamelog_player_all_df = gamelog_player_all.get_data_frames()[0] gamelog_player_all_df = gamelog_player_all_df[['GAME_DATE', 'MATCHUP', 'WL', 'MIN', 'FGM', 'FGA', 'FG_PCT', 'FG3M', 'FG3A', 'FG3_PCT', 'FTM', 'FTA', 'FT_PCT', 'OREB', 'DREB', 'REB', 'AST', 'STL', 'BLK', 'TOV', 'PTS']] gamelog_player_all_df = gamelog_player_all_df.rename(columns = {'GAME_DATE':'Game Date', 'FG_PCT' : 'FG %', 'FG3_PCT':'FG3 %', 'FT_PCT':'FT %'}) gamelog_player_all_df['FG %'] = pd.Series(["{0:.2f}%".format(val * 100) for val in gamelog_player_all_df['FG %']], index = gamelog_player_all_df.index) gamelog_player_all_df['FG3 %'] = pd.Series(["{0:.2f}%".format(val * 100) for val in gamelog_player_all_df['FG3 %']], index = gamelog_player_all_df.index) gamelog_player_all_df['FT %'] = pd.Series(["{0:.2f}%".format(val * 100) for val in gamelog_player_all_df['FT %']], index = gamelog_player_all_df.index) return gamelog_player_all_df
def player_average_9cat_stats(player_name, player_data_dict): # Get player identifier player_name_dict = [ player for player in player_data_dict if player[DISPLAY_FIRST_LAST] == player_name ] player_id = player_name_dict[0][PERSON_ID_KEY] # Player game log player_game_log = playergamelog.PlayerGameLog(player_id=player_id, season=SEASON_2020) nba_cooldown = random.gammavariate(alpha=9, beta=0.4) time.sleep(nba_cooldown) player_game_log_dataframe = player_game_log.get_data_frames()[0] # Filter for games played player_game_log_dataframe = \ player_game_log_dataframe[player_game_log_dataframe[MINUTES_COLUMN] >= 1] # Find true percentages player_game_log_dataframe = player_game_log_dataframe[CALCULATING_COLUMNS] player_game_log_dataframe.loc[MEAN_ROW] = player_game_log_dataframe.mean() player_game_log_dataframe = true_percentage(player_game_log_dataframe, FIELD_GOAL_PERCENTAGE_COLUMN) player_game_log_dataframe = true_percentage(player_game_log_dataframe, FREE_THROW_PERCENTAGE_COLUMN) # Filter for 9cat columns player_9cat = player_game_log_dataframe[NINE_CAT_COLUMNS] # Formatting columns player_9cat = format_dataframe_decimals(player_9cat) # Show only averages player_9cat_season_average = pd.DataFrame(player_9cat.loc[MEAN_ROW]).T # Add player name/games player player_9cat_season_average[PLAYER_COLUMN] = player_name player_9cat_season_average[GAMES_PLAYED] = len(player_game_log_dataframe) # Move PLAYER NAME column move_column_inplace(player_9cat_season_average, PLAYER_COLUMN, 0) return player_9cat_season_average
def get_winning_stats_per_team(team): fp = franchiseplayers.FranchisePlayers(team_id=team_to_id[team], headers=headers) PLAYERS = fp.get_data_frames()[0] # Build the list of players in the 2019-2020 season active_players = PLAYERS.loc[PLAYERS['ACTIVE_WITH_TEAM'] == 1] ids_per_team = active_players['PERSON_ID'].values player_names = active_players['PLAYER'].values print(player_names) players_per_team = dict(zip(ids_per_team, player_names)) effectiveness = [] players = [] ## Get the winning_stats_for a player for player in players_per_team: pgl = playergamelog.PlayerGameLog(player_id=player, headers=headers) player_game_data = pgl.get_data_frames()[0] effectiveness.append(determine_player_winning_score(player_game_data)) players.append(players_per_team[player]) plot_stats_to_winning(player_game_data, players_per_team[player]) effect = dict(zip(effectiveness, players)) rank_player_winning_scores(team, effect, 5)
def playerstatpull(player, teamabb, season=2020): #Pull a players boxscore stats in a season for regression by name TODO automate teamabb lookup DOESNT WORK FOR ROOKIES players=commonallplayers.CommonAllPlayers().get_data_frames() players=players[0] listofnames=players['DISPLAY_FIRST_LAST'] index=((list(listofnames)).index(player)) ID= (players.loc[index,'PERSON_ID']) bs=playergamelog.PlayerGameLog(player_id=ID,season=season) df=bs.get_data_frames() df=df[0] sumplusminus=[] plusminus=0 for i in range (len(df)): ###lookupgame, sum plus minus of rest, append to list game=boxscoretraditionalv2.BoxScoreTraditionalV2(game_id=df.loc[i][2]) game=(game.get_data_frames())[0] for j in range (len(game)): #TODO clean this up if game["TEAM_ABBREVIATION"][j]==teamabb and game["PLAYER_ID"][j]!=ID: if not math.isnan(game["PLUS_MINUS"][j]): ##filters out do not play could be done better plusminus+=game["PLUS_MINUS"][j] sumplusminus.append(plusminus) plusminus=0 time.sleep(1) #avoid timeout from api df['teamplusminus']=sumplusminus return df
def get_every_game_season(self, player_id, season_dict, season_games_dict): # go through every season for a player, get all of the games name = players.find_player_by_id(player_id)['full_name'] res = [] for year in season_dict[player_id]: # http request is made here player_season = playergamelog.PlayerGameLog(player_id, season=year) print(f'{name} - {year}') # ignore empty data if player_season.player_game_log.data['data'] != []: # played some time # all games in a season for game in player_season.player_game_log.data['data']: temp = [] for i in range(3, 25): # indices 3 to 25 give the important stats temp.append(game[i]) res.append(temp) player_dict = {player_id: res} season_games_dict.update(player_dict) # update shared dictionary print(f'{name} processed.')
data_dict[new] = data_dict[old] del data_dict[old] nba_players = players.get_players() time.sleep(0.5) for i in data_dict.keys(): if (data_dict[i][4] != 0) and (data_dict[i][5] != 'O'): print('--------------------------------------------------') print(i) try: pl = [ player for player in nba_players if player['full_name'] == i ][0]['id'] log_all = playergamelog.PlayerGameLog( player_id=pl).get_data_frames()[0] time.sleep(0.5) log_x = playergamelog.PlayerGameLog( player_id=pl).get_data_frames()[0][0:last_x] time.sleep(0.5) # STANDARD DEVIATION CALCULATION log_lst = [] for ind, row in log_all.iterrows(): log_fp = row['PTS'] + (row['FG3M'] * .5) + ( row['REB'] * 1.25) + (row['AST'] * 1.5) + ( (row['STL'] + row['BLK']) * 2) - (row['TOV'] * .5) DD_TD = 0 if row['PTS'] >= 10: DD_TD += 1
with open('data.json', 'w') as fp: json.dump(player_info, fp, indent=4) atexit.register(save_data) FROM_DATE = "01/01/2020" TO_DATE = "02/26/2020" # Count id id = 0 for player in player_info_raw: try: # Create game data sleep(0.5) game_log = playergamelog.PlayerGameLog(player_id=player['id'], timeout=300, date_from_nullable=FROM_DATE, date_to_nullable=TO_DATE).get_normalized_dict()["PlayerGameLog"] if len(game_log) == 0: continue games = [] for idx, game in enumerate(game_log): games.append({ "id": idx, "matchup": game["MATCHUP"], "result": game["WL"], "pts": game["PTS"], "ast": game["AST"], "reb": game["REB"] }) # Get player's info sleep(0.5)
rosters.append(rosters_dict["data"]) #get playerstats leaguestats = leaguedashplayerstats.LeagueDashPlayerStats( per_mode_detailed="PerGame", season="2018-19") leaguestats = leaguestats.league_dash_player_stats.get_dict() leaguestats = leaguestats["data"] leaguestats.sort(key=lambda x: x[0]) leaguestats_length = len(leaguestats) - 1 sql = "CREATE TABLE IF NOT EXISTS playergamelog (seasonid INT, playerid INT, gameid INT, gamedate DATE, matchup VARCHAR(255), win VARCHAR(255),min INT," sql += "fgm INT, fga INT, fg_pct DECIMAL(4,3), fg3m INT, fg3a INT, fg3_pct DECIMAL(4,3), ftm INT, fta INT, ft_pct DECIMAL(4,3), oreb INt, dreb INT, reb INT," sql += "ast INT, stl INT, blk INT, tov INT, pf INT, pts INT, plusminus INT, PRIMARY KEY (playerid, gamedate))" cursor.execute(sql) for player in leaguestats: player_stats = playergamelog.PlayerGameLog(player_id=player[0], season="2018-19") time.sleep(2) player_stats = player_stats.player_game_log.get_data_frame() for index, game in player_stats.iterrows(): sql = "INSERT INTO playergamelog (seasonid,playerid,gameid,gamedate,matchup,win,min,fgm,fga,fg_pct,fg3m,fg3a,fg3_pct,ftm,fta,ft_pct,oreb,dreb,reb,ast,stl,blk,tov,pf,pts,plusminus) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) ON DUPLICATE KEY UPDATE seasonid = %s" values = () for i in range(len(game) - 1): if (i == 3): game[i] = datetime.datetime.strptime(game[i], '%b %d, %Y') values = values + (game[i], ) values = values + (game[0], ) cursor.execute(sql, values) db.commit()
gamelog.get_data_frames()[0] ## get play by play from desired game (0021900543 ATL vs DEN) from nba_api.stats.endpoints import playbyplay gamepbp = playbyplay.PlayByPlay(game_id="0021900543") gamepbp.get_data_frames()[0].sort_values("EVENTNUM") ## get traditional box score from the same game from nba_api.stats.endpoints import boxscoretraditionalv2 boxscore = boxscoretraditionalv2.BoxScoreTraditionalV2(game_id="0021900543") boxscore.get_data_frames()[0] ## based on teamgamelog and box score, we could calculate the FPPM for each player ## but how to link games to players? have to go through team? from nba_api.stats.endpoints import playergamelog gamelog = playergamelog.PlayerGameLog(player_id="203999", season="2018-19") gamelog.get_data_frames()[0] # does it include DNPs? ### seems it does not ### One(?) does have to create a class that returns relevant FPs for a given player ## and game number (Nikola Vucevic, game 35)
def __getPlayerStats(playerID: str, year: int) -> DataFrame.__class__: gamelog = playergamelog.PlayerGameLog(player_id=playerID, season=str(year)) return gamelog.get_data_frames()[0]
from nba_api.stats.endpoints import playercareerstats, playergamelog import pandas as pd import numpy as np import datetime # Myles Turner Bubble Stats # career = playercareerstats.PlayerCareerStats(player_id='1626167') # career = career.get_data_frames()[0] domas_games = playergamelog.PlayerGameLog(player_id="1627734", season="ALL") domas_games = domas_games.get_data_frames()[0] myles_games = playergamelog.PlayerGameLog(player_id="1626167", season="ALL") myles_games = myles_games.get_data_frames()[0] for i in myles_games.Game_ID: for j in domas_games.Game_ID: if (i == j): myles_games = myles_games[myles_games.Game_ID != i] pacers_playoffs = playergamelog.PlayerGameLog(player_id="1626167", season="ALL", season_type_all_star="Playoffs") pacers_playoffs = pacers_playoffs.get_data_frames()[0] myles_games = pd.concat([pacers_playoffs, myles_games]) new_dates = [] for i in myles_games.GAME_DATE: i = datetime.datetime.strptime(i, '%b %d, %Y') new_dates.append(i)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- from nba_api.stats.library.parameters import SeasonAll from nba_api.stats.endpoints import playergamelog import pandas as pd gamelog_bron_all = playergamelog.PlayerGameLog(player_id='2544', season=SeasonAll.all) df_bron_games_all = gamelog_bron_all.get_data_frames()[0] df_bron_games_all.to_csv(path_or_buf="lebronAll.csv")
# import nba_api as nba # pbp = nba_st_end.playbyplay.PlayByPlay('0021701171') # pbp = pbp.get_data_frames()[0] # print (pbp) from nba_api.stats.static import players from nba_api.stats.static import teams from nba_api.stats.endpoints import leaguegamefinder from nba_api.stats.endpoints import playbyplayv2 from nba_api.stats.endpoints import commonplayerinfo from nba_api.stats.endpoints import playergamelog playerid = players.find_players_by_full_name('Damian Lillard')[0]['id'] gamefinder = leaguegamefinder.LeagueGameFinder(player_id_nullable=playerid) plays_for = commonplayerinfo.CommonPlayerInfo( player_id=playerid).get_data_frames()[0].at[0, 'TEAM_ABBREVIATION'] score = playergamelog.PlayerGameLog(season_all="ALL", player_id=playerid) againstTeam = {} for team in teams.get_teams(): againstTeam[team['abbreviation']] = 0 for i in range(len(games.index)): print(i) pbp = playbyplayv2.PlayByPlayV2(games.at[i, 'GAME_ID']) pbp = pbp.get_data_frames()[0] match = games.at[i, 'MATCHUP'] if ("@ " + plays_for in match) or (plays_for + " vs." in match): home = True else: home = False
import seaborn as sns import matplotlib.pyplot as plt import time # Get LeBron James player ID # https://github.com/swar/nba_api/blob/master/docs/nba_api/stats/static/players.md lbj_dict = players.find_players_by_full_name('LeBron James') lbj_id = lbj_dict[0]['id'] # Using ID, get LeBron's game logs # https://github.com/swar/nba_api/blob/master/docs/nba_api/stats/endpoints/playergamelog.md # Test on 2018-19 lbj_game_log_1819 = playergamelog.PlayerGameLog( player_id=lbj_id, season_all='2018-19', season_type_all_star='Regular Season') lbj_game_log_1819_df = lbj_game_log_1819.get_data_frames()[0] lbj_1819_pts_by_game = ( lbj_game_log_1819_df.loc[:, ['GAME_DATE', 'PTS']].sort_values('GAME_DATE')) """ lbj_1819_pts_by_game GAME_DATE PTS 26 DEC 02, 2018 22 25 DEC 05, 2018 42 24 DEC 07, 2018 35 23 DEC 08, 2018 20 22 DEC 10, 2018 28 21 DEC 13, 2018 29 20 DEC 15, 2018 24 19 DEC 16, 2018 13
from nba_api.stats.endpoints import playergamelog from nba_api.stats.library.parameters import SeasonAll import pandas as pd #Call the API endpoint passing in lebron's ID & which season gamelog = playergamelog.PlayerGameLog(player_id='1627763', season='2020') gamelogAll = playergamelog.PlayerGameLog(player_id='1627763', season=SeasonAll.all) #Converts gamelog object into a pandas dataframe #can also convert to JSON or dictionary df = gamelogAll.get_data_frames() print(df) # # If you want all seasons, you must import the SeasonAll parameter # from nba_api.stats.library.parameters import SeasonAll # gamelog_bron_all = playergamelog.PlayerGameLog(player_id='2544', season = SeasonAll.all) # df_bron_games_all = gamelog_bron_all.get_data_frames()
from nba_api.stats.endpoints import playergamelog, teamgamelog, playernextngames, leaguestandings import statistics r = 0 Play = ["DeMar DeRozan"] li = [18.5] for pl in Play: Line = li[r] name = pl the_factor = 'null' player_dict = players.get_active_players() for player in player_dict: if player['full_name'] == name: the_factor = player['id'] gamelog = playergamelog.PlayerGameLog(player_id=the_factor, season='2020') df = gamelog.get_data_frames() str_matchup = str(df[0].MATCHUP[0]) str_matchup = str_matchup[:-2] the_team_factor = 'null' team_dict = teams.get_teams() for team in team_dict: if team['abbreviation'] in str_matchup: the_team_factor = team['id'] team_game_log = teamgamelog.TeamGameLog(team_id=the_team_factor, season='2020') tdf = team_game_log.get_data_frames() next_games = playernextngames.PlayerNextNGames(player_id=the_factor,
filename = filename + seasonToGrab + '-CombinedPlayerBoxScores.csv' ######Create the dataframe by loading in a player outside of the loop player_dict = players.get_players() time.sleep(2) #Loop through player listing df_player_games_total = pd.DataFrame() # Use ternary operator or write function # Names are case sensitive player = [ player for player in player_dict if player['full_name'] == 'Tristan Thompson' ][0] player_id = player['id'] #Call the API endpoint passing in lebron's ID & which season gamelog_player = playergamelog.PlayerGameLog(player_id=player_id, season=seasonToGrab) time.sleep(2) #Converts gamelog object into a pandas dataframe #can also convert to JSON or dictionary df_player_games = gamelog_player.get_data_frames()[0] df_player_games.insert(2, 'Player_Name', 'Tristan Thompson') df_player_games_total = df_player_games time.sleep(2) ###### #####Loop through list of players and append together for i in playerList: # Use ternary operator or write function # Names are case sensitive player = [player for player in player_dict if player['full_name'] == i][0] player_id = player['id']