SVM_NBA_Matthew_S.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World, testing out jupyter notebook!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World, testing out jupyter notebook!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3. 4. 5.]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1,2,3,4,5], dtype=float)\n",
    "print(x)\n",
    "# first numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3. 4. 5.]\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 4. 24.  5. 43. 68.]\n"
     ]
    }
   ],
   "source": [
    "p = np.array([4, 24, 5, 43, 68], dtype=float)\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 20. 120.  25. 215. 340.]\n"
     ]
    }
   ],
   "source": [
    "print(5*p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 5 * p\n",
    "# testing out operations with numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 20., 120.,  25., 215., 340.])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 20. 120.  25. 215. 340.]\n"
     ]
    }
   ],
   "source": [
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True,  True])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z > 10\n",
    "# returns array with booleans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False,  True,  True])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z > 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([120., 215., 340.])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z[z>30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "print(np.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4.32192809, 6.9068906 , 4.64385619, 7.74819285, 8.40939094])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log2(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.30103   , 2.07918125, 1.39794001, 2.33243846, 2.53147892])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log10(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Experimenting with too much log....\n"
     ]
    }
   ],
   "source": [
    "print(\"Experimenting with too much log....\")\n",
    "#np.log120(z)\n",
    "# this caused an error\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# higher log values does not exist with numpy\n",
    "a = pd.Series([1, 2, 3, 4, 5, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "1    2\n",
       "2    3\n",
       "3    4\n",
       "4    5\n",
       "5    6\n",
       "dtype: int64"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(a.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RangeIndex(start=0, stop=6, step=1)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RangeIndex(start=0, stop=6, step=1)\n"
     ]
    }
   ],
   "source": [
    "print(a.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anthony Davis      28\n",
      "James Harden       30\n",
      "LeBron James       27\n",
      "Damian Lilliard    28\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "players = pd.Series([28, 30, 27, 28], index=[\"Anthony Davis\", \"James Harden\", \"LeBron James\", \"Damian Lilliard\"])\n",
    "print(players)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "James Harden    30\n",
       "dtype: int64"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "players[players> 28]\n",
    "# the games leading scorer and 'MVP'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "topscore = list(players.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[28, 30, 27, 28]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "topscore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "print(max(topscore))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n"
     ]
    }
   ],
   "source": [
    "print(min(topscore))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Anthony Davis\" in players"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Bob Simmons\" in players"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"LeBron James\" in players\n",
    "# more testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anthony Davis      28\n",
      "James Harden       30\n",
      "LeBron James       27\n",
      "Damian Lilliard    28\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "players = pd.Series([28, 30, 27, 28], index=[\"Anthony Davis\", \"James Harden\", \"LeBron James\", \"Damian Lilliard\"])\n",
    "print(players)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"LeBron James\" in players"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "James Harden    30\n",
       "dtype: int64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "players[players > 28]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Anthony Davis      28\n",
       "James Harden       30\n",
       "Damian Lilliard    28\n",
       "dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "players[players > 27]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "elDict = {'players':[\"Matthew Strong\", \"\"]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'players': ['Matthew Strong', '']}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "elDict = {'players':[\"Matthew Strong\", \"LeBron James\", \"Joel Embiid\", \"Michael Jordan\"], 'PPG':[1, 27, 20, 30], 'Team':[\"Baby Bobby Ballers\", \"Los Angeles Lakers\", \"Philadelphia 76ers\"]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'PPG': [1, 27, 20, 30],\n",
       " 'Team': ['Baby Bobby Ballers', 'Los Angeles Lakers', 'Philadelphia 76ers'],\n",
       " 'players': ['Matthew Strong',\n",
       "  'LeBron James',\n",
       "  'Joel Embiid',\n",
       "  'Michael Jordan']}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [],
   "source": [
    "#data = pd.DataFrame(elDict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "elDict = {'players':[\"Matthew Strong\", \"LeBron James\", \"Joel Embiid\", \"Michael Jordan\"], 'PPG':[1, 27, 20, 30], 'Team':[\"Baby Bobby Ballers\", \"Los Angeles Lakers\", \"Philadelphia 76ers\", \"Chicago Bulls\"]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'PPG': [1, 27, 20, 30],\n",
       " 'Team': ['Baby Bobby Ballers',\n",
       "  'Los Angeles Lakers',\n",
       "  'Philadelphia 76ers',\n",
       "  'Chicago Bulls'],\n",
       " 'players': ['Matthew Strong',\n",
       "  'LeBron James',\n",
       "  'Joel Embiid',\n",
       "  'Michael Jordan']}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataNBA = pd.DataFrame(elDict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>PPG</th>\n",
       "      <th>Team</th>\n",
       "      <th>players</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Baby Bobby Ballers</td>\n",
       "      <td>Matthew Strong</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>27</td>\n",
       "      <td>Los Angeles Lakers</td>\n",
       "      <td>LeBron James</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>20</td>\n",
       "      <td>Philadelphia 76ers</td>\n",
       "      <td>Joel Embiid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>30</td>\n",
       "      <td>Chicago Bulls</td>\n",
       "      <td>Michael Jordan</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   PPG                Team         players\n",
       "0    1  Baby Bobby Ballers  Matthew Strong\n",
       "1   27  Los Angeles Lakers    LeBron James\n",
       "2   20  Philadelphia 76ers     Joel Embiid\n",
       "3   30       Chicago Bulls  Michael Jordan"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   PPG                Team         players\n",
      "0    1  Baby Bobby Ballers  Matthew Strong\n",
      "1   27  Los Angeles Lakers    LeBron James\n",
      "2   20  Philadelphia 76ers     Joel Embiid\n",
      "3   30       Chicago Bulls  Michael Jordan\n"
     ]
    }
   ],
   "source": [
    "print(dataNBA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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>PPG</th>\n",
       "      <th>Team</th>\n",
       "      <th>players</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Baby Bobby Ballers</td>\n",
       "      <td>Matthew Strong</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>27</td>\n",
       "      <td>Los Angeles Lakers</td>\n",
       "      <td>LeBron James</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>20</td>\n",
       "      <td>Philadelphia 76ers</td>\n",
       "      <td>Joel Embiid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>30</td>\n",
       "      <td>Chicago Bulls</td>\n",
       "      <td>Michael Jordan</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   PPG                Team         players\n",
       "0    1  Baby Bobby Ballers  Matthew Strong\n",
       "1   27  Los Angeles Lakers    LeBron James\n",
       "2   20  Philadelphia 76ers     Joel Embiid\n",
       "3   30       Chicago Bulls  Michael Jordan"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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>PPG</th>\n",
       "      <th>Team</th>\n",
       "      <th>players</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Baby Bobby Ballers</td>\n",
       "      <td>Matthew Strong</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>27</td>\n",
       "      <td>Los Angeles Lakers</td>\n",
       "      <td>LeBron James</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   PPG                Team         players\n",
       "0    1  Baby Bobby Ballers  Matthew Strong\n",
       "1   27  Los Angeles Lakers    LeBron James"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "metadata": {},
   "outputs": [],
   "source": [
    "# (deleted)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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>PPG</th>\n",
       "      <th>Team</th>\n",
       "      <th>players</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>30</td>\n",
       "      <td>Chicago Bulls</td>\n",
       "      <td>Michael Jordan</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>27</td>\n",
       "      <td>Los Angeles Lakers</td>\n",
       "      <td>LeBron James</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>20</td>\n",
       "      <td>Philadelphia 76ers</td>\n",
       "      <td>Joel Embiid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Baby Bobby Ballers</td>\n",
       "      <td>Matthew Strong</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   PPG                Team         players\n",
       "3   30       Chicago Bulls  Michael Jordan\n",
       "1   27  Los Angeles Lakers    LeBron James\n",
       "2   20  Philadelphia 76ers     Joel Embiid\n",
       "0    1  Baby Bobby Ballers  Matthew Strong"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "playersSorted = dataNBA.sort_values(by=\"PPG\", ascending=False)\n",
    "playersSorted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1     True\n",
       "2    False\n",
       "3     True\n",
       "Name: PPG, dtype: bool"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA[\"PPG\"] > 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1     True\n",
       "2     True\n",
       "3     True\n",
       "Name: PPG, dtype: bool"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA[\"PPG\"] > 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = pd.Series(dataNBA[\"PPG\"] > 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1     True\n",
       "2     True\n",
       "3     True\n",
       "Name: PPG, dtype: bool"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pandas.core.groupby.DataFrameGroupBy object at 0x000002B626818EB8>"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA.groupby(\"PPG\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pandas.core.groupby.DataFrameGroupBy object at 0x000002B622A0BB00>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA.groupby(\"PPG\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<pandas.core.groupby.DataFrameGroupBy object at 0x000002B622F6A5F8>\n"
     ]
    }
   ],
   "source": [
    "print(dataNBA.groupby(\"PPG\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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>PPG</th>\n",
       "      <th>Team</th>\n",
       "      <th>players</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Baby Bobby Ballers</td>\n",
       "      <td>Matthew Strong</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>27</td>\n",
       "      <td>Los Angeles Lakers</td>\n",
       "      <td>LeBron James</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>20</td>\n",
       "      <td>Philadelphia 76ers</td>\n",
       "      <td>Joel Embiid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>30</td>\n",
       "      <td>Chicago Bulls</td>\n",
       "      <td>Michael Jordan</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   PPG                Team         players\n",
       "0    1  Baby Bobby Ballers  Matthew Strong\n",
       "1   27  Los Angeles Lakers    LeBron James\n",
       "2   20  Philadelphia 76ers     Joel Embiid\n",
       "3   30       Chicago Bulls  Michael Jordan"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     1\n",
       "1    27\n",
       "2    20\n",
       "3    30\n",
       "Name: PPG, dtype: int64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA[\"PPG\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     2\n",
       "1    28\n",
       "2    21\n",
       "3    31\n",
       "Name: PPG, dtype: int64"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA[\"PPG\"].apply(lambda x: x +1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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>PPG</th>\n",
       "      <th>Team</th>\n",
       "      <th>players</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Baby Bobby Ballers</td>\n",
       "      <td>Matthew Strong</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>27</td>\n",
       "      <td>Los Angeles Lakers</td>\n",
       "      <td>LeBron James</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>20</td>\n",
       "      <td>Philadelphia 76ers</td>\n",
       "      <td>Joel Embiid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>30</td>\n",
       "      <td>Chicago Bulls</td>\n",
       "      <td>Michael Jordan</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   PPG                Team         players\n",
       "0    1  Baby Bobby Ballers  Matthew Strong\n",
       "1   27  Los Angeles Lakers    LeBron James\n",
       "2   20  Philadelphia 76ers     Joel Embiid\n",
       "3   30       Chicago Bulls  Michael Jordan"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     1\n",
       "1    27\n",
       "2    20\n",
       "3    30\n",
       "Name: PPG, dtype: int64"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA[\"PPG\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataNBA[\"PPG\"] = dataNBA[\"PPG\"].apply(lambda x: x +1)\n",
    "# testing lamba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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>PPG</th>\n",
       "      <th>Team</th>\n",
       "      <th>players</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>Baby Bobby Ballers</td>\n",
       "      <td>Matthew Strong</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>28</td>\n",
       "      <td>Los Angeles Lakers</td>\n",
       "      <td>LeBron James</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>21</td>\n",
       "      <td>Philadelphia 76ers</td>\n",
       "      <td>Joel Embiid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>31</td>\n",
       "      <td>Chicago Bulls</td>\n",
       "      <td>Michael Jordan</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   PPG                Team         players\n",
       "0    2  Baby Bobby Ballers  Matthew Strong\n",
       "1   28  Los Angeles Lakers    LeBron James\n",
       "2   21  Philadelphia 76ers     Joel Embiid\n",
       "3   31       Chicago Bulls  Michael Jordan"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataNBA "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import svm\n",
    "# moving on to svm "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = [[0,0], [2,2]]\n",
    "y=[2.5, 4.5]\n",
    "client = svm.SVR()\n",
    "# support vector regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVR(C=1.0, cache_size=200, coef0=0.0, degree=3, epsilon=0.1, gamma='auto',\n",
       "  kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.fit(X,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "More testing on the way....\n"
     ]
    }
   ],
   "source": [
    "print(\"More testing on the way....\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.5])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.predict([[1,1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.50011314])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.predict([[5,5]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4.4])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.predict([[2,2]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "vo = np.array([1, 2, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 4])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vo\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 4]\n"
     ]
    }
   ],
   "source": [
    "print(vo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "print([1, 2, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [],
   "source": [
    "clr = svm.SVR()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = [[0,0], [2,2], [3,3]]\n",
    "y=[2.5, 4.5]\n",
    "client = svm.SVR()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVR(C=1.0, cache_size=200, coef0=0.0, degree=3, epsilon=0.1, gamma='auto',\n",
       "  kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)"
      ]
     },
     "execution_count": 269,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X=[[0,0], [1,1], [2,2]]\n",
    "y=[3.5,7.5, 9.7]\n",
    "client = svm.SVR()\n",
    "client.fit(X,y)\n",
    "#print(\"{} and {}\".format(X,y))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7.86775603])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.predict([[3,3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi\n"
     ]
    }
   ],
   "source": [
    "print(\"Hi\")\n",
    "# ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVR(C=1.0, cache_size=200, coef0=0.0, degree=3, epsilon=0.1, gamma='auto',\n",
       "  kernel='linear', max_iter=-1, shrinking=True, tol=0.001, verbose=False)"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# some simple linear regression here \n",
    "normLinear = svm.SVR(kernel=\"linear\")\n",
    "X=[[0,0], [1,1], [2,2]]\n",
    "y=[3.5,7.5, 11.5]\n",
    "normLinear.fit(X,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([13.35])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "normLinear.predict([[2.5,2.5]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import requests\n",
    "# testing json and requests here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "response = requests.get(\"https://jsonplaceholder.typicode.com/todos\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Response [200]>\n"
     ]
    }
   ],
   "source": [
    "print(response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(\"{} is the text of the response.\".format(response.text))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "todos = json.loads(response.text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\n"
     ]
    }
   ],
   "source": [
    "print(\"hi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "todos[0]['completed']\n",
    "# everything is put into dictionaries!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([[72, 200], [70, 180], [69, 179], [80, 250], [84, 300], [81, 270]])\n",
    "y = np.array([\"Point Guard\", \"Point Guard\", \"Point Guard\", \"Center\", \"Center\", \"Center\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n",
       "  decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',\n",
       "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
       "  tol=0.001, verbose=False)"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf = svm.SVC()\n",
    "clf.fit(x, y) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Center'], dtype='<U11')"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.predict([[82,190]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "newRep = requests.get(\"http://data.nba.net/10s/prod/v1/2018/players.json\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "print(newRep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# print(newRep.text) ... would have printed out all of the the nba players, uncommenting and run this section to see the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "allPlayers = json.loads(newRep.text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "metadata": {},
   "outputs": [],
   "source": [
    "#allPlayers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(allPlayers['league']['standard'])\n",
    "# looking at all of the players"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we want to choose between G F and C\n",
    "x = np.array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 1 1 1 1]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "x = np.append(x,[[1]])\n",
    "print(x)\n",
    "y = np.array([])\n",
    "print(y)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 339,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[190  78]\n",
      " [240  79]\n",
      " [190  74]\n",
      " ...\n",
      " [250  84]\n",
      " [250  83]\n",
      " [240  85]]\n",
      "SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n",
      "  decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',\n",
      "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
      "  tol=0.001, verbose=False)\n",
      "SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n",
      "  decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',\n",
      "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
      "  tol=0.001, verbose=False)\n",
      "1096\n",
      "548\n"
     ]
    }
   ],
   "source": [
    "playerSize = np.array([[0,0]])\n",
    "playerPosition = np.array([])\n",
    "testing = np.array([])\n",
    "for i in allPlayers['league']['standard']:\n",
    "    skip = False\n",
    "    if(i['weightPounds'] == '' or i['heightFeet']=='' or i['heightInches']==''):\n",
    "        skip = True\n",
    "    if(not skip):\n",
    "        totalHeight = (int(i['heightFeet'])*12) + int(i['heightInches'])\n",
    "        #fullName = i['firstName'] + ' ' + i['lastName']\n",
    "        #print('{} is {} inches tall.'.format(fullName, totalHeight))\n",
    "        #print([int(i['weightPounds']), totalHeight])\n",
    "        arr = np.array([[int(i['weightPounds']), totalHeight]])\n",
    "        xEr = np.array([int(i['weightPounds']), totalHeight])\n",
    "        #print(arr)\n",
    "        #print(i['pos'])\n",
    "        #print(playerSize)\n",
    "        playerSize = np.concatenate((playerSize, arr))\n",
    "        testing = np.append(testing, xEr)\n",
    "        #playerSize = np.append(playerSize, [int(i['weightPounds']), totalHeight])\n",
    "        playerPosition = np.append(playerPosition, i['pos'])\n",
    "\n",
    "#realPlayerSize = playerSize[playerSize!=[0,0]]\n",
    "y = np.expand_dims(playerSize, axis=1)\n",
    "\n",
    "realPlayers = playerSize[1:]\n",
    "print(realPlayers)\n",
    "\n",
    "clf = svm.SVC()\n",
    "\n",
    "clf.fit(realPlayers, playerPosition)\n",
    "#print(clf)\n",
    "print(clf)\n",
    "clf.predict([[260, 82]])\n",
    "clf.score([[260, 82], [250, 80]], ['C', 'C'])\n",
    "#a simple test of the svm SVC instance to see some basic comparisons of my code with actual desired goals\n",
    "import matplotlib.pyplot as plt\n",
    "print(testing.size)\n",
    "print(playerPosition.size)\n",
    "\n",
    "# testing out the functions and running a simple test for the SVC AFTER we have fed it the data of all of the NBA players currently.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your weight in pounds? 260\n",
      "What is your height? Enter feet first. 7\n",
      "What is your height? Now enter inches. 1\n",
      "Based on the Stats of ALL of the NBA Players, and your height and weight, you should be a Center.\n"
     ]
    }
   ],
   "source": [
    "# final version\n",
    "\n",
    "import json\n",
    "import requests\n",
    "from sklearn import svm\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "# Matthew Strong CU Boulder\n",
    "# July 21 2018\n",
    "# NBA Data API used \n",
    "# uses SVC machine learning to predict the best position for a person who wants to see if they have 'NBA' level height and weight\n",
    "# indeed the average height of a man would be very low for this function\n",
    "\n",
    "\n",
    "def predictPosition():\n",
    "    \n",
    "    newRep = requests.get(\"http://data.nba.net/10s/prod/v1/2018/players.json\")\n",
    "    allPlayers = json.loads(newRep.text)\n",
    "    # loading all of the players into python dictionary with the data nba api\n",
    "    playerSize = np.array([[0,0]])\n",
    "    # setting the numpu arrays\n",
    "    playerPosition = np.array([])\n",
    "    for i in allPlayers['league']['standard']:\n",
    "        skip = False\n",
    "        if(i['weightPounds'] == '' or i['heightFeet']=='' or i['heightInches']==''):\n",
    "            skip = True\n",
    "            # if a weight or height aspect of the player is visibly missing, skip the player\n",
    "        if(not skip):\n",
    "            # calculates total height\n",
    "            totalHeight = (int(i['heightFeet'])*12) + int(i['heightInches'])\n",
    "            #fullName = i['firstName'] + ' ' + i['lastName']\n",
    "            #print('{} is {} inches tall.'.format(fullName, totalHeight))\n",
    "            #print([int(i['weightPounds']), totalHeight])\n",
    "            \n",
    "            # array of the weight and full height\n",
    "            arr = np.array([[int(i['weightPounds']), totalHeight]])\n",
    "            #print(arr)\n",
    "            #print(playerSize)\n",
    "            # adding the height and weight duo to the np array of every player\n",
    "            playerSize = np.concatenate((playerSize, arr))\n",
    "            #playerSize = np.append(playerSize, [int(i['weightPounds']), totalHeight])\n",
    "            \n",
    "            #adding player position here to array -\n",
    "            # options are center, forward, or guard or combo of any two except guard-center\n",
    "            playerPosition = np.append(playerPosition, i['pos'])   \n",
    "    # getting rid of the [0,0] placeholder\n",
    "    realPlayers = playerSize[1:]\n",
    "    #print(realPlayers)\n",
    "    clf = svm.SVC()\n",
    "    # new instance of svc\n",
    "    # fit array of player's weight/heights to their corresponding position\n",
    "    clf.fit(realPlayers, playerPosition)         \n",
    "    weight = 0\n",
    "    heightFeet = 0\n",
    "    heightInches = 0\n",
    "    # the next few while loops will get the user's height and weight and will check for failure to convert to int\n",
    "    # e.g. the user types in 'swol' for weight\n",
    "    while(1):\n",
    "        weight = input(\"What is your weight in pounds? \")\n",
    "        try:\n",
    "            weight = int(weight)\n",
    "            break\n",
    "        except ValueError:\n",
    "            print(\"Please enter in a number! \")\n",
    "    while(1):\n",
    "        heightFeet = input(\"What is your height? Enter feet first. \")\n",
    "        try:\n",
    "            heightFeet = int(heightFeet)\n",
    "            \n",
    "            break\n",
    "        except ValueError:\n",
    "            print(\"Please enter in a number! \")\n",
    "    while(1):\n",
    "        heightInches = input(\"What is your height? Now enter inches. \")\n",
    "        try:\n",
    "            heightInches = int(heightInches)\n",
    "            break\n",
    "        except ValueError:\n",
    "            print(\"Please enter in a number!\")\n",
    "    totalHeight = (heightFeet*12) + heightInches\n",
    "    # predicts the user's classification based on weight and height and reads the position referencing a dictionary\n",
    "    rest = clf.predict([[weight, totalHeight]])\n",
    "    #print(rest[0])\n",
    "    myDict = {'F':\"Forward\", 'G':'Guard', 'C':\"Center\", 'G-F':\"Primary Guard and Secondary Forward\", 'F-G':\"Primary Forward and Secondary Guard\", 'F-C':\"Primary Forward and Secondary Center\", 'C-F':\"Primary Center and Secondary Forward\"}\n",
    "    selection = myDict[rest[0]]\n",
    "    print(\"Based on the Stats of ALL of the NBA Players, and your height and weight, you should be a {}.\".format(selection))\n",
    "    #print(\"{} is the weight\".format(weight))\n",
    "    #print(\"{} is the height in feet\".format(heightFeet))\n",
    "    #print(\"{} is the height in inches\".format(heightInches))\n",
    "# press shift+enter to run this section of code as well as the function\n",
    "\n",
    "predictPosition()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "bike is the second option, and run is the first option\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[\"run\", \"bike\", \"swim\"], [\"sit\", \"watch\", \"lie\"]])\n",
    "print(x.shape)\n",
    "print(\"{1} is the second option, and {0} is the first option\".format(\"run\", \"bike\"))\n",
    "# testing strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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
}