Data_Scientist_with_Python/01_Introduction_to_python/04-Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `Section 04: NumPy` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 01- Your First NumPy Array\n",
    "* Import the `numpy` package as `np`, so that you can refer to `numpy` with `np`.\n",
    "* Use `np.array()` to create a `numpy` array from `baseball`. Name this array `np_baseball`.\n",
    "* Print out the type of `np_baseball` to check that you got it right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# Create list baseball\n",
    "baseball = [180, 215, 210, 210, 188, 176, 209, 200]\n",
    "\n",
    "# Import the numpy package as np\n",
    "import numpy as np\n",
    "\n",
    "# Create a numpy array from baseball: np_baseball\n",
    "np_baseball = np.array(baseball)\n",
    "\n",
    "# Print out type of np_baseball\n",
    "print(type(np_baseball))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 02- Baseball players' height\n",
    "* Create a `numpy` array from `height_in`. Name this new array `np_height_in`.\n",
    "* Print `np_height_in`.\n",
    "* Multiply `np_height_in` with 0.`0254` to convert all height measurements from inches to meters. Store the new values in a new array, `np_height_m`.\n",
    "* Print out `np_height_m` and check if the output makes sense."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[74 74 72 72 73 69 69 71 76 71]\n",
      "[1.8796 1.8796 1.8288 1.8288 1.8542 1.7526 1.7526 1.8034 1.9304 1.8034]\n"
     ]
    }
   ],
   "source": [
    "# height_in is available as a regular list\n",
    "height_in = [74, 74, 72, 72, 73, 69, 69, 71, 76, 71] \n",
    "\n",
    "# Import numpy\n",
    "import numpy as np\n",
    "\n",
    "# Create a numpy array from height_in: np_height_in\n",
    "np_height_in = np.array(height_in)\n",
    "\n",
    "# Print out np_height_in\n",
    "print(np_height_in)\n",
    "\n",
    "# Convert np_height_in to m: np_height_m\n",
    "np_height_m = np_height_in * 0.0254\n",
    "\n",
    "# Print np_height_m\n",
    "print(np_height_m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 03- Baseball player's BMI\n",
    "* Create a `numpy` array from the `weight_lb` list with the correct units. Multiply by `0.453592` to go from pounds to kilograms. Store the resulting `numpy` array as `np_weight_kg`.\n",
    "* Use `np_height_m` and `np_weight_kg` to calculate the BMI of each player. Use the following equation:\n",
    "* Save the resulting numpy array as `bmi`.\n",
    "* Print out `bmi`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[19.28858727 19.7738158  23.11037639 27.60406069 28.48080465 28.48080465\n",
      " 24.80333518 25.99036864 30.86356276 27.89402921 28.11789135 25.10462629]\n"
     ]
    }
   ],
   "source": [
    "# height_in and weight_lb are available as regular lists\n",
    "height_in = [81, 80, 74, 74, 72, 72, 73, 69, 69, 71, 76, 71] \n",
    "weight_lb = [180, 180, 180, 215, 210, 210, 188, 176, 209, 200, 231, 180]\n",
    "\n",
    "# Import numpy\n",
    "import numpy as np\n",
    "\n",
    "# Create array from height_in with metric units: np_height_m\n",
    "np_height_m = np.array(height_in) * 0.0254\n",
    "\n",
    "# Create array from weight_lb with metric units: np_weight_kg\n",
    "np_weight_kg = np.array(weight_lb) * 0.453592\n",
    "\n",
    "# Calculate the BMI: bmi\n",
    "bmi = np_weight_kg/np_height_m ** 2\n",
    "\n",
    "# Print out bmi\n",
    "print(bmi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 04- Lightweight baseball players\n",
    "\n",
    "* Create a boolean `numpy` array: the element of the array should be `True` if the corresponding baseball player's BMI is below `21`. You can use the `<` operator for this. Name the array `light`.\n",
    "* Print the array `light`.\n",
    "* Print out a `numpy` array with the BMIs of all baseball players whose BMI is below 21. Use `light` inside square brackets to do a selection on the `bmi` array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True False False False False False False False False False False]\n",
      "[19.28858727 19.7738158 ]\n"
     ]
    }
   ],
   "source": [
    "# height_in and weight_lb are available as a regular lists\n",
    "\n",
    "# Import numpy\n",
    "import numpy as np\n",
    "\n",
    "# Calculate the BMI: bmi\n",
    "np_height_m = np.array(height_in) * 0.0254\n",
    "np_weight_kg = np.array(weight_lb) * 0.453592\n",
    "bmi = np_weight_kg / np_height_m ** 2\n",
    "\n",
    "# Create the light array\n",
    "light = bmi < 21\n",
    "\n",
    "# Print out light\n",
    "print(light)\n",
    "\n",
    "# Print out BMIs of all baseball players whose BMI is below 21\n",
    "print(bmi[light])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5- NumPy Side Effects\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 2])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "np.array([True, 1, 2]) + np.array([3, 4, False])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6- Subsetting NumPy Arrays\n",
    "* Subset `np_weight_lb` by printing out the element at index 2.\n",
    "* Print out a sub-array of `np_height_in` that contains the elements at index 2 up to and including index 8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "180\n",
      "[74 74 72 72 73 69 69]\n"
     ]
    }
   ],
   "source": [
    "# height_in and weight_lb are available as a regular lists\n",
    "\n",
    "# Import numpy\n",
    "import numpy as np\n",
    "\n",
    "# Store weight and height lists as numpy arrays\n",
    "np_weight_lb = np.array(weight_lb)\n",
    "np_height_in = np.array(height_in)\n",
    "\n",
    "# Print out the weight at index 2\n",
    "print(np_weight_lb[2])\n",
    "\n",
    "# Print out sub-array of np_height_in: index 2 up to and including index 9\n",
    "print(np_height_in[2:9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6- Your First 2D NumPy Array\n",
    "* Use `np.array()` to create a 2D `numpy` array from `baseball`. Name it `np_baseball`.\n",
    "* Print out the type of `np_baseball`.\n",
    "* Print out the `shape` attribute of `np_baseball`. Use `np_baseball.shape`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "(4, 2)\n"
     ]
    }
   ],
   "source": [
    "# Create baseball, a list of lists\n",
    "baseball = [[180, 78.4],\n",
    "            [215, 102.7],\n",
    "            [210, 98.5],\n",
    "            [188, 75.2]]\n",
    "\n",
    "# Import numpy\n",
    "import numpy as np\n",
    "\n",
    "# Create a 2D numpy array from baseball: np_baseball\n",
    "np_baseball = np.array(baseball)\n",
    "\n",
    "# Print out the type of np_baseball\n",
    "print(type(np_baseball))\n",
    "\n",
    "# Print out the shape of np_baseball\n",
    "print(np_baseball.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7- Baseball data in 2D form\n",
    "* Use `np.array()` to create a 2D `numpy` array from `baseball`. Name it `np_baseball`.\n",
    "* Print out the shape attribute of `np_baseball`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 2)\n"
     ]
    }
   ],
   "source": [
    "# baseball is available as a regular list of lists\n",
    "baseball = [[180, 78.4],[215, 102.7],[210, 98.5],[188, 75.2],[179, 75.3],\n",
    "            [170, 77.2],[205, 100.2],[212, 95.6],[190, 90.3],[181, 76.3]]\n",
    "\n",
    "\n",
    "\n",
    "# Import numpy package\n",
    "import numpy as np\n",
    "\n",
    "# Create a 2D numpy array from baseball: np_baseball\n",
    "np_baseball = np.array(baseball)\n",
    "\n",
    "# Print out the shape of np_baseball\n",
    "print(np_baseball.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8- Subsetting 2D NumPy Arrays\n",
    "\n",
    "* Print out the 4th row of `np_baseball`.\n",
    "* Make a new variable, `np_weight_lb`, containing the entire second column of `np_baseball`.\n",
    "* Select the height (first column) of the 7th baseball player in `np_baseball` and print it out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[188.   75.2]\n",
      "205.0\n"
     ]
    }
   ],
   "source": [
    "# baseball is available as a regular list of lists\n",
    "\n",
    "# Import numpy package\n",
    "import numpy as np\n",
    "\n",
    "# Create np_baseball (2 cols)\n",
    "np_baseball = np.array(baseball)\n",
    "\n",
    "# Print out the 4th row of np_baseball\n",
    "print(np_baseball[3,:])\n",
    "\n",
    "# Select the entire second column of np_baseball: np_weight_lb\n",
    "np_weight_lb = np_baseball[:,1]\n",
    "\n",
    "# Print out height of 7th player\n",
    "print(np_baseball[6,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9- 2D Arithmetic\n",
    "\n",
    "* You managed to get hold of the changes in height, weight and age of all baseball players. It is available as a 2D `numpy` array, `updated`. Add `np_baseball` and `updated` and print out the result.\n",
    "* You want to convert the units of height and weight to metric (meters and kilograms, respectively). As a first step, create a `numpy` array with three values: `0.0254`, `0.453592` and `1`. Name this array `conversion`.\n",
    "* Multiply `np_baseball` with `conversion` and print out the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "baseball = [[ 72, 210,  30.78], [ 72, 210, 35.43], [ 73, 188, 35.71], [ 69, 176, 29.39],\n",
    "               [ 69, 209,  30.77], [ 71, 200, 35.07], [ 76, 231, 30.19], [ 71, 180, 27.05],\n",
    "               [ 73, 188,  23.88], [ 73, 180, 26.96], [ 74, 185, 23.29]]\n",
    "\n",
    "\n",
    "updated = np.array([[1.1544228, 5.08167641, 1], [0.64427532, -5.09538071, 1], [1.00590086, 2.24342718, 1], [0.97953547, 12.19841763, 1],\n",
    "           [0.62874324, 13.72324216,   1], [1.27075194, -8.87946313, 1], [0.47655945, -10.82495536, 1], [0.91699376, -7.01116249, 1],\n",
    "           [1.17179326, 1.19946614, 1], [1.14509104, -12.00385685, 1], [1.20684945, -13.29830645, 1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 73.1544228  215.08167641  31.78      ]\n",
      " [ 72.64427532 204.90461929  36.43      ]\n",
      " [ 74.00590086 190.24342718  36.71      ]\n",
      " [ 69.97953547 188.19841763  30.39      ]\n",
      " [ 69.62874324 222.72324216  31.77      ]\n",
      " [ 72.27075194 191.12053687  36.07      ]\n",
      " [ 76.47655945 220.17504464  31.19      ]\n",
      " [ 71.91699376 172.98883751  28.05      ]\n",
      " [ 74.17179326 189.19946614  24.88      ]\n",
      " [ 74.14509104 167.99614315  27.96      ]\n",
      " [ 75.20684945 171.70169355  24.29      ]]\n",
      "[[  1.8288    95.25432   30.78    ]\n",
      " [  1.8288    95.25432   35.43    ]\n",
      " [  1.8542    85.275296  35.71    ]\n",
      " [  1.7526    79.832192  29.39    ]\n",
      " [  1.7526    94.800728  30.77    ]\n",
      " [  1.8034    90.7184    35.07    ]\n",
      " [  1.9304   104.779752  30.19    ]\n",
      " [  1.8034    81.64656   27.05    ]\n",
      " [  1.8542    85.275296  23.88    ]\n",
      " [  1.8542    81.64656   26.96    ]\n",
      " [  1.8796    83.91452   23.29    ]]\n"
     ]
    }
   ],
   "source": [
    "# baseball is available as a regular list of lists\n",
    "# updated is available as 2D numpy array\n",
    "\n",
    "# Import numpy package\n",
    "import numpy as np\n",
    "\n",
    "# Create np_baseball (3 cols)\n",
    "np_baseball = np.array(baseball)\n",
    "\n",
    "# Print out addition of np_baseball and updated\n",
    "print(np_baseball + updated)\n",
    "\n",
    "# Create numpy array: conversion\n",
    "conversion = np.array([0.0254, 0.453592, 1])\n",
    "\n",
    "# Print out product of np_baseball and conversion\n",
    "print(np_baseball * conversion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.88, 1.76, 1.78, 1.76, 1.74, 1.92, 1.66, 1.56, 1.88, 1.83])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.round(np.random.normal(1.75, 0.2, 10), 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10- Average versus median\n",
    "* Create `numpy` array `np_height_in` that is equal to first column of `np_baseball`.\n",
    "* Print out the mean of `np_height_in`.\n",
    "* Print out the median of `np_height_in`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "72.0909090909091\n",
      "72.0\n"
     ]
    }
   ],
   "source": [
    "# np_baseball is available\n",
    "\n",
    "# Import numpy\n",
    "import numpy as np\n",
    "\n",
    "# Create np_height_in from np_baseball\n",
    "np_height_in = np_baseball[:,0]\n",
    "\n",
    "# Print out the mean of np_height_in\n",
    "print(np.mean(np_height_in)) \n",
    "\n",
    "# Print out the median of np_height_in\n",
    "print(np.median(np_height_in)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11- Explore the baseball data\n",
    "\n",
    "* The code to print out the mean height is already included. Complete the code for the median height. Replace `None` with the correct code.\n",
    "* Use `np.std()` on the first column of `np_baseball` to calculate `stddev`. Replace `None` with the correct code.\n",
    "* Do big players tend to be heavier? Use `np.corrcoef()` to store the correlation between the first and second column of `np_baseball` in `corr`. Replace `None` with the correct code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average: 72.0909090909091\n",
      "Median: 72.0\n",
      "Standard Deviation: 1.9750509984000393\n",
      "Correlation: [[1.         0.33348879]\n",
      " [0.33348879 1.        ]]\n"
     ]
    }
   ],
   "source": [
    "# np_baseball is available\n",
    "\n",
    "# Import numpy\n",
    "import numpy as np\n",
    "\n",
    "# Print mean height (first column)\n",
    "avg = np.mean(np_baseball[:,0])\n",
    "print(\"Average: \" + str(avg))\n",
    "\n",
    "# Print median height. Replace 'None'\n",
    "med = np.median(np_baseball[:,0])\n",
    "print(\"Median: \" + str(med))\n",
    "\n",
    "# Print out the standard deviation on height. Replace 'None'\n",
    "stddev = np.std(np_baseball[:,0])\n",
    "print(\"Standard Deviation: \" + str(stddev))\n",
    "\n",
    "# Print out correlation between first and second column. Replace 'None'\n",
    "corr = np.corrcoef(np_baseball[:,0], np_baseball[:,1])\n",
    "print(\"Correlation: \" + str(corr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12- Blend it all together\n",
    "* Convert `heights` and `positions`, which are regular lists, to numpy arrays. Call them `np_heights` and `np_positions`.\n",
    "* Extract all the heights of the goalkeepers. You can use a little trick here: use `np_positions == 'GK'` as an index for `np_heights`. Assign the result to `gk_heights`.\n",
    "* Extract all the heights of all the other players. This time use `np_positions != 'GK'` as an index for `np_heights`. Assign the result to `other_heights`.\n",
    "* Print out the median height of the goalkeepers using `np.median()`. Replace `None` with the correct code.\n",
    "* Do the same for the other players. Print out their median height. Replace `None` with the correct code.\n",
    "\n",
    "\n",
    "Each element in the lists corresponds to a player. The first list, positions, contains strings representing each player's position. The possible positions are: 'GK' (goalkeeper), 'M' (midfield), 'A' (attack) and 'D' (defense). The second list, heights, contains integers representing the height of the player in cm. The first player in the lists is a goalkeeper and is pretty tall (191 cm)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Median height of goalkeepers: 185.0\n",
      "Median height of other players: 183.0\n"
     ]
    }
   ],
   "source": [
    "# heights and positions\n",
    "positions = ['GK', 'M', 'A', 'D', 'M', 'GK', 'M', 'M', 'GK', 'A', 'M', 'M', 'a', 'A', 'GK', 'M', 'D', 'A', 'D', 'M']\n",
    "heights = [191, 184, 185, 180, 181, 187, 170, 179, 183, 186, 185, 170, 187, 183, 173, 188, 183, 180, 188, 175]\n",
    "\n",
    "\n",
    "# heights and positions are available as lists\n",
    "\n",
    "# Import numpy\n",
    "import numpy as np\n",
    "\n",
    "# Convert positions and heights to numpy arrays: np_positions, np_heights\n",
    "np_positions = np.array(positions)\n",
    "np_heights = np.array(heights)\n",
    "\n",
    "# Heights of the goalkeepers: gk_heights\n",
    "gk_heights = np_heights[np_positions == 'GK'] \n",
    "\n",
    "# Heights of the other players: other_heights\n",
    "other_heights = np_heights[np_positions != 'GK'] \n",
    "\n",
    "# Print out the median height of goalkeepers. Replace 'None'\n",
    "print(\"Median height of goalkeepers: \" + str(np.median(gk_heights)))\n",
    "\n",
    "# Print out the median height of other players. Replace 'None'\n",
    "print(\"Median height of other players: \" + str(np.median(other_heights)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "==================================\n",
    "### `The End`\n",
    "=================================="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "375c74fd8c11b85bdfdf0d0a51867cc40572443e91947231b688f7b7116ba890"
  },
  "kernelspec": {
   "display_name": "Python 3.6.8 64-bit",
   "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.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}