{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## NBA Home Court Advantage\n", "\n", "### Part 2: A Deeper Look at Win Percentages\n", "\n", "In the [first notebook in this series on NBA home court advantage](http://nbviewer.jupyter.org/github/practicallypredictable/posts/blob/master/notebooks/nba_home_court-part1.ipynb), we saw that home court win percentages varied over the past 21 seasons, but have averaged around 60%.\n", "\n", "In this notebook, we'll try to drill a little deeper into the distribution of home court win percentages.\n", "\n", "Within a given NBA season, teams vary enormously in quality. From the historical data, we know that an average team (with a 50% win percentage) has roughly a 10% improvement in win probability from playing at home. But what about low-quality teams or elite teams? What does home court advantage look like for teams that aren't average?\n", "\n", "Let's look at the data and see. We'll use the same match up data from the 1996-97 through 2016-17 regular seasons." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "pd.options.display.max_rows = 999\n", "pd.options.display.max_columns = 999\n", "pd.options.display.float_format = '{:.3f}'.format" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", "from matplotlib.colors import rgb2hex\n", "import seaborn as sns\n", "sns.set()\n", "sns.set_context('notebook')\n", "plt.style.use('ggplot')" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from pathlib import Path" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "PROJECT_DIR = Path.cwd().parent / 'basketball' / 'nba'\n", "DATA_DIR = PROJECT_DIR / 'data' / 'prepared'\n", "DATA_DIR.mkdir(exist_ok=True, parents=True)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def load_nba_historical_matchups(input_dir):\n", " \"\"\"Load pickle file of NBA matchups prepared for analytics.\"\"\"\n", " PKLFILENAME = 'stats_nba_com-matchups-1996_97-2016_17.pkl'\n", " pklfile = input_dir.joinpath(PKLFILENAME)\n", " return pd.read_pickle(pklfile)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(26787, 41)" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matchups = load_nba_historical_matchups(DATA_DIR)\n", "matchups.shape" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "21" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seasons = sorted(list(matchups['season'].unique()))\n", "len(seasons)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def prepare_regular_season(matchups):\n", " df = matchups.copy()\n", " df = df[df['season_type'] == 'regular']\n", " return df" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(24797, 41)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "reg = prepare_regular_season(matchups)\n", "reg.shape" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "30" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "teams = sorted(list(reg['team_curr_h'].unique()))\n", "len(teams)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Grouping by Season and Team\n", "\n", "Let's group the match up information by season and team so we can look for patterns. To do this, we'll use the `pandas` [`groupby`](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.groupby.html) methods. These methods are very powerful but can be tricky to use correctly.\n", "\n", "Grouping will allow us to calculate aggregate statistics for a particular team in a particular season. Teams change over time, as rosters, coaches and management evolve. Of course, there's also variation in team lineups intra-season, due to trades and injuries. We will eventually get to the player level of detail, but for now we will focus on the regular season as a reasonable time unit for analysizing a team.\n", "\n", "We will also split the home and away games in this grouping. We can subtract the away game statistics from the home game statistics, controlling for season and team. This will allow us to develop a purer estimate of the impact of home court.\n", "\n", "For now, we're only going to compute win percentages. In future analysis, we'll apply the same idea to box scores." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "def win_loss_information(matchups, seasons, teams):\n", " # Split home and away games\n", " home_games = matchups.groupby(['season', 'team_curr_h', 'won'])\n", " away_games = matchups.groupby(['season', 'team_curr_a', 'won'])\n", " # Get counts of each type of game within each group\n", " home_wl_count = home_games['date'].count()\n", " away_wl_count = away_games['date'].count()\n", " # Get counts of home wins, home losses, away wins and away losses\n", " home_wins = {}\n", " home_losses = {}\n", " for season, team, winner in home_games.groups.keys():\n", " if winner == 'H':\n", " home_wins[(season, team)] = home_wl_count[(season, team, winner)]\n", " else:\n", " home_losses[(season, team)] = home_wl_count[(season, team, winner)]\n", " away_wins = {}\n", " away_losses = {}\n", " for season, team, winner in away_games.groups.keys():\n", " if winner == 'A':\n", " away_wins[(season, team)] = away_wl_count[(season, team, winner)]\n", " else:\n", " away_losses[(season, team)] = away_wl_count[(season, team, winner)]\n", " # Create DataFrame of counts and win/loss percentages\n", " df = pd.DataFrame({\n", " 'home_wins': home_wins,\n", " 'home_losses': home_losses,\n", " 'away_wins': away_wins,\n", " 'away_losses': away_losses,\n", " })\n", " df['home_games'] = df['home_wins'] + df['home_losses']\n", " df['away_games'] = df['away_wins'] + df['away_losses']\n", " df['games'] = df['home_games'] + df['away_games']\n", " df['wins'] = df['away_wins'] + df['home_wins']\n", " df['losses'] = df['away_losses'] + df['home_losses']\n", " df['win_percentage'] = df['wins'] / df['games']\n", " df['home_win_percentage'] = df['home_wins'] / df['home_games']\n", " df['away_win_percentage'] = df['away_wins'] / df['away_games']\n", " df = df.reset_index().rename(columns={'level_0': 'season', 'level_1': 'team'})\n", " return df[[\n", " 'season',\n", " 'team',\n", " 'games',\n", " 'wins',\n", " 'losses',\n", " 'win_percentage',\n", " 'home_games',\n", " 'home_wins',\n", " 'home_losses',\n", " 'home_win_percentage',\n", " 'away_games',\n", " 'away_wins',\n", " 'away_losses',\n", " 'away_win_percentage',\n", " ]]" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/html": [ "<div>\n", "<style scoped>\n", " .dataframe tbody tr th:only-of-type {\n", " vertical-align: middle;\n", " }\n", "\n", " .dataframe tbody tr th {\n", " vertical-align: top;\n", " }\n", "\n", " .dataframe thead th {\n", " text-align: right;\n", " }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", " <thead>\n", " <tr style=\"text-align: right;\">\n", " <th></th>\n", " <th>season</th>\n", " <th>team</th>\n", " <th>games</th>\n", " <th>wins</th>\n", " <th>losses</th>\n", " <th>win_percentage</th>\n", " <th>home_games</th>\n", " <th>home_wins</th>\n", " <th>home_losses</th>\n", " <th>home_win_percentage</th>\n", " <th>away_games</th>\n", " <th>away_wins</th>\n", " <th>away_losses</th>\n", " <th>away_win_percentage</th>\n", " </tr>\n", " </thead>\n", " <tbody>\n", " <tr>\n", " <th>0</th>\n", " <td>1996-97</td>\n", " <td>ATL</td>\n", " <td>82</td>\n", " <td>56</td>\n", " <td>26</td>\n", " <td>0.683</td>\n", " <td>41</td>\n", " <td>36</td>\n", " <td>5</td>\n", " <td>0.878</td>\n", " <td>41</td>\n", " <td>20</td>\n", " <td>21</td>\n", " <td>0.488</td>\n", " </tr>\n", " <tr>\n", " <th>1</th>\n", " <td>1996-97</td>\n", " <td>BKN</td>\n", " <td>82</td>\n", " <td>26</td>\n", " <td>56</td>\n", " <td>0.317</td>\n", " <td>41</td>\n", " <td>16</td>\n", " <td>25</td>\n", " <td>0.390</td>\n", " <td>41</td>\n", " <td>10</td>\n", " <td>31</td>\n", " <td>0.244</td>\n", " </tr>\n", " <tr>\n", " <th>2</th>\n", " <td>1996-97</td>\n", " <td>BOS</td>\n", " <td>82</td>\n", " <td>15</td>\n", " <td>67</td>\n", " <td>0.183</td>\n", " <td>41</td>\n", " <td>11</td>\n", " <td>30</td>\n", " <td>0.268</td>\n", " <td>41</td>\n", " <td>4</td>\n", " <td>37</td>\n", " <td>0.098</td>\n", " </tr>\n", " <tr>\n", " <th>3</th>\n", " <td>1996-97</td>\n", " <td>CHI</td>\n", " <td>82</td>\n", " <td>69</td>\n", " <td>13</td>\n", " <td>0.841</td>\n", " <td>41</td>\n", " <td>39</td>\n", " <td>2</td>\n", " <td>0.951</td>\n", " <td>41</td>\n", " <td>30</td>\n", " <td>11</td>\n", " <td>0.732</td>\n", " </tr>\n", " <tr>\n", " <th>4</th>\n", " <td>1996-97</td>\n", " <td>CLE</td>\n", " <td>82</td>\n", " <td>42</td>\n", " <td>40</td>\n", " <td>0.512</td>\n", " <td>41</td>\n", " <td>25</td>\n", " <td>16</td>\n", " <td>0.610</td>\n", " <td>41</td>\n", " <td>17</td>\n", " <td>24</td>\n", " <td>0.415</td>\n", " </tr>\n", " </tbody>\n", "</table>\n", "</div>" ], "text/plain": [ " season team games wins losses win_percentage home_games home_wins \\\n", "0 1996-97 ATL 82 56 26 0.683 41 36 \n", "1 1996-97 BKN 82 26 56 0.317 41 16 \n", "2 1996-97 BOS 82 15 67 0.183 41 11 \n", "3 1996-97 CHI 82 69 13 0.841 41 39 \n", "4 1996-97 CLE 82 42 40 0.512 41 25 \n", "\n", " home_losses home_win_percentage away_games away_wins away_losses \\\n", "0 5 0.878 41 20 21 \n", "1 25 0.390 41 10 31 \n", "2 30 0.268 41 4 37 \n", "3 2 0.951 41 30 11 \n", "4 16 0.610 41 17 24 \n", "\n", " away_win_percentage \n", "0 0.488 \n", "1 0.244 \n", "2 0.098 \n", "3 0.732 \n", "4 0.415 " ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "wl = win_loss_information(reg, seasons, teams)\n", "wl.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We now have data for season-by-season win percentages (overall, home and away) for each NBA team. As a reminder, we are using the current NBA team name for historical data, to keep track of team moves and name changes. Please see [the original post on scraping the data](http://practicallypredictable.com/2017/12/21/web-scraping-nba-team-matchups-box-scores/) for more information.\n", "\n", "Since it took some work to create this view of the data, let's save it to a CSV file. That way, we can easily use the data in different analyses." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "csvfile = DATA_DIR.joinpath('stats_nba_com-team_records-1996_97-2016_17.csv')\n", "wl.to_csv(csvfile, index=False, float_format='%g')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Analyzing the Win Percentages\n", "\n", "Now let's get a high level overview of the win percentage and home win percentage, for each team/season pair." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/html": [ "<div>\n", "<style scoped>\n", " .dataframe tbody tr th:only-of-type {\n", " vertical-align: middle;\n", " }\n", "\n", " .dataframe tbody tr th {\n", " vertical-align: top;\n", " }\n", "\n", " .dataframe thead th {\n", " text-align: right;\n", " }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", " <thead>\n", " <tr style=\"text-align: right;\">\n", " <th></th>\n", " <th>win_percentage</th>\n", " <th>home_win_percentage</th>\n", " </tr>\n", " </thead>\n", " <tbody>\n", " <tr>\n", " <th>count</th>\n", " <td>622.000</td>\n", " <td>622.000</td>\n", " </tr>\n", " <tr>\n", " <th>mean</th>\n", " <td>0.500</td>\n", " <td>0.598</td>\n", " </tr>\n", " <tr>\n", " <th>std</th>\n", " <td>0.155</td>\n", " <td>0.170</td>\n", " </tr>\n", " <tr>\n", " <th>min</th>\n", " <td>0.106</td>\n", " <td>0.121</td>\n", " </tr>\n", " <tr>\n", " <th>25%</th>\n", " <td>0.390</td>\n", " <td>0.488</td>\n", " </tr>\n", " <tr>\n", " <th>50%</th>\n", " <td>0.512</td>\n", " <td>0.610</td>\n", " </tr>\n", " <tr>\n", " <th>75%</th>\n", " <td>0.610</td>\n", " <td>0.732</td>\n", " </tr>\n", " <tr>\n", " <th>max</th>\n", " <td>0.890</td>\n", " <td>0.976</td>\n", " </tr>\n", " </tbody>\n", "</table>\n", "</div>" ], "text/plain": [ " win_percentage home_win_percentage\n", "count 622.000 622.000\n", "mean 0.500 0.598\n", "std 0.155 0.170\n", "min 0.106 0.121\n", "25% 0.390 0.488\n", "50% 0.512 0.610\n", "75% 0.610 0.732\n", "max 0.890 0.976" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hca = wl[['season', 'team', 'win_percentage', 'home_win_percentage']].copy()\n", "hca.describe()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are 622 distinct team/season pairs. For some of these 21 seasons, there were only 29 NBA teams (prior to the Charlotte expansion).\n", "\n", "As required by basic arithmetic, the average NBA team has a 50% win percentage. And we see the same 59.8% home team win percentage from our prior analysis. What's interesting in this table, though, is the distribution information.\n", "\n", "For example, we see that the win percentage has ranged from just over 10% to as high as 89%, and that 50% of the win percentages are between 39% and 61%. To see that, look at the \"25%\" and \"75%\" rows in table above. This table shows the [quartiles](https://en.wikipedia.org/wiki/Quartile) of the win percentage distribution. Quartiles are a particular example of [quantiles](https://en.wikipedia.org/wiki/Quantile).\n", "\n", "The 25% and 75% quantiles of the home win percentage distribution are roughly 49% and 73%. These also happen to be roughly 10% higher than the corresponding win percentage. So, how correct is it to simply add 10% to any NBA team's win percentage to predict their home win percentage? Or conversely, how correct is it to subtract 10% from any NBA team's home win percentage to predict their overall season win percentage?\n", "\n", "Before we answer that question, let's look at how these percentages vary over time, by season.\n", "\n", "### Variation by Season\n", "\n", "For simplicity, we'll just look at the average win percentage and home win percentage by season. You could also do this analysis with the [median](https://en.wikipedia.org/wiki/Median) (the 50% quantile) or some other statistic." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/html": [ "<div>\n", "<style scoped>\n", " .dataframe tbody tr th:only-of-type {\n", " vertical-align: middle;\n", " }\n", "\n", " .dataframe tbody tr th {\n", " vertical-align: top;\n", " }\n", "\n", " .dataframe thead th {\n", " text-align: right;\n", " }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", " <thead>\n", " <tr style=\"text-align: right;\">\n", " <th></th>\n", " <th>home_win_percentage</th>\n", " <th>win_percentage</th>\n", " </tr>\n", " <tr>\n", " <th>season</th>\n", " <th></th>\n", " <th></th>\n", " </tr>\n", " </thead>\n", " <tbody>\n", " <tr>\n", " <th>1996-97</th>\n", " <td>0.575</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>1997-98</th>\n", " <td>0.595</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>1998-99</th>\n", " <td>0.623</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>1999-00</th>\n", " <td>0.611</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2000-01</th>\n", " <td>0.598</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2001-02</th>\n", " <td>0.591</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2002-03</th>\n", " <td>0.628</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2003-04</th>\n", " <td>0.614</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2004-05</th>\n", " <td>0.605</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2005-06</th>\n", " <td>0.603</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2006-07</th>\n", " <td>0.591</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2007-08</th>\n", " <td>0.601</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2008-09</th>\n", " <td>0.608</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2009-10</th>\n", " <td>0.594</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2010-11</th>\n", " <td>0.604</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2011-12</th>\n", " <td>0.586</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2012-13</th>\n", " <td>0.612</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2013-14</th>\n", " <td>0.580</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2014-15</th>\n", " <td>0.575</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2015-16</th>\n", " <td>0.589</td>\n", " <td>0.500</td>\n", " </tr>\n", " <tr>\n", " <th>2016-17</th>\n", " <td>0.584</td>\n", " <td>0.500</td>\n", " </tr>\n", " </tbody>\n", "</table>\n", "</div>" ], "text/plain": [ " home_win_percentage win_percentage\n", "season \n", "1996-97 0.575 0.500\n", "1997-98 0.595 0.500\n", "1998-99 0.623 0.500\n", "1999-00 0.611 0.500\n", "2000-01 0.598 0.500\n", "2001-02 0.591 0.500\n", "2002-03 0.628 0.500\n", "2003-04 0.614 0.500\n", "2004-05 0.605 0.500\n", "2005-06 0.603 0.500\n", "2006-07 0.591 0.500\n", "2007-08 0.601 0.500\n", "2008-09 0.608 0.500\n", "2009-10 0.594 0.500\n", "2010-11 0.604 0.500\n", "2011-12 0.586 0.500\n", "2012-13 0.612 0.500\n", "2013-14 0.580 0.500\n", "2014-15 0.575 0.500\n", "2015-16 0.589 0.500\n", "2016-17 0.584 0.500" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hca.groupby('season')['home_win_percentage', 'win_percentage'].mean()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The average win percentage isn't too interesting, since it's always 50%. The home win percentage fluctuates by season as we saw in our [preliminary analysis](http://nbviewer.jupyter.org/github/practicallypredictable/posts/blob/master/notebooks/nba_home_court-part1.ipynb).\n", "\n", "### Ranking by Quartile\n", "\n", "Let's make this analysis a little more interesting. Let's organize the data by quartile, so we can see if there is any useful pattern for weak, mediocre, good and elite teams.\n", "\n", "We can use `pandas` to get the numerical values of each quartile." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/html": [ "<div>\n", "<style scoped>\n", " .dataframe tbody tr th:only-of-type {\n", " vertical-align: middle;\n", " }\n", "\n", " .dataframe tbody tr th {\n", " vertical-align: top;\n", " }\n", "\n", " .dataframe thead th {\n", " text-align: right;\n", " }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", " <thead>\n", " <tr style=\"text-align: right;\">\n", " <th></th>\n", " <th>home_win_percentage</th>\n", " <th>win_percentage</th>\n", " </tr>\n", " </thead>\n", " <tbody>\n", " <tr>\n", " <th>0</th>\n", " <td>0.931</td>\n", " <td>0.776</td>\n", " </tr>\n", " <tr>\n", " <th>1</th>\n", " <td>0.241</td>\n", " <td>0.241</td>\n", " </tr>\n", " <tr>\n", " <th>2</th>\n", " <td>0.086</td>\n", " <td>0.069</td>\n", " </tr>\n", " <tr>\n", " <th>3</th>\n", " <td>1.000</td>\n", " <td>1.000</td>\n", " </tr>\n", " <tr>\n", " <th>4</th>\n", " <td>0.534</td>\n", " <td>0.552</td>\n", " </tr>\n", " </tbody>\n", "</table>\n", "</div>" ], "text/plain": [ " home_win_percentage win_percentage\n", "0 0.931 0.776\n", "1 0.241 0.241\n", "2 0.086 0.069\n", "3 1.000 1.000\n", "4 0.534 0.552" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hca_ranks = hca.groupby('season').rank(numeric_only=True, pct=True)\n", "hca_ranks.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, all we need to do is to label our data with the quartile number. For every team/season win percentage and home win percentage, we can just look up in the above table what quartile that team is for that season.\n", "\n", "Fortunately, `pandas` lets us do this in just a few lines of Python." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "def quartile_index(x):\n", " return pd.qcut(x, q=4, labels=False)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "def get_quartiles(df):\n", " df_q = df.groupby('season').rank(numeric_only=True, pct=True).apply(quartile_index)\n", " for col in df_q.columns:\n", " df[col].astype(int)\n", " return df_q" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/html": [ "<div>\n", "<style scoped>\n", " .dataframe tbody tr th:only-of-type {\n", " vertical-align: middle;\n", " }\n", "\n", " .dataframe tbody tr th {\n", " vertical-align: top;\n", " }\n", "\n", " .dataframe thead th {\n", " text-align: right;\n", " }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", " <thead>\n", " <tr style=\"text-align: right;\">\n", " <th></th>\n", " <th>home_win_percentage</th>\n", " <th>win_percentage</th>\n", " </tr>\n", " </thead>\n", " <tbody>\n", " <tr>\n", " <th>0</th>\n", " <td>3</td>\n", " <td>3</td>\n", " </tr>\n", " <tr>\n", " <th>1</th>\n", " <td>0</td>\n", " <td>0</td>\n", " </tr>\n", " <tr>\n", " <th>2</th>\n", " <td>0</td>\n", " <td>0</td>\n", " </tr>\n", " <tr>\n", " <th>3</th>\n", " <td>3</td>\n", " <td>3</td>\n", " </tr>\n", " <tr>\n", " <th>4</th>\n", " <td>2</td>\n", " <td>2</td>\n", " </tr>\n", " </tbody>\n", "</table>\n", "</div>" ], "text/plain": [ " home_win_percentage win_percentage\n", "0 3 3\n", "1 0 0\n", "2 0 0\n", "3 3 3\n", "4 2 2" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "get_quartiles(hca).head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's take a moment to reflect on the above example. What we did was apply a function (to look up the quartile number) to our original `DataFrame`, and create a new `DataFrame` with those quartile values instead of the original data. This table only displays the first 5 lines of the data set, which comprise 622 team/season pairs. Let's put all this in a function to return the full 622-row table." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "def get_hca_quartile(hca, col, quartile):\n", " df = get_quartiles(hca)\n", " return df[df[col] == quartile]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### An Interesting Figure\n", "\n", "Since a picture is worth a thousand words, let's make a picture. We can use different colors to signify the different quartiles. Let's see the `seaborn` color palette." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAABECAYAAACmjMM7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAAZ9JREFUeJzt2jFKXFEAhtE7MtvIBlKb1iIhCLoIS+sphFnCQArrlC4iQhAt0sbaDWQbgZdeBkXyPZ7oOeW9PPi7Dy5vNU3TAID/dbD0AADeBkEBICEoACQEBYCEoACQWD9z7xcwAPZZPT54Lijjz+nhPFNegQ8/7senb3dLz5jN74vP4/vlw9IzZnO++Ti22+3SM2ax2+3G319nS8+YzfroalzefFl6xmw2X2/HuP659Iz5nBzvPfbkBUBCUABICAoACUEBICEoACQEBYCEoACQEBQAEoICQEJQAEgICgAJQQEgISgAJAQFgISgAJAQFAASggJAQlAASAgKAAlBASAhKAAkBAWAhKAAkBAUABKCAkBCUABICAoACUEBICEoACQEBYCEoACQEBQAEoICQEJQAEgICgAJQQEgISgAJAQFgISgAJAQFAASggJAQlAASAgKAAlBASAhKAAkBAWAhKAAkBAUABKCAkBCUABICAoACUEBICEoACRW0zQ9df/kJQDv1urxwfqlHwDAPp68AEgICgAJQQEgISgAJAQFgMQ/px8ciO76oEoAAAAASUVORK5CYII=\n", "text/plain": [ "<matplotlib.figure.Figure at 0x1a15ac2438>" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "colors = sns.color_palette()\n", "sns.palplot(colors)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We'll use the 4 colors on the right to signify the bottom, third, second and top quartile teams. We need a function to plot the data for each quartile in the correct color. We'll call this function 4 times, once for each quartile. The quartile is based on the team's win percentage in that season. The top quartile is the elite teams in that season, irrespective of home win percentage, and so on for the lower quartiles." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "def plot_hca_quartile(ax, hca, x_col, y_col, quartile, label, colors):\n", " lookup_df = get_hca_quartile(hca, y_col, quartile)\n", " data_df = hca.loc[lookup_df.index, :]\n", " ax = sns.regplot(\n", " data=data_df, x=x_col, y=y_col, ax=ax, fit_reg=False,\n", " label=label,\n", " scatter_kws={'alpha': 0.5, 'facecolors': colors[6-quartile]}\n", " )\n", " return ax" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "<matplotlib.figure.Figure at 0x1a1704d6a0>" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(figsize=(7, 7))\n", "x_col = 'home_win_percentage'\n", "y_col = 'win_percentage'\n", "ax = plot_hca_quartile(ax, hca, x_col, y_col, 0, 'bottom quartile win % for season', colors)\n", "ax = plot_hca_quartile(ax, hca, x_col, y_col, 1, '3rd quartile win % for season', colors)\n", "ax = plot_hca_quartile(ax, hca, x_col, y_col, 2, '2rd quartile win % for season', colors)\n", "ax = plot_hca_quartile(ax, hca, x_col, y_col, 3, 'top quartile win % for season', colors)\n", "ax.set_xlim(0, 1)\n", "ax.set_xlabel('Team Home Win Percentage')\n", "ax.set_ylim(0, 1)\n", "ax.set_ylabel('Team Win Percentage')\n", "ax.set_title('Team Overall Win Percentage and Home Win Percentage')\n", "ax.legend()\n", "ax.plot(ax.get_xlim(), ax.get_ylim(), linestyle='--', color='black', alpha=0.5)\n", "ax.axhline(y=0.5, linestyle='--', alpha=0.5, color='black')\n", "ax.axvline(x=0.5, linestyle='--', alpha=0.5, color='black')\n", "ax.axvline(x=hca['home_win_percentage'].mean(), alpha=0.5, color='black')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The figure has 4 lines overlaid to help in the interpretation.\n", "\n", "The horizontal dashed line divides the plot into team/season pairs with overall winning records in that season.\n", "\n", "The vertical dashed line divides the plot into team/season pairs with better-than-even home win percentages in that season. As you would expect, most of the observations fall to the right of this vertical line.\n", "\n", "There are some bottom-quartile teams with winning home records, and there are some third-quartile teams with losing home records.\n", "\n", "As a curiosity, look at the team sticking out on the lower-right. This team had a better than 65% home win record, but was sub-40% overall. Who was it? The 2002-3 Chicago Bulls, with their [franchise-worst 3-38 road record](https://en.wikipedia.org/wiki/2002%E2%80%9303_Chicago_Bulls_season). They got 27 of their 30 wins on at home." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/html": [ "<div>\n", "<style scoped>\n", " .dataframe tbody tr th:only-of-type {\n", " vertical-align: middle;\n", " }\n", "\n", " .dataframe tbody tr th {\n", " vertical-align: top;\n", " }\n", "\n", " .dataframe thead th {\n", " text-align: right;\n", " }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", " <thead>\n", " <tr style=\"text-align: right;\">\n", " <th></th>\n", " <th>season</th>\n", " <th>team</th>\n", " <th>win_percentage</th>\n", " <th>home_win_percentage</th>\n", " <th>wins</th>\n", " <th>losses</th>\n", " </tr>\n", " </thead>\n", " <tbody>\n", " <tr>\n", " <th>177</th>\n", " <td>2002-03</td>\n", " <td>CHI</td>\n", " <td>0.366</td>\n", " <td>0.659</td>\n", " <td>30</td>\n", " <td>52</td>\n", " </tr>\n", " </tbody>\n", "</table>\n", "</div>" ], "text/plain": [ " season team win_percentage home_win_percentage wins losses\n", "177 2002-03 CHI 0.366 0.659 30 52" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "wl.loc[\n", " (wl['win_percentage'] < 0.38) & (wl['home_win_percentage'] > 0.62),\n", " ['season', 'team', 'win_percentage', 'home_win_percentage', 'wins', 'losses']\n", "]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The vertical solid line shows the location of the home win percentage average for all teams and seasons (59.8%).\n", "\n", "The diagonal line has slope 1, and is where the team win percentage equals the home win percentage. In other words, _teams on this line had no observable home court advantage_ in that particular season.\n", "\n", "In fact, we see that there are a few teams which had _worse_ home records than overall records. Here is a list of the 11 times where that occurred." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/html": [ "<div>\n", "<style scoped>\n", " .dataframe tbody tr th:only-of-type {\n", " vertical-align: middle;\n", " }\n", "\n", " .dataframe tbody tr th {\n", " vertical-align: top;\n", " }\n", "\n", " .dataframe thead th {\n", " text-align: right;\n", " }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", " <thead>\n", " <tr style=\"text-align: right;\">\n", " <th></th>\n", " <th>season</th>\n", " <th>team</th>\n", " <th>win_percentage</th>\n", " <th>home_win_percentage</th>\n", " <th>wins</th>\n", " <th>losses</th>\n", " </tr>\n", " </thead>\n", " <tbody>\n", " <tr>\n", " <th>14</th>\n", " <td>1996-97</td>\n", " <td>MIA</td>\n", " <td>0.744</td>\n", " <td>0.707</td>\n", " <td>61</td>\n", " <td>21</td>\n", " </tr>\n", " <tr>\n", " <th>162</th>\n", " <td>2001-02</td>\n", " <td>NOP</td>\n", " <td>0.537</td>\n", " <td>0.512</td>\n", " <td>44</td>\n", " <td>38</td>\n", " </tr>\n", " <tr>\n", " <th>272</th>\n", " <td>2005-06</td>\n", " <td>HOU</td>\n", " <td>0.415</td>\n", " <td>0.366</td>\n", " <td>34</td>\n", " <td>48</td>\n", " </tr>\n", " <tr>\n", " <th>300</th>\n", " <td>2006-07</td>\n", " <td>DET</td>\n", " <td>0.646</td>\n", " <td>0.634</td>\n", " <td>53</td>\n", " <td>29</td>\n", " </tr>\n", " <tr>\n", " <th>343</th>\n", " <td>2007-08</td>\n", " <td>ORL</td>\n", " <td>0.634</td>\n", " <td>0.610</td>\n", " <td>52</td>\n", " <td>30</td>\n", " </tr>\n", " <tr>\n", " <th>369</th>\n", " <td>2008-09</td>\n", " <td>MIN</td>\n", " <td>0.293</td>\n", " <td>0.268</td>\n", " <td>24</td>\n", " <td>58</td>\n", " </tr>\n", " <tr>\n", " <th>384</th>\n", " <td>2009-10</td>\n", " <td>BOS</td>\n", " <td>0.610</td>\n", " <td>0.585</td>\n", " <td>50</td>\n", " <td>32</td>\n", " </tr>\n", " <tr>\n", " <th>404</th>\n", " <td>2009-10</td>\n", " <td>PHI</td>\n", " <td>0.329</td>\n", " <td>0.293</td>\n", " <td>27</td>\n", " <td>55</td>\n", " </tr>\n", " <tr>\n", " <th>437</th>\n", " <td>2010-11</td>\n", " <td>SAC</td>\n", " <td>0.293</td>\n", " <td>0.268</td>\n", " <td>24</td>\n", " <td>58</td>\n", " </tr>\n", " <tr>\n", " <th>443</th>\n", " <td>2011-12</td>\n", " <td>BKN</td>\n", " <td>0.333</td>\n", " <td>0.273</td>\n", " <td>22</td>\n", " <td>44</td>\n", " </tr>\n", " <tr>\n", " <th>579</th>\n", " <td>2015-16</td>\n", " <td>MIN</td>\n", " <td>0.354</td>\n", " <td>0.341</td>\n", " <td>29</td>\n", " <td>53</td>\n", " </tr>\n", " </tbody>\n", "</table>\n", "</div>" ], "text/plain": [ " season team win_percentage home_win_percentage wins losses\n", "14 1996-97 MIA 0.744 0.707 61 21\n", "162 2001-02 NOP 0.537 0.512 44 38\n", "272 2005-06 HOU 0.415 0.366 34 48\n", "300 2006-07 DET 0.646 0.634 53 29\n", "343 2007-08 ORL 0.634 0.610 52 30\n", "369 2008-09 MIN 0.293 0.268 24 58\n", "384 2009-10 BOS 0.610 0.585 50 32\n", "404 2009-10 PHI 0.329 0.293 27 55\n", "437 2010-11 SAC 0.293 0.268 24 58\n", "443 2011-12 BKN 0.333 0.273 22 44\n", "579 2015-16 MIN 0.354 0.341 29 53" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "wl.loc[\n", " wl['win_percentage'] > wl['home_win_percentage'],\n", " ['season', 'team', 'win_percentage', 'home_win_percentage', 'wins', 'losses']\n", "]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Conclusion\n", "\n", "There is clearly a strong association between a team's home win percentage and the team's overall win percentage. The 10% extra home win probability rule of thumb is reasonable for an average team. However, there is a lot of variation around the averages.\n", "\n", "Moving along the horizontal line, we see that a team with an average win percentage could have anywhere from a below-average (50%) to a good (70%) home win percentage.\n", "\n", "Similarly, moving along the dashed vertical line, we see that a team with a below-average 50% home win percentage could either have an average season (50% overall) or a very poor season." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python [conda env:sports_py36]", "language": "python", "name": "conda-env-sports_py36-py" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.4" } }, "nbformat": 4, "nbformat_minor": 2 }