NumPy_SciPy_Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy, SciPy and Pandas\n",
    "\n",
    "Each of these modules could be the topic of a semester-long course, and we will not get into the details of them. \n",
    "\n",
    "One fundemental concept I want to convey is well summarized in this quote from the [SciPy Getting Started page](https://www.scipy.org/getting-started.html):\n",
    "\n",
    "> Don’t reinvent the wheel, there may already be a pre-made solution for your problem.\n",
    "\n",
    "To some extent, this can apply to every module. There are certainly other modules that we could cover--[**BioPython**](https://biopython.org/) being one that I highly recommend you check out. As I've stated, Python is somewhat intentionally stripped down, with limited built-in functionality. But a lot of functionality has been added with modules--**make use of them!** \n",
    "\n",
    "Whatever you plan to do with Python, take some time to look into what modules are available to help you. Don't reinvent the wheel!\n",
    "\n",
    "## Here are the general features of these modules\n",
    "\n",
    "\n",
    "**NumPy** provides array and matrix data types for Python as well as efficient mathematical tools for working with these data types. If your work involves numerical computations, especially matrix manipulations, NumPy is your tool! \n",
    "\n",
    "**SciPy** adds additional tools for integration, diffential equations, optimization, and more. Many mathematically-based scientific computations benefit from SciPy.\n",
    "\n",
    "**Pandas** provides data frames for Python. Data frames are a table representation of data where columns and rows can be named (indexed). Tabular data can be analyzed without data frames, but Pandas and data frames simplify data analysis, and form the foundation of a lot of data science work.\n"
   ]
  },
  {
   "source": [
    "## NumPy and inclusive communities\n",
    "\n",
    "[NumPy](https://numpy.org/) is undoubtedly an important package for Python and its developers (mostly volunteer) have provided a great service to the community, not only with NumPy itself, but enabling development of packages that use NumPy under the hood to add even more functionality. The developers have however done a great disservice  in failing to address issues of inclusion of diverse talents. \n",
    "\n",
    "On September, 16, 2020, *Nature* published the paper [Array Programming with NumPy](https://www.nature.com/articles/s41586-020-2649-2?amp%3Bcode=573df4db-16bd-47ad-b138-d0d9c14134f1) with 26 authors. **All** 26 authors are male! There have been many excuses offered, and commitments to improve ([NumPy Diversity and Inclusion Statement](https://numpy.org/diversity_sep2020/)).\n",
    "\n",
    "This is not news however, a [2018 analysis by Anthony Scopatz](https://nbviewer.jupyter.org/github/scopatz/nf-project-inequality/blob/9b83df3090c9b9b1b953d2905d428b71165ce607/nf-project-inequality.ipynb), found huge \"Inequality of underrepresented groups in PyData Leadership\" (this is an interesting read on its own and is presented as a Jupyter Notebook). Here's the main figure from Anthony's analysis:\n",
    "\n",
    "![image from Anthony Scopatz's analysis, linked from Reshama Shaikh's article on \"Why Women Are Flourishing In R Community But Lagging In Python\"](https://reshamas.github.io/assets/images/numfocus_os.png)\n",
    "\n",
    "The analysis showed high inequality in NumPy and many other Python projects.\n",
    "\n",
    "There is also a very interesting analysis by Reshama Shaikh on \"[Why Women Are Flourishing In R Community But Lagging In Python](https://reshamas.github.io/why-women-are-flourishing-in-r-community-but-lagging-in-python/)\" which contrasts the Python and R communities. I highly recommend reading Rashama's article, it has many good insights as to why R, in general, has succeeded in attracting a more diverse developer community.\n",
    "\n",
    "As I mentioned when looking at Git and Github and the need for developer communities to be more inclusive of racial diversity, stop using offensive terms, and actively work to foster racial diversity, the same is true for gender diversity (Anthony's article also makes a great point about including non-binary people in assessment of diversity).\n",
    "\n",
    "While I am disappointed in the NumPy history and will encourage reforms, if we choose to stop using NumPy, we would not be able to use Python for a wide array (pun intended) of applications. So, we will use NumPy, but also commit to increasing diversity and acknowledge historical wrongs."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Array and Matrix\n",
    "\n",
    "While lists can do a lot, NumPy offers robust support for arrays and matrices and the math associated with them.\n",
    "\n",
    "One thing we haven't seen yet, is the `import as` construct. We could just `import numpy`, but then when we use a NumPy function, we'd have to type, for example, `numpy.array([6, 7, 8])`. If we instead `import numpy as np`, we make a shorthand and can call array with `np.array([6, 7, 8])`--a few letters shorted each time we type it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[6 7 8]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "my_array=np.array([6, 7, 8])  # Make an array, show type and print it.\n",
    "print(type(my_array))\n",
    "print(my_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11],\n",
       "       [12, 13, 14]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix = np.arange(15).reshape(5, 3)  # Make 5X3 matrix of the numbers 0-14.\n",
    "matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6],\n",
       "       [7],\n",
       "       [8]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_array.reshape(3,1)  # Reshape the array to be a vector with 3 rows, 1 column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   7,  16],\n",
       "       [ 18,  28,  40],\n",
       "       [ 36,  49,  64],\n",
       "       [ 54,  70,  88],\n",
       "       [ 72,  91, 112]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prod=my_array * matrix  # Matrix multiplication\n",
    "prod"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could keep going, but would quickly get to the end of my matrix math understanding! But there are functions to make matrixes with 1s on the diagonals, transpose matrices, calculate eigenvectors, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SciPy\n",
    "\n",
    "The example here is from the [SciPy Getting Started page](https://www.scipy.org/getting-started.html). I am not concerned about the details. First the demo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.00000000e+00 2.00040008e-03 4.00080016e-03 ... 9.99599920e+00\n",
      " 9.99799960e+00 1.00000000e+01]\n"
     ]
    }
   ],
   "source": [
    "from scipy import special, optimize\n",
    "\n",
    "f = lambda x: -special.jv(3, x)\n",
    "sol = optimize.minimize(f, 1.0)\n",
    "x = np.linspace(0, 10, 5000)\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll need the `pyplot` funtion of `matplotlib` to plot the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(x, special.jv(3, x), '-', sol.x, -sol.fun, 'o')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks good...maybe useful...\n",
    "\n",
    "But really, I wanted to show you the script on the same page:\n",
    "\n",
    "```python\n",
    "\n",
    "\"\"\"example.py\n",
    "\n",
    "Compute the maximum of a Bessel function and plot it.\n",
    "\n",
    "\"\"\"\n",
    "import argparse\n",
    "\n",
    "import numpy as np\n",
    "from scipy import special, optimize\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def main():\n",
    "    # Parse command-line arguments\n",
    "    parser = argparse.ArgumentParser(usage=__doc__)\n",
    "    parser.add_argument(\"--order\", type=int, default=3, help=\"order of Bessel function\")\n",
    "    parser.add_argument(\"--output\", default=\"plot.png\", help=\"output image file\")\n",
    "    args = parser.parse_args()\n",
    "\n",
    "    # Compute maximum\n",
    "    f = lambda x: -special.jv(args.order, x)\n",
    "    sol = optimize.minimize(f, 1.0)\n",
    "\n",
    "    # Plot\n",
    "    x = np.linspace(0, 10, 5000)\n",
    "    plt.plot(x, special.jv(args.order, x), '-', sol.x, -sol.fun, 'o')\n",
    "\n",
    "    # Produce output\n",
    "    plt.savefig(args.output, dpi=96)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n",
    "    \n",
    "```\n",
    "\n",
    "And really all I wanted to talk about was the last couple of lines:\n",
    "\n",
    "```python\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `if __name__ == \"__main__\":`\n",
    "\n",
    "I want to show you this because it is common and also a bit confusing if you don't understand it.\n",
    "\n",
    "`__name__` is a variable that Python uses to tell if the code is being launched from the command line, or has been called as a function. Let's use an addition function from earlier as an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please type one number: 5\n",
      "Please type another number: 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0 + 6.0 = 11.0\n"
     ]
    }
   ],
   "source": [
    "def add_two(a,b):\n",
    "    c=a+b\n",
    "    return c\n",
    "\n",
    "num1=float(input(\"Please type one number:\"))\n",
    "num2=float(input(\"Please type another number:\"))\n",
    "\n",
    "print(num1, \"+\", num2,\"=\", add_two(num1,num2))\n",
    "\n",
    "# Saved as add_two_prompt.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that I haven't added all the good `try:`/`except:` and other cool stuff to make this more robust, but whatever...\n",
    "\n",
    "Now, let's imagine `add_two` is the most amazing function ever written and in our next script we realize that we want to use the `add_two` function.\n",
    "\n",
    "Let's save the above to a file called `add_two_prompt.py`, and run it on the command line:\n",
    "\n",
    "```bash\n",
    "$ python add_two_prompt.py\n",
    "Please type one number:4\n",
    "Please type another number:5\n",
    "4.0 + 5.0 = 9.0\n",
    "$\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please type one number: 5\n",
      "Please type another number: 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0 + 6.0 = 11.0\n"
     ]
    }
   ],
   "source": [
    "import add_two_prompt\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But as soon as we import the add_two_prompt script, the script is run, prompting the user for the numbers and calling the function! That probably isn't what we want!\n",
    "\n",
    "We want to import the function and be able to run it with two numbers. We don't want to prompt the user for numbers, we just want to be able to call the `add_two` function.\n",
    "\n",
    "We could edit the add_two_prompt script to remove the part about prompting the user for numbers, but that would break that neat functionality.\n",
    "\n",
    "What we want is to only prompt the user for numbers when we run the script from the command line, but otherwise, we just want to add the add_two function to our toolbox.\n",
    "\n",
    "The way to do that is with the `if __name__ == \"__main__\":`\n",
    "\n",
    "Let's change the script to look like:\n",
    "\n",
    "```python\n",
    "#!/usr/bin/env python3\n",
    "\n",
    "def add_two(a,b):\n",
    "    c=a+b\n",
    "    return c\n",
    "\n",
    "def main():\n",
    "    num1=float(input(\"Please type one number:\"))\n",
    "    num2=float(input(\"Please type another number:\"))\n",
    "\n",
    "    print(num1, \"+\", num2,\"=\", add_two(num1,num2))\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n",
    "\n",
    "# Saved as add_two_ifmain.py\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That works on the command line still.\n",
    "\n",
    "But we can import it and use as intended:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your score is: 25\n"
     ]
    }
   ],
   "source": [
    "import add_two_ifmain\n",
    "\n",
    "score=20\n",
    "bonus=5\n",
    "\n",
    "print(\"Your score is:\", add_two_ifmain.add_two(score,bonus))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By moving the interactive parts of the program to the \"main\" function and using the `__name__` variable, we have the best of both worlds.\n",
    "\n",
    "Mostly I want to show this because you will find a lot of examples that look like this and it can be confusing if you don't understand what they are doing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas\n",
    "\n",
    "Pandas makes analyzing tabular data so much easier. There's a lot that can be done in Pandas, but let's use our flights data as an example.\n",
    "\n",
    "Turns out there's a similar dataset online here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>FL_DATE</th>\n",
       "      <th>ORIGIN</th>\n",
       "      <th>DEST</th>\n",
       "      <th>ARR_DELAY_NEW</th>\n",
       "      <th>WEATHER_DELAY</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2017-05-01</td>\n",
       "      <td>LAX</td>\n",
       "      <td>IAD</td>\n",
       "      <td>50.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2017-05-01</td>\n",
       "      <td>LAX</td>\n",
       "      <td>IAD</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2017-05-01</td>\n",
       "      <td>SAN</td>\n",
       "      <td>SFO</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2017-05-01</td>\n",
       "      <td>SFO</td>\n",
       "      <td>EWR</td>\n",
       "      <td>111.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2017-05-01</td>\n",
       "      <td>JFK</td>\n",
       "      <td>SFO</td>\n",
       "      <td>6.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      FL_DATE ORIGIN DEST  ARR_DELAY_NEW  WEATHER_DELAY\n",
       "0  2017-05-01    LAX  IAD           50.0            0.0\n",
       "1  2017-05-01    LAX  IAD            0.0            NaN\n",
       "2  2017-05-01    SAN  SFO            0.0            NaN\n",
       "3  2017-05-01    SFO  EWR          111.0            0.0\n",
       "4  2017-05-01    JFK  SFO            6.0            NaN"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Note you will likely need to update the path here!!!\n",
    "# This file is too large for git, but is available at: \n",
    "#   https://www.dropbox.com/s/jizx4ijnpxmi3av/flights.May2017-Apr2018.csv?dl=0\n",
    "\n",
    "# Importing the whole dataset takes >4GB of RAM. To avoid this, let's use just a few columns.\n",
    "columns=['FL_DATE','ORIGIN','DEST','ARR_DELAY_NEW','WEATHER_DELAY']\n",
    "\n",
    "# The usecols argument is a list of columns to import.\n",
    "df=pd.read_csv(\"../shared_data/flights.May2017-Apr1018.csv\", usecols=columns)\n",
    "\n",
    "\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FL_DATE          1525\n",
       "ORIGIN           1525\n",
       "DEST             1525\n",
       "ARR_DELAY_NEW    1525\n",
       "WEATHER_DELAY     804\n",
       "dtype: int64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Count rows where the ORIGIN or DEST are GNV and the ARR_DELAY_NEW is > 0.\n",
    "df[((df.ORIGIN=='GNV') | (df.DEST=='GNV')) & df.ARR_DELAY_NEW>0].count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "late = df[((df.ORIGIN=='GNV') | (df.DEST=='GNV')) & df.ARR_DELAY_NEW>0]\n",
    "late.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could keep going with this, but where to stop..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keep going...\n",
    "\n",
    "There's a ton of online resources for Pandas. Here's a few suggestions:\n",
    "\n",
    "* [Top 8 resources for learning data analysis with Pandas](https://www.dataschool.io/best-python-pandas-resources/)\n",
    "\n",
    "* The videos and Juyter notebooks from: [Easier data analysis in Python with Pandas](https://www.dataschool.io/easier-data-analysis-with-pandas/)\n",
    "\n",
    "* The [Python Data Science Handbook](https://jakevdp.github.io/PythonDataScienceHandbook/) has a chapter on Pandas. This is a great book!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8 (full)",
   "language": "python",
   "name": "python3-3.8-ufrc"
  },
  "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.8.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}