Unlocking the Winning Formula: Sports Analytics with Python and ArcticDB

How many wins should a team expect given the number of points (or runs or goals) it scores and allows/concedes over the course of a season? That number provides a natural benchmark for the team’s actual record. Did it outperform or underperform its capabilities? Did the team’s manager do a good or bad job of in-game decision-making?

Bill James' groundbreaking work in Major League Baseball during the 1980s was one of the first to link points scored and allowed to a team's expected wins and losses:

where W is the number of team wins over the course of a season, L is the number of losses, PS is points scored by the offense and PA is points allowed by the defense.

Because James found λ = 2 reasonable in describing baseball, the formula has been nicknamed the ‘Pythagorean’ Won-Loss Formula. Note that if PS = PA, the team would be expected to win half of its games for a ‘0.500’ record. For example, the 2020–2021 NBA Champion Milwaukee Bucks scored 8,649 points and yielded 8,225 to its opponents during the regular season. For NBA teams, we estimate λ ≈ 14.3 (more on where we get this value later).

The Bucks’ actual winning percentage was only 63.9% in the regular season (= 46 wins / 72 games). So, they underperformed their capabilities at least by this measure. This might also explain their playoff success, where they likely played closer to their ‘true’ level of talent.

Equation (1) is central to much of the ‘Moneyball’ revolution in sports. Jonah Hill’s character in the 2011 movie Moneyball references the equation in one scene while discussing with Brad Pitt’s character how they will build their team in the upcoming season after losing most of their best players. The equation’s first derivative can be used to calculate an individual player’s marginal added value, commonly referred to as Wins Above Replacement (WAR) or Value Over Replacement Player (VORP). These metrics are now widely used for player valuation across several sports. Conceptually, a replacement player is modeled as a below average, fringe player who is readily available to a team at the league minimum wage. WAR and VORP-like metrics serve as standardized estimates of player’s ‘alpha,’ allowing comparisons across players and teams.

We can see λ’s importance in these marginal added value calculations. Taking the first derivative of (1) with respect to PS and using an average team to provide a common baseline (i.e., a team that scores as many points as it allows at a rate equal to the league average scoring rate per game: ), the marginal wins per point function is:

Once we have a reasonable estimate of λ, marginal wins per point (or run or goal) can be computed for any sport. To make this more concrete, let’s take the case of Aaron Judge, an outfielder for Major League Baseball’s (MLB) New York Yankees, who made $40 million in salary for the 2024 season. Did he earn it? Purposely handwaving over most or all of the details, we use data from Fangraphs.com, which publishes one of the widely referenced WAR values for baseball. According to the site, Judge’s offensive and defensive contributions added 108.5 runs above a replacement player during the season. How many wins over the full 162-game season would those runs be worth to an average team?

Using (2), plugging in our estimate of λ ≈ 1.8 for MLB (again more on this later), and an average of 4.39 runs per game for the 2024 season, our wins-per-run estimate is about 0.103, which is consistent with Fangraph’s calculations. Flipping the relationship, we can say that 9 to10 runs over the season are worth about one win in baseball. Multiplying through, Judge added about 11.2 wins (= 108.5 runs x 0.103 wins per run) during the season. And finally, Fangraphs estimates that a win in baseball is worth about $8 million based on free agency market transactions, implying Judge created $88–$89 million in value in 2024 which was significantly higher than his $40 million salary.

Our purpose here

So why write more on this well-covered equation that is now central to professional sports (other than highlighting how cool ArcticDB is of course[GT1] )? Most studies of James’ formula we have read have been written in isolation, focusing on individual sports.

As a result, λ often feels somewhat arbitrary to us or, at best, not well-understood other than each sport has its own specific value that makes the James model ‘work’.

James’ derivation of (1) was largely empirically driven. Miller (2006/7) provides theoretical support by showing that (1) gives the closed-form probability that PS > PA (i.e., the probability that a team wins a game) assuming, among other things, that points scored and allowed are independent random variables following continuous Weibull distributions with means equal to PS and PA, respectively, and both share a shape parameter = λ.

The Weibull distribution, like the lognormal distribution commonly used in finance to model stock returns, provides a reasonable representation for positive-valued, random variables which is the case for the sports analyzed here (e.g., we don’t study golf).

Our purpose here is to examine several sports simultaneously to provide some intuition about what the λ coefficient is capturing. We will show that the coefficient functions as a kind of exchange rate or scaling factor that translates the mean and standard deviation of the scoring distribution in each sport into the expected win probability. λ is approximately linear in each sport’s Information Ratio (IR). In finance, IR (and its cousin the Sharpe Ratio) describes the ratio of an asset’s return to its risk. In sports, we define it as the mean points (or runs or goals) scored per game divided by the standard deviation of points scored per game.

For example, using all the available history we collected for the English Premier League (EPL) and the NBA, we compute IRs of:

Which sports? What data?

After scouring the internet for several months during the Covid-19 pandemic, we collected game-level scoring data for nine sports drawn from across the globe, covering seasons as far back as the 19^th century and through the last pre-Covid-19 year of 2019 (data details can be found in Appendix A):

• Aussie Rules Football – Australian Football League (AFL)

• Football – English Premier League (EPL)

• Twenty20 Cricket – Indian Premier League (IPL

• Lacrosse – NCAA Men’s Division I Lacrosse (LAX)

• Baseball – Major League Baseball (MLB)

• Basketball – National Basketball Association (NBA)

• American Football – National Football League (NFL)

• Ice Hockey – National Hockey League (NHL)

• Rugby – Super Rugby Pacific (SUP)

Using ArcticDB, we stored game-by-game results dating back as far as possible, recording key information for each game:

• League

• Date

• Team names (both teams)

• Points scored and points allowed

We list the mean, standard deviation, and IR for each league in the respective boxes in Figure 1, covering the 2010–2019 seasons. Scoring distributions vary across sports but are generally positively skewed. For example, sports like American football have distinct scoring clusters consistent with their respective scoring systems. The James model and our fitting procedure have proven robust across sports, so our findings here are not highly sensitive to an assumed distribution.

Figure 1. Points per game distributions by league, all games, 2010–2019 seasons

_{Source: Various (listed in appendix) as at January 2025 Key: Australian Football League (AFL), English Premier League (EPL), Indian Premier League (IPL), NCAA Men’s Division I Lacrosse (LAX), Major League Baseball (MLB), National Basketball Association (NBA), National Football League (NFL), National Hockey League (NHL), Super Rugby Pacific (SUP)}

Fitting the model

For our purposes, it will be easier to work in units of (log) odds, which affords fitting the James model through ordinary least squares (OLS).

With some rearranging of (1), taking the natural logarithm of both sides and setting up for a regression:

where the index i indicates a given team-season (e.g., Liverpool 2018–2019), ℓ_i is the log odds ratio, a is an intercept term, and ε_i the residual error for each team-season.

Building a regression with ArcticDB data

At this point, we want to run a regression in python using data from ArcticDB. To get a feel for the data, let’s look at all teams in all seasons of the English Premier League (EPL) from 1888–1889 to 2018-19 and the National Basketball Association (NBA) from 1946–1947 to 2018–2019.

To run this in python we first need to install ArcticDB and import the necessary libraries. Examples here are run with version 5.1.2.

%pip install arcticdb
import arcticdb as adb
adb.__version__
import numpy as np
import pandas as pd
import statsmodels.api as sm
import statsmodels.formula.api as smf
import seaborn as sns
import matplotlib.pyplot as plt
sns.set_theme()

Getting this data for yourself

We’ve collated data from various free sources in a .csv file and shown you how you can load this data into ArcticDB for analysis in Python. All sources are listed in Appendix D.

Loading and preparing the regression data

Next, let’s load and list out the league data we have. Each league is a separate dataframe (table) in ArcticDB. Details of how to load data from .csv into ArcticDB are in Appendix E.

arctic = adb.Arctic('lmdb://sports')
league_data = arctic.get_library('leagues')
leagues = league_data.list_symbols()
leagues
['AFL', 'NBA', 'LAX', 'SUP', 'NFL', 'NHL', 'MLB', 'IPL', 'EPL'] 

Each table for a league looks like this with both team names, PS (points scored), PA (points allowed), the game date, whether it was played at home or away, and whether it was won (1) or lost (0). The top and bottom five rows are displayed here.

Table 1: Extract showing top and tail of data for SUP Rugby data

Each observation for the regression includes the total number of points scored or allowed, as well as the mean ‘win’ value for each season and team. Let’s extract the relevant columns from ArcticDB and prepare the data. Here, we use the batch-read and lazy-dataframe features to rapidly retrieve all the league tables and concatenate into a single table.

lazy_dfs = league_data.read_batch(leagues, lazy=True)
df = adb.concat(lazy_dfs).collect().data[['LEAGUE', 'YEAR_ID', 'TEAM_ID', 'PS', 'PA', 'WI']]
df_team = df.groupby(['LEAGUE', 'YEAR_ID', 'TEAM_ID']).agg(PS=('PS', 'mean'),
                                                        PA=('PA', 'mean'),
                                                        WI=('WI', 'mean'),
                                                        nobs=('WI', 'count'))

df_team.round(2).head()

Per Equation (3), we calculate the log ratios and plot both EPL and NBA lines.

# prepare data for regression
df_reg = df_team.copy()
df_reg = df_reg.loc[(df_reg['PS']>0) & (df_reg['PA']>0) & \
                    (df_reg['WI']>0) & (df_reg['WI']<1)]
df_reg['lnWI']=np.log(df_reg['WI']/(1-df_reg['WI']))
df_reg['lnPSPA']=np.log(df_reg['PS']/df_reg['PA'])
df_reg = df_reg.reset_index()

# plot
NBA_and_EPL = df_reg[df_reg['LEAGUE'].isin(['NBA', 'EPL'])]
sns.lmplot(data=NBA_and_EPL,
           x='lnPSPA',
           y='lnWI',
           hue='LEAGUE',
           scatter_kws=dict(s=3),
           line_kws=dict(color="grey"),
           facet_kws=dict(legend_out=False),
           aspect=1.6)

See Figure 2, where each dot represents one team-season (e.g., Chicago Bulls 1995–1996). The slope of the regression line through the data points gives us the implied or fitted λ for each sport. Football (smallest λ) and basketball (largest λ) sit at the opposite extremes of the nine sports in our data.

Figure 2. Team-season plot: EPL (1888–1889 to 2018–2019) and NBA (1946–1947 to 2018–2019

_{Source: Various (listed in Appendix) as at January 2025Note: Number of team-season observations: EPL = 2,463 and NBA = 1,607. For consistency, the EPL datapoints assume ties are worth 1/2 of a win for the entire period, which was the case up until the 1980–1981 season when it was lowered to 1/3 of a win to encourage fewer ties. Source: James P. Curley engsoccerdata: English Soccer Data 1871–2019 (https://github.com/jalapic/engsoccerdata). fivethirtyeight NBA ELO data 1947–2019 (https://data.fivethirtyeight.com/). We use the EPL labeling loosely, since we combine EPL history with data from the top division of the English Football League prior to the EPL’s first season in 1992–1993.}

It’s useful to keep track of our results as we go, enabling us to revisit them if our methodology or input-data changes for any reason. In ArcticDB we can create a library (i.e. dataset) for this, and just write the resulting dataframe without requiring database administration.

analysis = arctic.get_library('analysis', create_if_missing=True)
analysis.write('regression_data', df_reg)

Results

Before discussing the regression results in detail, we can build some intuition about what we should find. Looking at the scatterplot in Figure 2, note the tight spread of dots along the X-axis for the NBA compared to the much wider spread for the EPL. The best and worst regular-season teams in NBA history exhibit a spread of just 25% in the log ratio of points scored to points allowed: +10% for the Golden State Warriors (2015–16) versus -15% for the Carlotte Bobcats (2011–12). In the modern era of the EPL, we observe a much larger spread of almost 300%: +137% for Manchester City (2017–18) versus -149% for Derby County (2007–08). Thus, the cross-sectional spread, or variation in the log ratio of PS to PA (i.e., the ‘X’ or independent variable in the regression) appears to be an important driver of λ.

As many of you will remember from your basic statistics classes, the slope coefficient in a single variable OLS regression can be decomposed into the ratio of the covariance between the Y and X variables and the variance of X. The ratio functions as a scaling factor that normalizes the different units of Y and X. So, the lower (or higher) the variation in X, the steeper (or flatter) the slope of the line will be. The opposite is true for the variation in Y.

For the moment, let’s assume full team parity within a sports league — each team is equally skilled and plays the same number of N games per season. All teams’ offenses and defenses draw from two independent points distributions: one for PS and one for PA, each with mean μ and variance σ². Also assume that the values drawn for PS and PA in each game perfectly determine its outcome (PS > PA = win; otherwise = loss). Since the expected values for PS and PA are the same, we would expect every team to have a 50% chance of winning any given game.

We show in Appendix B that, under these simplifying assumptions, λ is approximately linear in each sport’s IR. Equation (5a) clearly shows that both the number of games played in a season, and IR are inverse drivers of the dispersion in X in Figure 2. EPL teams play 38 games per season, while NBA teams play 82. As outlined in the next section, the EPL has the lowest IR among the sports in our sample, while the NBA has the highest, which is also consistent with the slopes for the two sports in the scatter plot.

Plugging (5a) and (5b) into (4) we get an approximation of λ:

where is a constant that depends on the underlying distributions of PS and PA.

Without assuming an actual underlying point distribution, it’s hard to say much more than that a sport’s IR is an important factor in determining λ, and the relationship between the two is approximately linear under our assumptions.

We are fitting across team-seasons in Equation (3), and some leagues may have a large dispersion or skew among their top and bottom teams. It’s unclear how each sport’s actual point distribution and team competitive imbalances will impact the OLS estimates of λ. We can allow the regression results sort these details.

Regression results for the James model

While we show all available data in Figure 2 for both the NBA and EPL, we operate in rolling 10-year windows, focusing most of our attention on the 2010–2019 seasons. Sports evolve over time, leading to varying estimates of λ. For example, the NBA introduced the 24-second shot clock in the 1954–1955 season to save fans from extreme boredom. In 1950, the Fort Wayne Pistons defeated the Minneapolis Lakers 19–18 in the lowest-scoring game in league history. Fitting the model over a decade of data feels about right as we balance having enough team-seasons to estimate the model and capturing the changing dynamics of each league.

Looking at the recent period first, we fit Equation (3) for each league by pooling all team-seasons from 2010– 2019 seasons.

We’ll use a utility function to perform the regression, so we can return the fit within a pandas apply method.

def ols_coef(df, xcol, ycol):
    """OLS function used for lambda calcs -- assumes univariate regression"""
    model=sm.OLS(df[ycol],sm.add_constant(df[xcol])).fit()
    outdf = pd.DataFrame({'adj.'     : model.params.iloc[0],
                          'adj. se'  : model.bse.iloc[0],
                          'λ'        : model.params.iloc[1],
                          'λ se'     : model.bse.iloc[1],
                          'nobs'     : model.nobs,
                          'adj. R^2$' : model.rsquared_adj}, index=[0])

    return outdf

Using the same prepared data above (df_reg), we filter for our selected decade and perform an OLS regression for each league.

df_ols = df_reg.loc[(df_reg['YEAR_ID']>=2010) & (df_reg['YEAR_ID']<=2019)]
cols=df_ols.groupby(['LEAGUE']).apply(ols_coef,xcol=['lnPSPA'],ycol=['lnWI'])
cols = ols.droplevel(1).sort_values(['λ']).reset_index().round(2)
cols

Let’s record the OLS results, just as we did with the regression data, into an ArcticDB library, for later analysis or sharing with colleagues. Since the library has already been created, we simply save the table.

analysis.write('ols', ols)
VersionedItem(symbol='ols', library='analysis', data=n/a, version=2, metadata=None
             , host='UMDB(path=sports)', timestamp=1738255232379464601)

The return value shows that the data is automatically versioned in ArcticDB and includes a timestamp for each version. This is extremely useful for tracking the fit changes when we make edits.

The λ estimates and errors are shown in Figure 3a. As we’ve noted, the EPL and NBA sit at the extremes. The model fits all sports well with statistically significant coefficients. The confidence bands around our estimate for the IPL is wider (also adjusted R² is 0.57 for the IPL compared to a range of 0.81 to 0.94 for the other leagues). For those that are interested, the poorer fit for the IPL we believe is due to the limited number of teams each season (8–10) and the truncated game effect in Twenty20 Cricket, discussed in Appendix A, which we can only partially adjust for.

Consistent with our back-of-the-envelope calculations, we observe a near linear relationship between λ and IR in Figure 3b, confirming IR as a central, endemic feature of each sport and clarifying the drivers of λ differences across sports. Finally, restricting our analysis to sports with deeper data histories (sorry no rugby, cricket, or lacrosse), we do see time varying behavior in the fitted coefficient for all sports, supporting our use of rolling window estimates (see Figure 3c). The balance between offense and defense evolves over time. Scoring in the NFL, for example, has been on a consistent uptrend since the league’s founding, while the NHL achieved peak scoring in the 1990s, which has recently begun to rebound. The impact of the 24-second shot clock is clearly evident in the early history of our NBA data.

Figure 3a. Estimates of λ by league, 2010–2019 season

_{Source: Various (listed in Appendix) as at January 2025. Key: Australian Football League (AFL), English Premier League (EPL), Indian Premier League (IPL), NCAA Men’s Division I Lacrosse (LAX), Major League Baseball (MLB), National Basketball Association (NBA), National Football League (NFL), National Hockey League (NHL), Super Rugby Pacific (SUP).}

_{Note: Error bars represent ±2 standard errors around the coefficient estimate. N is the number of team-seasons used to estimate the model.}

Figure 3b. Estimates of λ versus league information ratio, 2010–2019 seasons

Source: Various (listed in Appendix) as at January 2025. Key: Australian Football League (AFL), English Premier League (EPL), Indian Premier League (IPL), NCAA Men’s Division I Lacrosse (LAX), Major League Baseball (MLB), National Basketball Association (NBA), National Football League (NFL), National Hockey League (NHL), Super Rugby Pacific (SUP)

Figure 3c. Rolling 10-year estimates of λ, all available seasons through 2019

_{Source: Various (listed in Appendix) as at January 2025. Key: Australian Football League (AFL), English Premier League (EPL), Major League Baseball (MLB), National Basketball Association (NBA), National Football League (NFL), National Hockey League (NHL)}

_{Note: Shaded regions represent ±2 standard errors around the coefficient estimate.}

Parting thoughts

Hopefully, by looking across sports and time and with a little mathematics, we have provided some intuition behind James’ formula, which lies at the center of modern sports analysis. While the formula has empirical roots in just one sport, baseball, it has proven to be a robust model working across very different scoring distributions.

With ArcticDB we have successfully kept track of what we are doing with automatically versioned and shareable input and output data — all without any of the typical database operation overhead, such as creating tables or managing schemas. ArcticDB is also extremely fast; with the amount of data here (approx. 853,000 rows) the load times are imperceptible. Please check it out at https://github.com/man-group/ArcticDB/.

Appendix A – Data sources and notes

Australian Football League (AFL) – The league was known as the Victorian Football League (VFL) prior to 1990. Our first season of data is 1897. Source: https://afltables.com.

English Premier League (EPL) – We use the EPL labeling loosely since we combine EPL history with data from the top division of the English Football League prior to the EPL’s first season in 1992–1993. Our first season of data is 1888–1889, and we exclude the 1939–1940 partial season. Source: James P. Curley engsoccerdata: English Soccer Data 1871–2019 (https://github.com/jalapic/engsoccerdata).

Indian Premier League (IPL) – Our earliest data starts with the 2008 IPL inaugural season. Source: https://cricsheet.org/. In Twenty20 cricket, teams play just two innings, which can obfuscate the ‘true’ scoring capability of the team batting last and the ‘true’ run prevention skill of the team bowling last. Upon the batting team scoring one more run than its opponent in the last inning, the game is immediately halted. We partially adjust for this truncation effect by grossing up the second team’s runs by the remaining ‘resources’ left when the game ends. Remaining resources are estimated using the Duckworth–Lewis method which accounts for the number of overs left to be played and the number of wickets in hand by the bowling team. See Senevirathne and Manage, ‘Predicting the winning percentage of limited-overs cricket using the Pythagorean formula,’ Journal of Sports Analytics, vol. 7, no. 3, pp. 169–183, 2021 and Bhattacharya, Gill, and Swartz, ‘Duckworth–Lewis and Twenty20 cricket,’ Journal of the Operational Research Society, Volume 62, 2011 – Issue 11.

NCAA Men’s Division I Lacrosse (LAX) – This is the only non-professional league included in our sample. Our first season of data is 2010. Source: https://stats.ncaa.org/.

Major League Baseball (MLB) – The sport with the deepest history of data in our sample starting in 1871, We use the game-by-game data provided by fivethirtyeight.com, which notably excludes any games played in the Negro Leagues (1920 to late 1940s) and includes games played in the National Association (1871–1875). Source: fivethirtyeight MLB ELO data (https://data.fivethirtyeight.com/).

National Basketball Association (NBA) – Our data begins with the 1946–1947 season of the Basketball Association of America (BAA) and includes games played the American Basketball Association (ABA) from 1967–1968 to 1975–1976. Source: fivethirtyeight NBA ELO data (https://data.fivethirtyeight.com/).

National Football League (NFL) – Our data begins with the 1922 season and includes games played by the All-America Football Conference (AAFC) from 1946–1949 and the American Football League (AFL) from 1960–1969. Source: fivethirtyeight NFL ELO data (https://data.fivethirtyeight.com/).

National Hockey League (NHL) – While our data begins with the 1917–1918 season, the league was extremely concentrated with as a few as 3 and up to just 6 teams per year through the 1966–1967 season. After that season, the league expanded initially to 12 teams and then incrementally to a total of 31 teams by the 2019 season. Source: fivethirtyeight NHL ELO data (https://data.fivethirtyeight.com/).

Super Rugby Pacific (SUP) – Our data begins with the 1996 season. Source: pick & go’s Super Rugby Database (http://www.lassen.co.nz/s14tab.php).

Appendix B – λ is approximately linear in IR

All teams are equally skilled in the league and play N games each per season.

For each team i and game n, assume and are i.i.d. with mean and variance σ².

Expected points scored/allowed and wins for each team over the course of a full season of N games are straightforward:

The variance for points scored and allowed is simply the per-game variance multiplied by the number of games (remember all sampled points are assumed independent). The variance for wins can be taken from the well-known result for the variance of the sum of independent Bernoulli random variables. A Bernoulli random variable equals 1 with probability p and 0 with probability 1-p and has variance equal to p x [1-p], which in our case is 0.5 x 0.5 = 0.25.

The covariance between the difference in points scored and allowed and wins for any team-game is:

For any two i.i.d. variables, X and Y, with the same mean and variance. Then X-Y follows a symmetry distribution. Therefore, we can write:

where C > 0 is a constant that depends on the underlying distributions of PS and PA.

So,

Note by Cauchy–Schwarz inequality:

Which implies:

The covariance of points scored with wins for the entire season is simply the per game covariance times the number of games:

Of course, what we are interested in is the variance / standard deviations of the Y and X variables (4). We can derive a reasonable estimate for both by using a technique called the Delta Method, which relies on a Taylor series expansion centered around the variable’s mean to derive a linear function.

For variance:

For covariance:

Applying the variance estimate:

Applying the covariance estimate, taking advantage of symmetry due to our parity assumptions:

Author Names:

Greg Bond, Maxim Morozov for ArcticDB

Appendix D – Data Sources & Notes

Australian Football League (AFL) – The league was known as the Victorian Football League (VFL) prior to 1990. Our first season of data is 1897. Source: https://afltables.com.

English Premier League (EPL) – We use the EPL labeling loosely since we combine EPL history with data from the top division of the English Football League prior to the EPL’s first season in 1992-93. Our first season of data is 1888-89, and we exclude the 1939-40 partial season. Source: James P. Curley engsoccerdata: English Soccer Data 1871-2019 (https://github.com/jalapic/engsoccerdata).

Indian Premier League (IPL) – Our earliest data starts with the 2008 IPL inaugural season. Source: https://cricsheet.org/. In Twenty20 cricket, teams play just two innings, which can obfuscate the “true” scoring capability of the team batting last and the “true” run prevention skill of the team bowling last. Upon the batting team scoring one more run than its opponent in the last inning, the game is immediately halted. We partially adjust for this truncation effect by grossing up the second team’s runs by the remaining “resources” left when the game ends. Remaining resources are estimated using the Duckworth–Lewis method which accounts for the number of overs left to be played and the number of wickets in hand by the bowling team. See Senevirathne and Manage, “Predicting the winning percentage of limited-overs cricket using the Pythagorean formula,” Journal of Sports Analytics, vol. 7, no. 3, pp. 169-183, 2021 & Bhattacharya, Gill, and Swartz, “Duckworth–Lewis and Twenty20 cricket,” Journal of the Operational Research Society, Volume 62, 2011 - Issue 11.

NCAA Men’s Division I Lacrosse (LAX) – This is the only non-professional league included in our sample. Our first season of data is 2010. Source: https://stats.ncaa.org/.

Major League Baseball (MLB) – The sport with the deepest history of data in our sample starting in 1871, We use the game-by-game data provided by fivethirtyeight.com, which notably excludes any games played in the Negro Leagues (1920 to late 1940s) and includes games played in the National Association (1871-1875). Source: fivethirtyeight MLB ELO data (https://data.fivethirtyeight.com/).

National Basketball Association (NBA) – Our data begins with the 1946-1947 season of the Basketball Association of America (BAA) and includes games played the American Basketball Association (ABA) from 1967-68 to 1975-76. Source: fivethirtyeight NBA ELO data (https://data.fivethirtyeight.com/).

National Football League (NFL) – Our data begins with the 1922 season and includes games played by the All-America Football Conference (AAFC) from 1946-1949 and the American Football League (AFL) from 1960-1969. Source: fivethirtyeight NFL ELO data (https://data.fivethirtyeight.com/).

National Hockey League (NHL) – While our data begins with the 1917-18 season, the league was extremely concentrated with as a few as 3 and up to just 6 teams per year through the 1966-67 season. After that season, the league expanded initially to 12 and then incrementally to the 2019 season 31 team total. Source: fivethirtyeight NHL ELO data (https://data.fivethirtyeight.com/).

Super Rugby Pacific (SUP) – Our data begins with the 1996 season. Source: pick & go’s Super Rugby Database (http://www.lassen.co.nz/s14tab.php).

Appendix E

Preparing data for loading into ArcticDB. ArcticDB is a database solution that’s optimised for timeseries data for quantitative finance. In this example we show how to load data into ArcticDB.

import arcticdb as adb
import pandas as pd

df = pd.read_csv(dataFile)

df = df.drop(columns="Unnamed: 0")
df = df.rename(columns={'FREQ_RUNS_S': 'PS',
                        'FREQ_RUNS_A': 'PA' })

df = df.sort_values(['LEAGUE','YEAR_ID','TEAM_ID'])

arctic = adb.Arctic('lmdb://sports')
lib = arctic.get_library('leagues', create_if_missing=True)
for league in df['LEAGUE'].unique():
    lib.write(league, df[df['LEAGUE']==league])
lib.list_symbols()

['EPL', 'SUP', 'NHL', 'MLB', 'AFL', 'LAX', 'NBA', 'IPL', 'NFL']