NBA Player Statistics Workshop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NBA Player Statistics Workshop\n",
    "\n",
    "Given a dataset of NBA players performance and salary in 2014, use Python to load the dataset and compute the summary statistics for the `SALARY` field:\n",
    "\n",
    "- mean\n",
    "- median\n",
    "- mode\n",
    "- minimum\n",
    "- maximum\n",
    "\n",
    "You will need to make use of the csv module to load the data and interact with it. Computations should require only simple arithmetic. (For the purposes of this exercise, attempt to use pure Python and no third party dependencies like Pandas - you can then compare and contrast the use of Pandas for this task later). \n",
    "\n",
    "**Bonus:**\n",
    "\n",
    "Determine the relationship of PER (Player Efficiency Rating) to Salary via a visualization of the data.\n",
    "\n",
    "\n",
    "NBA 2014 Players Dataset: [http://bit.ly/gtnbads](http://bit.ly/gtnbads)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Imports - you'll need some of these later, but it's traditional to put them all at the beginning.\n",
    "\n",
    "import os\n",
    "import csv\n",
    "import json\n",
    "import urllib2\n",
    "\n",
    "from collections import Counter\n",
    "from operator import itemgetter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fetching the Data\n",
    "\n",
    "You have a couple of options of fetching the data set to begin your analysis:\n",
    "\n",
    "1. Click on the link above and Download the file. \n",
    "2. Write a Python function that automatically downloads the data as a comma-separated value file (CSV) and writes it to disk. \n",
    "\n",
    "In either case, you'll have to be cognizant of where the CSV file lands. Here is a quick implementation of a function to download a URL at a file and write it to disk. Note the many approaches to do this as outlined here: [How do I download a file over HTTP using Python?](http://stackoverflow.com/questions/22676/how-do-i-download-a-file-over-http-using-python). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def download(url, path):\n",
    "    \"\"\"\n",
    "    Downloads a URL and writes it to the specified path. The \"path\" \n",
    "    is like the mailing address for the file - it tells the function \n",
    "    where on your computer to send it!\n",
    "    \n",
    "    Also note the use of \"with\" to automatically close files - this \n",
    "    is a good standard practice to follow.\n",
    "    \"\"\"\n",
    "    response = urllib2.urlopen(url)\n",
    "    with open(path, 'w') as f:\n",
    "        f.write(response.read())\n",
    "    \n",
    "    response.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Your turn: use the above function to download the data!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## Write the Python to execute the function and download the file here:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the Data\n",
    "\n",
    "Now that we have the CSV file that we're looking for, we need to be able to open the file and read it into memory. The trick is that we want to read only a single line at a time - consider really large CSV files. Python provides memory efficient iteration in the form of `generators` and the `csv.reader` module exposes one such generator, that reads the data from the CSV one row at a time. Moreover, we also want to parse our data so that we have specific access to the fields we're looking for. The `csv.DictReader` class will give you each row as a dictionary, where the keys are derived from the first, header line of the file. \n",
    "\n",
    "Here is a function that reads data from disk one line at a time and `yield`s it to the user. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def read_csv(path):\n",
    "    # First open the file\n",
    "    with open(path, 'r') as f:\n",
    "        # Create a DictReader to parse the CSV\n",
    "        reader = csv.DictReader(f)\n",
    "        for row in reader:\n",
    "            # HINT: Convert SALARY column values into integers & PER column into floats.\n",
    "            # Otherwise CSVs can turn ints into strs! You'll thank me later :D\n",
    "            row['SALARY'] = int(row['SALARY'])\n",
    "            row['PER'] = float(row['PER'])\n",
    "            # Now yield each row one at a time.\n",
    "            yield row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Your turn: use the above function to open the file and print out the first row of the CSV!**\n",
    "\n",
    "To do this, you'll need to do three things:\n",
    "\n",
    "First, remember where you told the `download` function to store your file? Pass that same path into `read_csv`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Write the Python to execute our read_csv function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next step: The `read_csv` function \"returns\" a generator. How can we access just the first row? Remember [how to access the next row of a generator](http://stackoverflow.com/questions/4741243/how-to-pick-just-one-item-from-a-generator-in-python)? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Now write the Python to print the first row of the CSV here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Are there different ways to print the first _n_ rows of something? Sure! Try using `break`, which will stop a `for` loop from running. E.g. the code:\n",
    "\n",
    "```python\n",
    "for idx in xrange(100):\n",
    "    if idx > 10:\n",
    "        break\n",
    "```\n",
    "\n",
    "...will stop the for loop after 10 iterations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, write a `for` loop that can access and print every row. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## Write the Python to print *every* row of the CSV here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary Statistics\n",
    "\n",
    "In this section, you'll use the CSV data to write computations for mean, median, mode, minimum, and maximum. Use Python to access the values in the `SALARY` column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data = list(read_csv('fixtures/nba_players.csv')) #Put in your own path here.\n",
    "data  = sorted(data, key=itemgetter('SALARY'))\n",
    "\n",
    "total = 0\n",
    "count = 0\n",
    "\n",
    "for row in data:\n",
    "        count += 1\n",
    "        total += row['SALARY']\n",
    "\n",
    "# Total Count\n",
    "print \"There are %d total players.\" % count\n",
    "\n",
    "# Write the Python to get the median\n",
    "median = \n",
    "print \"The median salary is %d.\" % median\n",
    "\n",
    "# Write the Python to get the minimum\n",
    "minimum = \n",
    "print \"The minimum salary is %d.\" % minimum\n",
    "\n",
    "# Write the Python to get the maximum\n",
    "maximum = \n",
    "print \"The maximum salary is %d.\" % maximum\n",
    "\n",
    "# Write the Python to get the mean\n",
    "mean = \n",
    "print \"The mean salary is %d.\" % mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nice work! Now... calculating the mode is a bit different. Remember about the [Decorate-Sort-Undecorate](http://www.greenteapress.com/thinkpython/html/thinkpython013.html) pattern that we learned about in ThinkPython? That will work here!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Write the Python to get the mode of the salaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \"DSU\" approach is a little inefficient. Instead of using a dictionary as our data type to solve the mode problem, we could use counter() from the Collections module. [Read more about counter()](https://pymotw.com/2/collections/counter.html) and try it out here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Experiment with using counter() here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Putting the pieces together\n",
    "\n",
    "The above summary statistics can actually be computed inside of a single (and elegant!) function. Give it a try!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "    \"minimum\": null, \n",
      "    \"median\": null, \n",
      "    \"mode\": null, \n",
      "    \"maximum\": null, \n",
      "    \"mean\": null\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "def statistics(path):\n",
    "    \"\"\"\n",
    "    Takes as input a path to `read_csv` and the field to\n",
    "    compute the summary statistics upon.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Uncomment below to load the CSV into a list\n",
    "    # data = list(read_csv(path))\n",
    "    \n",
    "    # Fill in the function here\n",
    "\n",
    "\n",
    "    stats = {\n",
    "        'maximum': data[-1]['SALARY'],\n",
    "        'minimum': data[0]['SALARY'],\n",
    "        'median': data[count / 2]['SALARY'], # Any potential problems here?\n",
    "        'mode': freqs.most_common(2),\n",
    "        'mean': total / count,\n",
    "    }\n",
    "\n",
    "    return stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keep playing with the above function to get it to work more efficiently or to reduce bad data in the computation - e.g. what are all those zero salaries? \n",
    "\n",
    "\n",
    "## Visualization\n",
    "\n",
    "\n",
    "Congratulations if you've made it this far! It's time for the bonus round!\n",
    "\n",
    "You've now had some summary statistics about the salaries of NBA players, but what we're really interested in is the relationship between `SALARY` and the rest of the fields in the data set. The `PER` - Player Efficiency Rating, is an aggregate score of all performance statistics; therefore if we determine the relationship of `PER` to `SALARY`, we might learn a lot about how to model NBA salaries. \n",
    "\n",
    "In order to explore this, let's create a scatter plot of `SALARY` to `PER`, where each point is an NBA player.\n",
    "\n",
    "Visualization is going to require a third party library. You probably already have matplotlib, so that might be the simplest if you're having trouble with installation. If you don't, `pip install` it now! Follow the documentation to create the scatter plot inline in the notebook in the following cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Insert your Python to create the visualization here\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline  # Makes the plot appear inline in your iPython Notebook.\n",
    "\n",
    "def read_data(path):\n",
    "    # Pandas is an efficient way to wrangle the data quickly\n",
    "    return pd.DataFrame(pd.read_csv(path))\n",
    "\n",
    "def graph_data(path, xkey='PER', ykey='SALARY'):\n",
    "    data = read_data(path)\n",
    "    ## Fill this in yourself!\n",
    "    plt.show()\n",
    "\n",
    "graph_data('fixtures/nba_players.csv') # Or whatever your path is"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nice work!! Matplotlib is pretty useful, but also kind of bare bones. Once you're ready to experiment with other libraries and take your visualizations to the next level, check out the following:\n",
    "\n",
    "- Seaborn\n",
    "- Bokeh\n",
    "- Pandas\n",
    "\n",
    "Our favorite is Bokeh - it's interactive!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}