notebooks/02-IntroPython_Numpy_Scypy_Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02 - Introduction to Python for Data Analysis\n",
    "\n",
    "by [Alejandro Correa Bahnsen](albahnsen.com/) and [Jesus Solano](https://github.com/jesugome)\n",
    "\n",
    "version 1.4, January 2019\n",
    "\n",
    "## Part of the class [Practical Machine Learning](https://github.com/albahnsen/PracticalMachineLearningClass)\n",
    "\n",
    "\n",
    "\n",
    "This notebook is licensed under a [Creative Commons Attribution-ShareAlike 3.0 Unported License](http://creativecommons.org/licenses/by-sa/3.0/deed.en_US). Special thanks goes to [Rick Muller](http://www.cs.sandia.gov/~rmuller/), Sandia National Laboratories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why Python?\n",
    "Python is the programming language of choice for many scientists to a large degree because it offers a great deal of power to analyze and model scientific data with relatively little overhead in terms of learning, installation or development time. It is a language you can pick up in a weekend, and use for the rest of one's life.\n",
    "\n",
    "The [Python Tutorial](http://docs.python.org/3/tutorial/) is a great place to start getting a feel for the language. To complement this material, I taught a [Python Short Course](http://www.wag.caltech.edu/home/rpm/python_course/) years ago to a group of computational chemists during a time that I was worried the field was moving too much in the direction of using canned software rather than developing one's own methods. I wanted to focus on what working scientists needed to be more productive: parsing output of other programs, building simple models, experimenting with object oriented programming, extending the language with C, and simple GUIs. \n",
    "\n",
    "I'm trying to do something very similar here, to cut to the chase and focus on what scientists need. In the last year or so, the [Jupyter Project](http://jupyter.org) has put together a notebook interface that I have found incredibly valuable. A large number of people have released very good IPython Notebooks that I have taken a huge amount of pleasure reading through. Some ones that I particularly like include:\n",
    "\n",
    "* Rick Muller [A Crash Course in Python for Scientists](http://nbviewer.jupyter.org/gist/rpmuller/5920182)\n",
    "* Rob Johansson's [excellent notebooks](http://jrjohansson.github.io/), including [Scientific Computing with Python](https://github.com/jrjohansson/scientific-python-lectures) and [Computational Quantum Physics with QuTiP](https://github.com/jrjohansson/qutip-lectures) lectures;\n",
    "* [XKCD style graphs in matplotlib](http://nbviewer.ipython.org/url/jakevdp.github.com/downloads/notebooks/XKCD_plots.ipynb);\n",
    "* [A collection of Notebooks for using IPython effectively](https://github.com/ipython/ipython/tree/master/examples/notebooks#a-collection-of-notebooks-for-using-ipython-effectively)\n",
    "* [A gallery of interesting IPython Notebooks](https://github.com/ipython/ipython/wiki/A-gallery-of-interesting-IPython-Notebooks)\n",
    "\n",
    "I find Jupyter notebooks an easy way both to get important work done in my everyday job, as well as to communicate what I've done, how I've done it, and why it matters to my coworkers. In the interest of putting more notebooks out into the wild for other people to use and enjoy, I thought I would try to recreate some of what I was trying to get across in the original Python Short Course, updated by 15 years of Python, Numpy, Scipy, Pandas, Matplotlib, and IPython development, as well as my own experience in using Python almost every day of this time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why Python for Data Analysis?\n",
    "\n",
    "- Python is great for scripting and applications.\n",
    "- The `pandas` library offers improved library support.\n",
    "- Scraping, web APIs\n",
    "- Strong High Performance Computation support\n",
    "    - Load balanceing tasks\n",
    "    - MPI, GPU\n",
    "    - MapReduce\n",
    "- Strong support for abstraction\n",
    "    - Intel MKL\n",
    "    - HDF5\n",
    "- Environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## But we already know R\n",
    "\n",
    "...Which is better? Hard to answer\n",
    "\n",
    "http://www.kdnuggets.com/2015/05/r-vs-python-data-science.html\n",
    "\n",
    "http://www.kdnuggets.com/2015/03/the-grammar-data-science-python-vs-r.html\n",
    "\n",
    "https://www.datacamp.com/community/tutorials/r-or-python-for-data-analysis\n",
    "\n",
    "https://www.dataquest.io/blog/python-vs-r/\n",
    "\n",
    "http://www.dataschool.io/python-or-r-for-data-science/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What You Need to Install\n",
    "\n",
    "There are two branches of current releases in Python: the older-syntax Python 2, and the newer-syntax Python 3. This schizophrenia is largely intentional: when it became clear that some non-backwards-compatible changes to the language were necessary, the Python dev-team decided to go through a five-year (or so) transition, during which the new language features would be introduced and the old language was still actively maintained, to make such a transition as easy as possible. \n",
    "\n",
    "Nonetheless, I'm going to write these notes with Python 3 in mind, since this is the version of the language that I use in my day-to-day job, and am most comfortable with. \n",
    "\n",
    "With this in mind, these notes assume you have a Python distribution that includes:\n",
    "\n",
    "* [Python](http://www.python.org) version 3.5;\n",
    "* [Numpy](http://www.numpy.org), the core numerical extensions for linear algebra and multidimensional arrays;\n",
    "* [Scipy](http://www.scipy.org), additional libraries for scientific programming;\n",
    "* [Matplotlib](http://matplotlib.sf.net), excellent plotting and graphing libraries;\n",
    "* [IPython](http://ipython.org), with the additional libraries required for the notebook interface.\n",
    "* [Pandas](http://pandas.pydata.org/), Python version of R dataframe\n",
    "* [scikit-learn](http://scikit-learn.org), Machine learning library!\n",
    "\n",
    "A good, easy to install option that supports Mac, Windows, and Linux, and that has all of these packages (and much more) is the [Anaconda](https://www.continuum.io/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking your installation\n",
    "\n",
    "You can run the following code to check the versions of the packages on your system:\n",
    "\n",
    "(in IPython notebook, press `shift` and `return` together to execute the contents of a cell)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python version: 3.6.7 (default, Oct 22 2018, 11:32:17) \n",
      "[GCC 8.2.0]\n",
      "IPython: 7.2.0\n",
      "numpy: 1.15.4\n",
      "scipy: 1.2.0\n",
      "matplotlib: 3.0.2\n",
      "pandas: 0.23.4\n",
      "scikit-learn: 0.20.2\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "print('Python version:', sys.version)\n",
    "\n",
    "import IPython\n",
    "print('IPython:', IPython.__version__)\n",
    "\n",
    "import numpy\n",
    "print('numpy:', numpy.__version__)\n",
    "\n",
    "import scipy\n",
    "print('scipy:', scipy.__version__)\n",
    "\n",
    "import matplotlib\n",
    "print('matplotlib:', matplotlib.__version__)\n",
    "\n",
    "import pandas\n",
    "print('pandas:', pandas.__version__)\n",
    "\n",
    "import sklearn\n",
    "print('scikit-learn:', sklearn.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# I. Python Overview\n",
    "This is a quick introduction to Python. There are lots of other places to learn the language more thoroughly. I have collected a list of useful links, including ones to other learning resources, at the end of this notebook. If you want a little more depth, [Python Tutorial](http://docs.python.org/2/tutorial/) is a great place to start, as is Zed Shaw's [Learn Python the Hard Way](http://learnpythonthehardway.org/book/).\n",
    "\n",
    "The lessons that follow make use of the IPython notebooks. There's a good introduction to notebooks [in the IPython notebook documentation](http://ipython.org/notebook.html) that even has a [nice video](http://www.youtube.com/watch?v=H6dLGQw9yFQ#!) on how to use the notebooks. You should probably also flip through the [IPython tutorial](http://ipython.org/ipython-doc/dev/interactive/tutorial.html) in your copious free time.\n",
    "\n",
    "Briefly, notebooks have code cells (that are generally followed by result cells) and text cells. The text cells are the stuff that you're reading now. The code cells start with \"In []:\" with some number generally in the brackets. If you put your cursor in the code cell and hit Shift-Enter, the code will run in the Python interpreter and the result will print out in the output cell. You can then change things around and see whether you understand what's going on. If you need to know more, see the [IPython notebook documentation](http://ipython.org/notebook.html) or the [IPython tutorial](http://ipython.org/ipython-doc/dev/interactive/tutorial.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Python as a Calculator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many of the things I used to use a calculator for, I now use Python for:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(50-5*6)/4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(If you're typing this into an IPython notebook, or otherwise using notebook file, you hit shift-Enter to evaluate a cell.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the last few lines, we have sped by a lot of things that we should stop for a moment and explore a little more fully. We've seen, however briefly, two different data types: **integers**, also known as *whole numbers* to the non-programming world, and **floating point numbers**, also known (incorrectly) as *decimal numbers* to the rest of the world.\n",
    "\n",
    "We've also seen the first instance of an **import** statement. Python has a huge number of libraries included with the distribution. To keep things simple, most of these variables and functions are not accessible from a normal Python interactive session. Instead, you have to import the name. For example, there is a **math** module containing many useful functions. To access, say, the square root function, you can either first\n",
    "\n",
    "    from math import sqrt\n",
    "\n",
    "and then"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'sqrt' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-18128337f01f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m81\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'sqrt' is not defined"
     ]
    }
   ],
   "source": [
    "sqrt(81)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sqrt\n",
    "sqrt(81)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or you can simply import the math library itself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.sqrt(81)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can define variables using the equals (=) sign:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1256.6370614359173"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "radius = 20\n",
    "pi = math.pi\n",
    "area = pi * radius ** 2 \n",
    "area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can name a variable *almost* anything you want. It needs to start with an alphabetical character or \"\\_\", can contain alphanumeric characters plus underscores (\"\\_\"). Certain words, however, are reserved for the language:\n",
    "\n",
    "    and, as, assert, break, class, continue, def, del, elif, else, except, \n",
    "    exec, finally, for, from, global, if, import, in, is, lambda, not, or,\n",
    "    pass, print, raise, return, try, while, with, yield\n",
    "\n",
    "Trying to define a variable using one of these will result in a syntax error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-8-c7a05f6eb55e>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-8-c7a05f6eb55e>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    return = 0\u001b[0m\n\u001b[0m           ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "return = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [Python Tutorial](http://docs.python.org/2/tutorial/introduction.html#using-python-as-a-calculator) has more on using Python as an interactive shell. The [IPython tutorial](http://ipython.org/ipython-doc/dev/interactive/tutorial.html) makes a nice complement to this, since IPython has a much more sophisticated iteractive shell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "Strings are lists of printable characters, and can be defined using either single quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, World!'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello, World!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or double quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, World!'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello, World!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like the other two data objects we're familiar with (ints and floats), you can assign a string to a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting = \"Hello, World!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **print** statement is often used for printing character strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But it can also print data types other than strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "must be str, not float",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-a442573ed26f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The area is \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0marea\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: must be str, not float"
     ]
    }
   ],
   "source": [
    "print(\"The area is \" + area)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The area is 1256.6370614359173\n"
     ]
    }
   ],
   "source": [
    "print(\"The area is \" + str(area))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above snipped, the number 600 (stored in the variable \"area\") is converted into a string before being printed out."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the + operator to concatenate strings together:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Don't forget the space between the strings, if you want one there. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "statement = \"Hello, \" + \"World!\"\n",
    "print(statement)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have a lot of words to concatenate together, there are other, more efficient ways to do this. But this is fine for linking a few strings together."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "Very often in a programming language, one wants to keep a group of similar items together. Python does this using a data type called **lists**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "days_of_the_week = [\"Sunday\",\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access members of the list using the **index** of that item:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tuesday'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_the_week[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python lists, like C, but unlike Fortran, use 0 as the index of the first element of a list. Thus, in this example, the 0 element is \"Sunday\", 1 is \"Monday\", and so on. If you need to access the *n*th element from the end of the list, you can use a negative index. For example, the -1 element of a list is the last element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Saturday'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_the_week[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can add additional items to the list using the .append() command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Fortran', 'C', 'C++', 'Python']\n"
     ]
    }
   ],
   "source": [
    "languages = [\"Fortran\",\"C\",\"C++\"]\n",
    "languages.append(\"Python\")\n",
    "print(languages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **range()** command is a convenient way to make sequential lists of numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that range(n) starts at 0 and gives the sequential list of integers less than n. If you want to start at a different number, use range(start,stop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(2,8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The lists created above with range have a *step* of 1 between elements. You can also give a fixed step size via a third command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evens = list(range(0,20,2))\n",
    "evens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evens[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists do not have to hold the same data type. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Today', 7, 99.3, '']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\"Today\",7,99.3,\"\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, it's good (but not essential) to use lists for similar objects that are somehow logically connected. If you want to group different data types together into a composite data object, it's best to use **tuples**, which we will learn about below.\n",
    "\n",
    "You can find out how long a list is using the **len()** command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function len in module builtins:\n",
      "\n",
      "len(obj, /)\n",
      "    Return the number of items in a container.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(evens)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration, Indentation, and Blocks\n",
    "One of the most useful things you can do with lists is to *iterate* through them, i.e. to go through each element one at a time. To do this in Python, we use the **for** statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sunday\n",
      "Monday\n",
      "Tuesday\n",
      "Wednesday\n",
      "Thursday\n",
      "Friday\n",
      "Saturday\n"
     ]
    }
   ],
   "source": [
    "for day in days_of_the_week:\n",
    "    print(day)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code snippet goes through each element of the list called **days_of_the_week** and assigns it to the variable **day**. It then executes everything in the indented block (in this case only one line of code, the print statement) using those variable assignments. When the program has gone through every element of the list, it exists the block.\n",
    "\n",
    "(Almost) every programming language defines blocks of code in some way. In Fortran, one uses END statements (ENDDO, ENDIF, etc.) to define code blocks. In C, C++, and Perl, one uses curly braces {} to define these blocks.\n",
    "\n",
    "Python uses a colon (\":\"), followed by indentation level to define code blocks. Everything at a higher level of indentation is taken to be in the same block. In the above example the block was only a single line, but we could have had longer blocks as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today is Sunday\n",
      "Today is Monday\n",
      "Today is Tuesday\n",
      "Today is Wednesday\n",
      "Today is Thursday\n",
      "Today is Friday\n",
      "Today is Saturday\n"
     ]
    }
   ],
   "source": [
    "for day in days_of_the_week:\n",
    "    statement = \"Today is \" + day\n",
    "    print(statement)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **range()** command is particularly useful with the **for** statement to execute loops of a specified length:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The square of  0  is  0\n",
      "The square of  1  is  1\n",
      "The square of  2  is  4\n",
      "The square of  3  is  9\n",
      "The square of  4  is  16\n",
      "The square of  5  is  25\n",
      "The square of  6  is  36\n",
      "The square of  7  is  49\n",
      "The square of  8  is  64\n",
      "The square of  9  is  81\n",
      "The square of  10  is  100\n",
      "The square of  11  is  121\n",
      "The square of  12  is  144\n",
      "The square of  13  is  169\n",
      "The square of  14  is  196\n",
      "The square of  15  is  225\n",
      "The square of  16  is  256\n",
      "The square of  17  is  289\n",
      "The square of  18  is  324\n",
      "The square of  19  is  361\n"
     ]
    }
   ],
   "source": [
    "for i in range(20):\n",
    "    print(\"The square of \",i,\" is \",i*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing\n",
    "Lists and strings have something in common that you might not suspect: they can both be treated as sequences. You already know that you can iterate through the elements of a list. You can also iterate through the letters in a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S\n",
      "u\n",
      "n\n",
      "d\n",
      "a\n",
      "y\n"
     ]
    }
   ],
   "source": [
    "for letter in \"Sunday\":\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is only occasionally useful. Slightly more useful is the *slicing* operation, which you can also use on any sequence. We already know that we can use *indexing* to get the first element of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sunday'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_the_week[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want the list containing the first two elements of a list, we can do this via"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sunday', 'Monday']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_the_week[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or simply"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sunday', 'Monday']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_the_week[:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want the last items of the list, we can do this with negative slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Friday', 'Saturday']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_the_week[-2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which is somewhat logically consistent with negative indices accessing the last elements of the list.\n",
    "\n",
    "You can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']\n"
     ]
    }
   ],
   "source": [
    "workdays = days_of_the_week[1:6]\n",
    "print(workdays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since strings are sequences, you can also do this to them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sun\n"
     ]
    }
   ],
   "source": [
    "day = \"Sunday\"\n",
    "abbreviation = day[:3]\n",
    "print(abbreviation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we really want to get fancy, we can pass a third element into the slice, which specifies a step length (just like a third argument to the **range()** function specifies the step):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = list(range(0,40))\n",
    "evens = numbers[2::2]\n",
    "evens"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that in this example I was even able to omit the second argument, so that the slice started at 2, went to the end of the list, and took every second element, to generate the list of even numbers less that 40."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Booleans and Truth Testing\n",
    "We have now learned a few data types. We have integers and floating point numbers, strings, and lists to contain them. We have also learned about lists, a container that can hold any data type. We have learned to print things out, and to iterate over items in lists. We will now learn about **boolean** variables that can be either True or False.\n",
    "\n",
    "We invariably need some concept of *conditions* in programming to control branching behavior, to allow a program to react differently to different situations. If it's Monday, I'll go to work, but if it's Sunday, I'll sleep in. To do this in Python, we use a combination of **boolean** variables, which evaluate to either True or False, and **if** statements, that control branching based on boolean values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sleep in\n"
     ]
    }
   ],
   "source": [
    "if day == \"Sunday\":\n",
    "    print(\"Sleep in\")\n",
    "else:\n",
    "    print(\"Go to work\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Quick quiz: why did the snippet print \"Go to work\" here? What is the variable \"day\" set to?)\n",
    "\n",
    "Let's take the snippet apart to see what happened. First, note the statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day == \"Sunday\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we evaluate it by itself, as we just did, we see that it returns a boolean value, False. The \"==\" operator performs *equality testing*. If the two items are equal, it returns True, otherwise it returns False. In this case, it is comparing two variables, the string \"Sunday\", and whatever is stored in the variable \"day\", which, in this case, is the other string \"Saturday\". Since the two strings are not equal to each other, the truth test has the false value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The if statement that contains the truth test is followed by a code block (a colon followed by an indented block of code). If the boolean is true, it executes the code in that block. Since it is false in the above example, we don't see that code executed.\n",
    "\n",
    "The first block of code is followed by an **else** statement, which is executed if nothing else in the above if statement is true. Since the value was false, this code is executed, which is why we see \"Go to work\".\n",
    "\n",
    "You can compare any data types in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "50 == 2*25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 < 3.14159"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 != 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 <= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 >= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see a few other boolean operators here, all of which which should be self-explanatory. Less than, equality, non-equality, and so on.\n",
    "\n",
    "Particularly interesting is the 1 == 1.0 test, which is true, since even though the two objects are different data types (integer and floating point number), they have the same *value*. There is another boolean operator **is**, that tests whether two objects are the same object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 is 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do boolean tests on lists as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] == [1,2,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] < [1,2,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, note that you can also string multiple comparisons together, which can result in very intuitive tests:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hours = 5\n",
    "0 < hours < 24"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If statements can have **elif** parts (\"else if\"), in addition to if/else parts. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sleep in\n"
     ]
    }
   ],
   "source": [
    "if day == \"Sunday\":\n",
    "    print(\"Sleep in\")\n",
    "elif day == \"Saturday\":\n",
    "    print(\"Do chores\")\n",
    "else:\n",
    "    print(\"Go to work\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course we can combine if statements with for loops, to make a snippet that is almost interesting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today is Sunday\n",
      "   Sleep in\n",
      "Today is Monday\n",
      "   Go to work\n",
      "Today is Tuesday\n",
      "   Go to work\n",
      "Today is Wednesday\n",
      "   Go to work\n",
      "Today is Thursday\n",
      "   Go to work\n",
      "Today is Friday\n",
      "   Go to work\n",
      "Today is Saturday\n",
      "   Do chores\n"
     ]
    }
   ],
   "source": [
    "for day in days_of_the_week:\n",
    "    statement = \"Today is \" + day\n",
    "    print(statement)\n",
    "    if day == \"Sunday\":\n",
    "        print(\"   Sleep in\")\n",
    "    elif day == \"Saturday\":\n",
    "        print(\"   Do chores\")\n",
    "    else:\n",
    "        print(\"   Go to work\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is something of an advanced topic, but ordinary data types have boolean values associated with them, and, indeed, in early versions of Python there was not a separate boolean object. Essentially, anything that was a 0 value (the integer or floating point 0, an empty string \"\", or an empty list []) was False, and everything else was true. You can see the boolean value of any data object using the **bool()** function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool([\"This \",\" is \",\" a \",\" list\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code Example: The Fibonacci Sequence\n",
    "The [Fibonacci sequence](http://en.wikipedia.org/wiki/Fibonacci_number) is a sequence in math that starts with 0 and 1, and then each successive entry is the sum of the previous two. Thus, the sequence goes 0,1,1,2,3,5,8,13,21,34,55,89,...\n",
    "\n",
    "A very common exercise in programming books is to compute the Fibonacci sequence up to some number **n**. First I'll show the code, then I'll discuss what it is doing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "sequence = [0,1]\n",
    "for i in range(2,n): # This is going to be a problem if we ever set n <= 2!\n",
    "    sequence.append(sequence[i-1]+sequence[i-2])\n",
    "print(sequence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's go through this line by line. First, we define the variable **n**, and set it to the integer 20. **n** is the length of the sequence we're going to form, and should probably have a better variable name. We then create a variable called **sequence**, and initialize it to the list with the integers 0 and 1 in it, the first two elements of the Fibonacci sequence. We have to create these elements \"by hand\", since the iterative part of the sequence requires two previous elements.\n",
    "\n",
    "We then have a for loop over the list of integers from 2 (the next element of the list) to **n** (the length of the sequence). After the colon, we see a hash tag \"#\", and then a **comment** that if we had set **n** to some number less than 2 we would have a problem. Comments in Python start with #, and are good ways to make notes to yourself or to a user of your code explaining why you did what you did. Better than the comment here would be to test to make sure the value of **n** is valid, and to complain if it isn't; we'll try this later.\n",
    "\n",
    "In the body of the loop, we append to the list an integer equal to the sum of the two previous elements of the list.\n",
    "\n",
    "After exiting the loop (ending the indentation) we then print out the whole list. That's it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "We might want to use the Fibonacci snippet with different sequence lengths. We could cut an paste the code into another cell, changing the value of **n**, but it's easier and more useful to make a function out of the code. We do this with the **def** statement in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(sequence_length):\n",
    "    \"Return the Fibonacci sequence of length *sequence_length*\"\n",
    "    sequence = [0,1]\n",
    "    if sequence_length < 1:\n",
    "        print(\"Fibonacci sequence only defined for length 1 or greater\")\n",
    "        return\n",
    "    if 0 < sequence_length < 3:\n",
    "        return sequence[:sequence_length]\n",
    "    for i in range(2,sequence_length): \n",
    "        sequence.append(sequence[i-1]+sequence[i-2])\n",
    "    return sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now call **fibonacci()** for different sequence_lengths:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've introduced a several new features here. First, note that the function itself is defined as a code block (a colon followed by an indented block). This is the standard way that Python delimits things. Next, note that the first line of the function is a single string. This is called a **docstring**, and is a special kind of comment that is often available to people using the function through the python command line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function fibonacci in module __main__:\n",
      "\n",
      "fibonacci(sequence_length)\n",
      "    Return the Fibonacci sequence of length *sequence_length*\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(fibonacci)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you define a docstring for all of your functions, it makes it easier for other people to use them, since they can get help on the arguments and return values of the function.\n",
    "\n",
    "Next, note that rather than putting a comment in about what input values lead to errors, we have some testing of these values, followed by a warning if the value is invalid, and some conditional code to handle special cases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two More Data Structures: Tuples and Dictionaries\n",
    "Before we end the Python overview, I wanted to touch on two more data structures that are very useful (and thus very common) in Python programs.\n",
    "\n",
    "A **tuple** is a sequence object like a list or a string. It's constructed by grouping a sequence of objects together with commas, either without brackets, or with parentheses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 'hi', 9.0)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (1,2,'hi',9.0)\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are like lists, in that you can access the elements using indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, tuples are *immutable*, you can't append to them or change the elements of them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-63-91f1b43b8697>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "t.append(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-64-421dc5a1d5b5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m77\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t[1]=77"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are useful anytime you want to group different pieces of data together in an object, but don't want to create a full-fledged class (see below) for them. For example, let's say you want the Cartesian coordinates of some objects in your program. Tuples are a good way to do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Bob', 0.0, 21.0)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "('Bob',0.0,21.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, it's not a necessary distinction, but one way to distinguish tuples and lists is that tuples are a collection of different things, here a name, and x and y coordinates, whereas a list is a collection of similar things, like if we wanted a list of those coordinates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "positions = [\n",
    "             ('Bob',0.0,21.0),\n",
    "             ('Cat',2.5,13.1),\n",
    "             ('Dog',33.0,1.2)\n",
    "             ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples can be used when functions return more than one value. Say we wanted to compute the smallest x- and y-coordinates of the above list of objects. We could write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 1.2\n"
     ]
    }
   ],
   "source": [
    "def minmax(objects):\n",
    "    minx = 1e20 # These are set to really big numbers\n",
    "    miny = 1e20\n",
    "    for obj in objects:\n",
    "        name,x,y = obj\n",
    "        if x < minx: \n",
    "            minx = x\n",
    "        if y < miny:\n",
    "            miny = y\n",
    "    return minx,miny\n",
    "\n",
    "x,y = minmax(positions)\n",
    "print(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionaries** are an object called \"mappings\" or \"associative arrays\" in other languages. Whereas a list associates an integer index with a set of objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [1,2,9,21]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The index in a dictionary is called the *key*, and the corresponding dictionary entry is the *value*. A dictionary can use (almost) anything as the key. Whereas lists are formed with square brackets [], dictionaries use curly brackets {}:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rick's age is  46\n"
     ]
    }
   ],
   "source": [
    "ages = {\"Rick\": 46, \"Bob\": 86, \"Fred\": 21}\n",
    "print(\"Rick's age is \",ages[\"Rick\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's also a convenient way to create dictionaries without having to quote the keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Rick': 46, 'Bob': 86, 'Fred': 20}"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(Rick=46,Bob=86,Fred=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **len()** command works on both tuples and dictionaries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion of the Python Overview\n",
    "There is, of course, much more to the language than I've covered here. I've tried to keep this brief enough so that you can jump in and start using Python to simplify your life and work. My own experience in learning new things is that the information doesn't \"stick\" unless you try and use it for something in real life.\n",
    "\n",
    "You will no doubt need to learn more as you go. I've listed several other good references, including the [Python Tutorial](http://docs.python.org/2/tutorial/) and [Learn Python the Hard Way](http://learnpythonthehardway.org/book/). Additionally, now is a good time to start familiarizing yourself with the [Python Documentation](http://docs.python.org/2.7/), and, in particular, the [Python Language Reference](http://docs.python.org/2.7/reference/index.html).\n",
    "\n",
    "Tim Peters, one of the earliest and most prolific Python contributors, wrote the \"Zen of Python\", which can be accessed via the \"import this\" command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No matter how experienced a programmer you are, these are words to meditate on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# II. Numpy and Scipy\n",
    "\n",
    "[Numpy](http://numpy.org) contains core routines for doing fast vector, matrix, and linear algebra-type operations in Python. [Scipy](http://scipy) contains additional routines for optimization, special functions, and so on. Both contain modules written in C and Fortran so that they're as fast as possible. Together, they give Python roughly the same capability that the [Matlab](http://www.mathworks.com/products/matlab/) program offers. (In fact, if you're an experienced Matlab user, there a [guide to Numpy for Matlab users](http://www.scipy.org/NumPy_for_Matlab_Users) just for you.)\n",
    "\n",
    "## Making vectors and matrices\n",
    "Fundamental to both Numpy and Scipy is the ability to work with vectors and matrices. You can create vectors from lists using the **array** command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array = np.array([1,2,3,4,5,6])\n",
    "array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "size of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6,)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To build matrices, you can either use the array command with lists of lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [1, 0]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.array([[0,1],[1,0]])\n",
    "mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add a column of ones to mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 1.],\n",
       "       [1., 0., 1.]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat2 = np.c_[mat, np.ones(2)]\n",
    "mat2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "size of a matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat2.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also form empty (zero) matrices of arbitrary shape (including vectors, which Numpy treats as vectors with one row), using the **zeros** command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's also an **identity** command that behaves as you'd expect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.identity(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "as well as a **ones** command."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linspace, matrix functions, and plotting\n",
    "The **linspace** command makes a linear array of points from a starting to an ending value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.02040816, 0.04081633, 0.06122449, 0.08163265,\n",
       "       0.10204082, 0.12244898, 0.14285714, 0.16326531, 0.18367347,\n",
       "       0.20408163, 0.2244898 , 0.24489796, 0.26530612, 0.28571429,\n",
       "       0.30612245, 0.32653061, 0.34693878, 0.36734694, 0.3877551 ,\n",
       "       0.40816327, 0.42857143, 0.44897959, 0.46938776, 0.48979592,\n",
       "       0.51020408, 0.53061224, 0.55102041, 0.57142857, 0.59183673,\n",
       "       0.6122449 , 0.63265306, 0.65306122, 0.67346939, 0.69387755,\n",
       "       0.71428571, 0.73469388, 0.75510204, 0.7755102 , 0.79591837,\n",
       "       0.81632653, 0.83673469, 0.85714286, 0.87755102, 0.89795918,\n",
       "       0.91836735, 0.93877551, 0.95918367, 0.97959184, 1.        ])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you provide a third argument, it takes that as the number of points in the space. If you don't provide the argument, it gives a length 50 linear space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0,1,11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**linspace** is an easy way to make coordinates for plotting. Functions in the numpy library (all of which are imported into IPython notebook) can act on an entire vector (or even a matrix) of points at once. Thus,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.00000000e+00,  1.27877162e-01,  2.53654584e-01,  3.75267005e-01,\n",
       "        4.90717552e-01,  5.98110530e-01,  6.95682551e-01,  7.81831482e-01,\n",
       "        8.55142763e-01,  9.14412623e-01,  9.58667853e-01,  9.87181783e-01,\n",
       "        9.99486216e-01,  9.95379113e-01,  9.74927912e-01,  9.38468422e-01,\n",
       "        8.86599306e-01,  8.20172255e-01,  7.40277997e-01,  6.48228395e-01,\n",
       "        5.45534901e-01,  4.33883739e-01,  3.15108218e-01,  1.91158629e-01,\n",
       "        6.40702200e-02, -6.40702200e-02, -1.91158629e-01, -3.15108218e-01,\n",
       "       -4.33883739e-01, -5.45534901e-01, -6.48228395e-01, -7.40277997e-01,\n",
       "       -8.20172255e-01, -8.86599306e-01, -9.38468422e-01, -9.74927912e-01,\n",
       "       -9.95379113e-01, -9.99486216e-01, -9.87181783e-01, -9.58667853e-01,\n",
       "       -9.14412623e-01, -8.55142763e-01, -7.81831482e-01, -6.95682551e-01,\n",
       "       -5.98110530e-01, -4.90717552e-01, -3.75267005e-01, -2.53654584e-01,\n",
       "       -1.27877162e-01, -2.44929360e-16])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.linspace(0,2*np.pi)\n",
    "np.sin(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In conjunction with **matplotlib**, this is a nice way to plot things:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff2b78345c0>]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.plot(x,np.sin(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix operations\n",
    "Matrix objects act sensibly when multiplied by scalars:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.125, 0.   , 0.   ],\n",
       "       [0.   , 0.125, 0.   ],\n",
       "       [0.   , 0.   , 0.125]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.125*np.identity(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "as well as when you add two matrices together. (However, the matrices have to be the same shape.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 1.],\n",
       "       [1., 3.]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.identity(2) + np.array([[1,1],[1,2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Something that confuses Matlab users is that the times (*) operator give element-wise multiplication rather than matrix multiplication:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.identity(2)*np.ones((2,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get matrix multiplication, you need the **dot** command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [1., 1.]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(np.identity(2),np.ones((2,2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**dot** can also do dot products (duh!):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.array([3,4])\n",
    "np.sqrt(np.dot(v,v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "as well as matrix-vector products."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are **determinant**, **inverse**, and **transpose** functions that act as you would suppose. Transpose can be abbreviated with \".T\" at the end of a matrix object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [2, 4]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = np.array([[1,2],[3,4]])\n",
    "m.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2. ,  1. ],\n",
       "       [ 1.5, -0.5]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.inv(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's also a **diag()** function that takes a list or a vector and puts it along the diagonal of a square matrix. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0, 0, 0],\n",
       "       [0, 2, 0, 0, 0],\n",
       "       [0, 0, 3, 0, 0],\n",
       "       [0, 0, 0, 4, 0],\n",
       "       [0, 0, 0, 0, 5]])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll find this useful later on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Least squares fitting\n",
    "Very often we deal with some data that we want to fit to some sort of expected behavior. Say we have the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_data = \"\"\"\\\n",
    "3.1905781584582433,0.028208609537968457\n",
    "4.346895074946466,0.007160804747670053\n",
    "5.374732334047101,0.0046962988461934805\n",
    "8.201284796573875,0.0004614473299618756\n",
    "10.899357601713055,0.00005038370219939726\n",
    "16.295503211991434,4.377451812785309e-7\n",
    "21.82012847965739,3.0799922117601088e-9\n",
    "32.48394004282656,1.524776208284536e-13\n",
    "43.53319057815846,5.5012073588707224e-18\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's a section below on parsing CSV data. We'll steal the parser from that. For an explanation, skip ahead to that section. Otherwise, just assume that this is a way to parse that text into a numpy array that we can plot and do other analyses with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = []\n",
    "for line in raw_data.splitlines():\n",
    "    words = line.split(',')\n",
    "    data.append(words)\n",
    "data = np.array(data, dtype=np.float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3.19057816e+00, 2.82086095e-02],\n",
       "       [4.34689507e+00, 7.16080475e-03],\n",
       "       [5.37473233e+00, 4.69629885e-03],\n",
       "       [8.20128480e+00, 4.61447330e-04],\n",
       "       [1.08993576e+01, 5.03837022e-05],\n",
       "       [1.62955032e+01, 4.37745181e-07],\n",
       "       [2.18201285e+01, 3.07999221e-09],\n",
       "       [3.24839400e+01, 1.52477621e-13],\n",
       "       [4.35331906e+01, 5.50120736e-18]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3.19057816,  4.34689507,  5.37473233,  8.2012848 , 10.8993576 ,\n",
       "       16.29550321, 21.82012848, 32.48394004, 43.53319058])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[:, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff2b3fc8f60>]"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEaCAYAAAAR0SDgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAHK9JREFUeJzt3X+YnWV95/H3TUboqDFoxrhMwlpW0t3GdpeWGrQ/rMjCFVs0LqVfflWxpWZbS39ssXEsrbVU26HdatkWbVNUwCLstzRcTWsVq9FavBDxV7cG+iNglGRUHESMmkKTPPvHcw8ehsnMmcxkzsnM+3Vdc805z7mf53zPDTmfc9/3mecpTdMgSdIxvS5AktQfDARJEmAgSJIqA0GSBBgIkqTKQJAkAQaCJKkyEHTUK6VcW0pp6s+BUsruUsr1pZTVPa7l30sp46WU20opm0spTzqM4+0vpbziCJQqPY6BoMXi74ETgP8IXAh8D/DnPa7lmcDpwA3ApcAnSynP6FFN0owMBC0WjzRN88WmafY0TfNhYAvwvFLKUyYalFIuLKXcUUp5qH5yf3cp5Ts6Hn9nKeWGjvs/WT/p/3THthtKKTd2WctY0zT/2DTNW4HnAU8HRjuOdWYp5UOllK/Umv6ulLK+4/FdwDLgHROjjrr9qaWUPyulfL6Usq+U8s+llMtKKeUw+04CDAQtQqWUYeBc4ED9mXAc8Abge4Ez62PvLqUcWx//IO0n+gkvBL5cf084Hdg+25qaptlDO1I4p5Qy8e/uycBbaMPi+4F/Bd5bSllZH39OrfGXaEccJ3S8js8ALwXWAb8F/CbwitnWJXUa6HUB0jx5QSnl67Qfcgbrtt9vmuYbEw2apnlH5w51bv4B2jfej9C+0Z9QSlnXNM1dtG/+VwKvru2/k/ZNedaBUO0AngIMAfc3TXPLpHo2AT8GbABuaJrmy/VD/0NN03yx43V8kY6RBvDZUspzaKfKHvMapdlwhKDF4g7gFGA97Sfm24Ff62xQSjmllHJLKeWzpZS9wOfrQ88EaJpmF7ALeGEp5T8Dx9N+gn9iKWUd7Ujh803T3HOYNU5M6UxM/ZxUp6l2llK+BnwNWDFRzyEPUsoxpZSRUsqn69TX14GfmWk/aSaOELRY7GuaZme9/ZlSyrOAPwReCVBKeSLwPuA24CeBL9W2O4BjO46zHTiDdqrmtqZp9pVSPkwbBoc1XdTh2cBDtKMSgL8GxoGfA+4DHqn1HTvl3t9yGfBa4H8BnwL21ts/OofaJANBi9brgbtLKX/SNM3Hge+kXdS9vGmauwFKKd/Ptz61T/gg8H+Ag8AH6raJkHg+7Xz+rNWvwF4EbG2a5mBdJ1gH/EjTNLfWNmuAVZN2fYR2YbnT84H3Nk3z9o7jrz2cuqROThlpUWqa5l+BvwLeWDd9DngY+PlSyrNKKWcAV1GnbzpsB54KvIRvjQa2A2cDT6O7EcKxpZT/UEoZLqV8dynlZ2mnsO6n/WQP8CDtgvUrSynfUUp5HnAjsG/SsT4LnF6PNVS3/TPtmsnpdd83AKd1UZc0LQNBi9nvAWeVUl7QNM048BO03y7aAfxv2sXig507NE0zBvwL7TTMp+rm/wd8FfiX+m2hmfwQ8AXaNYoP0Y4M/gj43qZpvlSf5yDw48Cz6vGvBf6g7tfpMuBU2rWNL9dtvwX8HfCXtEHzVNpRjTQnxSumSZLAEYIkqTIQJEmAgSBJqgwESRJw9P0dgivgknR4Zjz54dEWCIyNjS3o8w0NDTE+Pr6gzzmTfqwJrGs2+rEmsK7Z6se6pqppeHi4q32dMpIkAQaCJKkyECRJgIEgSaoMBEkSsAQCYevWQdavX8WaNSewfv0qtm4dnHknSVqCjrqvnc7G1q2DbN68gn372tzbs2eAzZtXAHDOOZPPMixJS9uiHiGMji5/NAwm7Nt3DKOjy3tUkST1r0UdCGNjky80Nf12SVrKFnUgDA8fmNV2SVrKFnUgjIzsZXDwMRfEYnDwICMje3tUkST1r0W9qDyxcDw6upyxsWUMDx9gZGSvC8qSNIVFHQjQhoIBIEkzW9RTRpKk7hkIkiTAQJAkVQaCJAkwECRJlYEgSQIMBElSZSBIkgADQZJUGQiSJMBAkCRVBoIkCTAQJEmVgSBJAgwESVLV1fUQImIDcBWwDLgmM0cnPX4ccD1wKvAAcF5m7oqIM4FR4FjgEeBXMnN73edDwAnAxMUKzsrM++f8iiRJh2XGEUJELAOuBl4ErAMuiIh1k5pdAjyYmScDbwaurNvHgRdn5ncDFwPvnLTfRZl5Sv0xDCSph7qZMloP7MzMezPzEeAmYOOkNhuB6+rtm4EzIqJk5qcyc6xu3wEM1tGEJKnPdDNltBq4r+P+buC0Q7XJzP0R8RCwknaEMOHHgE9m5sMd294REQeAvwDekJnN5CePiE3ApnpshoaGuih5/gwMDCz4c86kH2sC65qNfqwJrGu2+rGuudS0INdUjohn004jndWx+aLM3BMRy2kD4WW06xCPkZlbgC31bjM+Pj65yRE1NDTEQj/nTPqxJrCu2ejHmsC6Zqsf65qqpuHh4a727WbKaA9wYsf9NXXblG0iYgBYQbu4TESsAW4BXp6Z90zskJl76u+9wLtop6YkST3SzQjhTmBtRJxE+8Z/PnDhpDbbaBeNbwfOBbZnZhMRxwPvBkYy8yMTjWtoHJ+Z4xHxBOBs4P1zfjWSpMM2YyDUNYFLgVtpv3b69szcERFXAB/PzG3A24B3RsRO4Cu0oQFwKXAy8LqIeF3ddhbwDeDWGgbLaMPgT+fxdUmSZqk0zePWcftZMzY2NnOreXS0zBH2A+vqXj/WBNY1W/1Y1zRrCGWmff1LZUkSYCBIkioDQZIEGAiSpMpAkCQBBoIkqTIQJEmAgSBJqgwESRJgIEiSKgNBkgQYCJKkykCQJAEGgiSpMhAkSYCBIEmqDARJEmAgSJIqA0GSBBgIkqTKQJAkAQaCJKkyECRJgIEgSaoMBEkSYCBIkqqBbhpFxAbgKmAZcE1mjk56/DjgeuBU4AHgvMzcFRFnAqPAscAjwK9k5va6z6nAtcAg8DfAL2ZmMx8vSpI0ezOOECJiGXA18CJgHXBBRKyb1OwS4MHMPBl4M3Bl3T4OvDgzvxu4GHhnxz5vBV4JrK0/G+bwOiRJc9TNCGE9sDMz7wWIiJuAjcBdHW02Aq+vt28G/igiSmZ+qqPNDmCwjiaeBjwlMz9aj3k98FLgPXN4LZKkOegmEFYD93Xc3w2cdqg2mbk/Ih4CVtKOECb8GPDJzHw4IlbX43Qec/VUTx4Rm4BN9dgMDQ11UfL8GRgYWPDnnEk/1gTWNRv9WBNY12z1Y11zqamrNYS5iohn004jnTXbfTNzC7Cl3m3Gx8enaz7vhoaGWOjnnEk/1gTWNRv9WBNY12z1Y11T1TQ8PNzVvt18y2gPcGLH/TV125RtImIAWEG7uExErAFuAV6emfd0tF8zwzElSQuomxHCncDaiDiJ9k37fODCSW220S4a3w6cC2zPzCYijgfeDYxk5kcmGmfmFyLiaxHxXOAO4OXAH8751UiSDtuMI4TM3A9cCtwK3N1uyh0RcUVEvKQ2exuwMiJ2Ar8MjNTtlwInA6+LiE/Xn1X1sVcB1wA7gXtwQVmSeqo0zVH11f9mbGxsQZ/waJkj7AfW1b1+rAmsa7b6sa5p1hDKTPv6l8qSJMBAkCRVBoIkCTAQJEmVgSBJAgwESVJlIEiSAANBklQZCJIkwECQJFUGgiQJMBAkSZWBIEkCDARJUmUgSJIAA0GSVBkIkiTAQJAkVQaCJAkwECRJlYEgSQIMBElSZSBIkgADQZJUGQiSJMBAkCRVA900iogNwFXAMuCazByd9PhxwPXAqcADwHmZuSsiVgI3A88Brs3MSzv2+RBwArCvbjorM++f28uRJB2uGQMhIpYBVwNnAruBOyNiW2be1dHsEuDBzDw5Is4HrgTOA/4N+HXgu+rPZBdl5sfn+BokSfOgmymj9cDOzLw3Mx8BbgI2TmqzEbiu3r4ZOCMiSmZ+IzNvow0GSVIf62bKaDVwX8f93cBph2qTmfsj4iFgJTA+w7HfEREHgL8A3pCZzeQGEbEJ2FSPzdDQUBclz5+BgYEFf86Z9GNNYF2z0Y81gXXNVj/WNZeaulpDOEIuysw9EbGcNhBeRrsO8RiZuQXYUu824+MzZcz8GhoaYqGfcyb9WBNY12z0Y01gXbPVj3VNVdPw8HBX+3YzZbQHOLHj/pq6bco2ETEArKBdXD6kzNxTf+8F3kU7NSVJ6pFuRgh3Amsj4iTaN/7zgQsntdkGXAzcDpwLbJ9q+mdCDY3jM3M8Ip4AnA28/zDqlyTNkxkDoa4JXArcSvu107dn5o6IuAL4eGZuA94GvDMidgJfoQ0NACJiF/AU4NiIeClwFvA54NYaBstow+BP5/WVSZJmpTTNIT/I96NmbGxsQZ/waJkj7AfW1b1+rAmsa7b6sa5p1hDKTPv6l8qSJMBAkCRVBoIkCTAQJEmVgSBJAgwESVJlIEiSAANBklQZCJIkwECQJFUGgiQJMBAkSZWBIEkCDARJUmUgSJIAA0GSVBkIkiTAQJAkVQaCJAkwECRJlYEgSQIMBElSZSBIkgADQZJUGQiSJMBAkCRVA900iogNwFXAMuCazByd9PhxwPXAqcADwHmZuSsiVgI3A88Brs3MSzv2ORW4FhgE/gb4xcxs5vyKJEmHZcYRQkQsA64GXgSsAy6IiHWTml0CPJiZJwNvBq6s2/8N+HXg1VMc+q3AK4G19WfD4bwASdL86GbKaD2wMzPvzcxHgJuAjZPabASuq7dvBs6IiJKZ38jM22iD4VERcQLwlMz8aB0VXA+8dC4vRJI0N91MGa0G7uu4vxs47VBtMnN/RDwErATGpznm7knHXD1Vw4jYBGyqx2ZoaKiLkufPwMDAgj/nTPqxJrCu2ejHmsC6Zqsf65pLTV2tIfRSZm4BttS7zfj4oTLmyBgaGmKhn3Mm/VgTWNds9GNNYF2z1Y91TVXT8PBwV/t2M2W0Bzix4/6aum3KNhExAKygXVye7phrZjimJGkBdTNCuBNYGxEn0b5pnw9cOKnNNuBi4HbgXGD7dN8YyswvRMTXIuK5wB3Ay4E/PIz6JUnzZMYRQmbuBy4FbgXubjfljoi4IiJeUpu9DVgZETuBXwZGJvaPiF3Am4BXRMTujm8ovQq4BtgJ3AO8Z35ekiTpcJSmOaq++t+MjY0t6BMeLXOE/cC6utePNYF1zVY/1jXNGkKZaV//UlmSBBgIkqTKQJAkAQaCJKkyECRJgIEgSaoMBEkSYCBIkioDQZIEGAiSpMpAkCQBBgIAW7cOsn79KtasOYH161exdetgr0uSpAXX9xfIOdK2bh1k8+YV7NvXZuOePQNs3rwCgHPO2dfL0iRpQS35EcLo6PJHw2DCvn3HMDq6vEcVSVJvLPlAGBtbNqvtkrRYLflAGB4+MKvtkrRYLflAGBnZy+DgwcdsGxw8yMjI3h5VJEm9seQXlScWjkdHlzM2tozh4QOMjOx1QVnSkrPkAwHaUDAAJC11S37KSJLUMhAkSYCBIEmqDARJEmAgSJIqA0GSBBgIkqSqq79DiIgNwFXAMuCazByd9PhxwPXAqcADwHmZuas+9lrgEuAA8AuZeWvdvgvYW7fvz8zvm4fXI0k6TDOOECJiGXA18CJgHXBBRKyb1OwS4MHMPBl4M3Bl3XcdcD7wbGAD8JZ6vAmnZ+YphoEk9V43U0brgZ2ZeW9mPgLcBGyc1GYjcF29fTNwRkSUuv2mzHw4Mz8L7KzHO2rceOMxXjxH0pLQzZTRauC+jvu7gdMO1SYz90fEQ8DKuv2jk/ZdXW83wPsiogH+JDO3TPXkEbEJ2FSPzdDQUBclz48bbzyGV71qGd/8ZgHai+e85jXHs3z5ci644OAMex85AwMDC9oP3bKu7vVjTWBds9WPdc2lpl6ey+gHM3NPRKwC/jYi/ikzPzy5UQ2KibBoxsfHF6zAyy9f9WgYTPjmNwuXXw5nnrlwdUw2NDTEQvZDt6yre/1YE1jXbPVjXVPVNDw83NW+3UwZ7QFO7Li/pm6bsk1EDAAraBeXD7lvZk78vh+4hT6cSvLiOZKWkm4C4U5gbUScFBHH0i4Sb5vUZhtwcb19LrA9M5u6/fyIOC4iTgLWAh+LiCdFxHKAiHgScBbwmbm/nPnlxXMkLSUzBkJm7gcuBW4F7m435Y6IuCIiXlKbvQ1YGRE7gV8GRuq+O4AE7gLeC/xcZh4AngHcFhH/AHwMeHdmvnd+X9rcjYzs5YlPbB6zzYvnSFqsStM0M7fqH83Y2NiCPuHf/u0qLr+cvrp4Tj/OW4J1zUY/1gTWNVv9WNc0awhlyh06eIGcGVxwwcGeLiBL0kLx1BWSJMBAkCRVBoIkCTAQJEmVgSBJAgwESVJlIEiSAANBklQZCJIkwECQJFUGgiQJMBAkSZWBIEkCDARJUmUgSJIAA0GSVBkIkiTAQJAkVQaCJAkwECRJlYEgSQIMBElSZSD0yNatg6xfv4o1a05g/fpVbN062OuSJC1xA70uYCnaunWQzZtXsG9fm8d79gywefMKAM45Z18vS5O0hDlC6IHR0eWPhsGEffuOYXR0eY8qkqQuRwgRsQG4ClgGXJOZo5MePw64HjgVeAA4LzN31cdeC1wCHAB+ITNv7eaYi9nY2LJZbe/G1q2DjI4uZ2xsGcPDBxgZ2dt3ow1rXBrsw/mz0H054wghIpYBVwMvAtYBF0TEuknNLgEezMyTgTcDV9Z91wHnA88GNgBviYhlXR5z0RoePjCr7TOZmILas2eApimPTkH107qENS4N9uH86UVfdjNltB7YmZn3ZuYjwE3AxkltNgLX1ds3A2dERKnbb8rMhzPzs8DOerxujrlojYzsZXDw4GO2DQ4eZGRk72Ed72iYgrLGpcE+nD+96MtupoxWA/d13N8NnHaoNpm5PyIeAlbW7R+dtO/qenumYwIQEZuATfXYDA0NdVHy/BkYGJj359y0CZYvP8jrXle47z448US44oqDXHDBk4Anzbqm6aagFrK/puurXtbY7X/DhazxSPx/NR/mWteR6sPF2l/TOdy+nEtNff8to8zcAmypd5vx8fEFff6hoSGOxHOeeWb706nbp5lc0/DwKvbsefx/yuHhA0ek9m7remwtvaux2/+GC1njkfr/aq7mWteR6sPF2l/TOdy+nKqm4eHhrp6zmymjPcCJHffX1G1TtomIAWAF7eLyofbt5pjq0nxPQR0J1rg02Ifzpxd92c0I4U5gbUScRPumfT5w4aQ224CLgduBc4HtmdlExDbgXRHxJmAYWAt8DChdHFNdmvjWQT9/s8Malwb7cP70oi9L0zQzNoqIHwH+gPYrom/PzDdGxBXAxzNzW0R8G/BO4HuArwDnZ+a9dd/LgZ8C9gO/lJnvOdQxu6i3GRsbm+1rnJN+HKr2Y01gXbPRjzWBdc1WP9Y1zZRRmWnfrgKhjxgI9GdNYF2z0Y81gXXNVj/WNZdA8C+VJUmAgSBJqgwESRJgIEiSqqNuUbnXBUjSUWrRLSqXhf6JiE/04nmPtpqs6+ivyboWR13T1DSjoy0QJElHiIEgSQIMhG5smbnJguvHmsC6ZqMfawLrmq1+rOuwazraFpUlSUeIIwRJEmAgSJKqvr9ATq9ExC5gL3AA2J+Z39ejOt4OnA3cn5nfVbc9Dfi/wLcDu4DIzAf7oK7XA68Evlyb/Wpm/s0C1nQicD3wDNq/WdmSmVf1ur+mqev19La/vg34MHAc7XvBzZn5G/W09DfRXvXwE8DL6qVue1nTtcAPAw/Vpq/IzE8vRE2T6lsGfBzYk5ln97KvpqnpWg6zrxwhTO/0zDylV2FQXQtsmLRtBPhAZq4FPlDvL7RreXxdAG+ufXbKQr65VfuByzJzHfBc4OciYh29769D1QW97a+HgRdm5n8DTgE2RMRzgStrXScDDwKX9EFNAL/S0VcLHgbVLwJ3d9zvZV8dqiY4zL4yEPpcZn6Y9hoTnTYC19Xb1wEvXdCiOGRdPZWZX8jMT9bbe2n/kaymx/01TV09lZlNZn693n1C/WmAFwI31+0L2l/T1NRzEbEG+FHgmnq/0MO+mqqmuXLK6NAa4H0R0QB/Uq/t3C+ekZlfqLe/SDsV0S8ujYiX0w5hL1voqawJEfHttBdsuoM+6q9Jdf0APe6vOt3wCeBk4GrgHuCrmbm/NtnNAofX5Joy846I+FngjRHxOuooLzMfXsi6aC/otRlYXu+vpMd9NUVNEw6rrxwhHNoPZub3Ai+iHeI/v9cFTSUzG/rkExTwVuBZtEP9LwC/34siIuLJwF/QXqHva52P9bK/pqir5/2VmQcy8xTa65qvB/7LQtcw2eSaIuK7gNfS1vYc4GnAaxaypoiYWC/7xEI+73Smqemw+8pAOITM3FN/3w/cQvuPpV98KSJOAKi/7+9xPQBk5pfqP+aDwJ/Sgz6LiCfQvunekJlb6+ae99dUdfVDf03IzK8CHwSeBxwfEROzB2tor3vey5o21Gm3pn7SfQcL31c/ALykftnkJtqpoqvobV89rqaI+LO59JWBMIWIeFJELJ+4DZwFfKa3VT3GNuDievti4C97WMujJt50q//BAvdZndN9G3B3Zr6p46Ge9teh6uqD/np6RBxfbw8CZ9Kub3wQOLc2W9D+OkRN/9QR6IV2nn5B+yozX5uZazLz24Hzge2ZeRE97KtD1PQTc+kr1xCm9gzgloiAto/elZnv7UUhEXEj8AJgKCJ2A78BjAIZEZcAnwOiT+p6QUScQjslswv4nwtc1g8ALwP+MSImvlnxq/S+vw5V1wU97q8TgOvqnP0xQGbmX0fEXcBNEfEG4FO0YdbrmrZHxNNpz9r5aeBnFrCm6byG3vXVodxwuH3lqSskSYBTRpKkykCQJAEGgiSpMhAkSYCBIEmqDAQteRHxxxHx672uQ+o1v3aqRa/+JeczaM86egC4i/Z01FvqXwnP5jg/nZnvPwJlSj3nCEFLxYszcznwTNo/VHsN/fFHRFLfcISgRW+qT/YRsR74KPBfgVcDuzPz1yJiiPZaDz8IHAR20F5s5DrgItrz9R8ArsjM342IPwd+CBgE/gH42czcUZ/jWuAbtBfmeT7tyOTCzLynPv5s2rNVngr8O3BVZv52RBxDewbLVwLH056x8mcys69ON67FxxGClqTM/Bjt6Yp/aNJDl9XtT6edZvpVoMnMlwGfpx1pPDkzf7e2fw+wFlgFfBK4YdLxzgd+E3gqsBN4I0A9V9b7gfcCw7Snev5A3efnac9B88P1sQdpT00tHVGey0hL2Rjt6YE7/Tvt+XSemZk7gb+f7gCZ+faJ2/WSmA9GxIrMnLh84S01fIiIG4CJk9udDXwxMydOef1vtNdIgPbcM5dm5u6O434+Il7Wce59ad4ZCFrKVvP4q779HvB62osjQbvwPDrVzvUEbG8Efpx2RDGxQD3Et65n+8WOXb4JPLnePpH2YjRTeSbtyRU7F7wP0I5YenIqai0NBoKWpIh4Dm0g3AacNrG9XuLyMuCyemGW7RFxZ2Z+gMdfWOdC2stz/nfas5WuoJ3eKV2UcB/tdNKhHvupzPxI1y9ImgcGgpaUiHgK7QLvVcCfZeY/1pHAxONnA/9E++n9IdpP5hOf1L8E/KeOwy2nXWR+AHgi8NuzKOWvgTdFxC/RXjntWGBdZt4B/DHtJRAvzszP1VMZf39m9sV1L7R4uaispeKvImIv7afvy2nn8n9yinZraRd7vw7cDrwlMz9YH/sd4Nci4qsR8Wrav2X4HO00zl2031rqSh2JnAm8mHZa6V+B0+vDV9Fe1Od9teaP0jGKkY4Uv3YqSQIcIUiSKgNBkgQYCJKkykCQJAEGgiSpMhAkSYCBIEmqDARJEgD/Hyf9Mljz9jpDAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title(\"Raw Data\")\n",
    "plt.xlabel(\"Distance\")\n",
    "plt.plot(data[:,0],data[:,1],'bo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we expect the data to have an exponential decay, we can plot it using a semi-log plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff2b3f96a20>]"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.title(\"Raw Data\")\n",
    "plt.xlabel(\"Distance\")\n",
    "plt.semilogy(data[:,0],data[:,1],'bo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a pure exponential decay like this, we can fit the log of the data to a straight line. The above plot suggests this is a good approximation. Given a function\n",
    "$$ y = Ae^{-ax} $$\n",
    "$$ \\log(y) = \\log(A) - ax$$\n",
    "Thus, if we fit the log of the data versus x, we should get a straight line with slope $a$, and an intercept that gives the constant $A$.\n",
    "\n",
    "There's a numpy function called **polyfit** that will fit data to a polynomial form. We'll use this to fit to a straight line (a polynomial of order 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = sp.polyfit(data[:,0],np.log(data[:,1]),1)\n",
    "a = params[0]\n",
    "A = np.exp(params[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see whether this curve fits the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff2b3ebe240>]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "x = np.linspace(1,45)\n",
    "plt.title(\"Raw Data\")\n",
    "plt.xlabel(\"Distance\")\n",
    "plt.semilogy(data[:,0],data[:,1],'bo')\n",
    "plt.semilogy(x,A*np.exp(a*x),'b-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have more complicated functions, we may not be able to get away with fitting to a simple polynomial. Consider the following data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff2b3ce1390>]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "gauss_data = \"\"\"\\\n",
    "-0.9902286902286903,1.4065274110372852e-19\n",
    "-0.7566104566104566,2.2504438576596563e-18\n",
    "-0.5117810117810118,1.9459459459459454\n",
    "-0.31887271887271884,10.621621621621626\n",
    "-0.250997150997151,15.891891891891893\n",
    "-0.1463309463309464,23.756756756756754\n",
    "-0.07267267267267263,28.135135135135133\n",
    "-0.04426734426734419,29.02702702702703\n",
    "-0.0015939015939017698,29.675675675675677\n",
    "0.04689304689304685,29.10810810810811\n",
    "0.0840994840994842,27.324324324324326\n",
    "0.1700546700546699,22.216216216216214\n",
    "0.370878570878571,7.540540540540545\n",
    "0.5338338338338338,1.621621621621618\n",
    "0.722014322014322,0.08108108108108068\n",
    "0.9926849926849926,-0.08108108108108646\"\"\"\n",
    "\n",
    "data = []\n",
    "for line in gauss_data.splitlines():\n",
    "    words = line.split(',')\n",
    "    data.append(words)\n",
    "data = np.array(data, dtype=np.float)\n",
    "\n",
    "plt.plot(data[:,0],data[:,1],'bo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This data looks more Gaussian than exponential. If we wanted to, we could use **polyfit** for this as well, but let's use the **curve_fit** function from Scipy, which can fit to arbitrary functions. You can learn more using help(curve_fit).\n",
    "\n",
    "First define a general Gaussian function to fit to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gauss(x,A,a): \n",
    "    return A*np.exp(a*x**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now fit to it using **curve_fit**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff2b164f3c8>]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "from scipy.optimize import curve_fit\n",
    "\n",
    "params,conv = curve_fit(gauss,data[:,0],data[:,1])\n",
    "x = np.linspace(-1,1)\n",
    "plt.plot(data[:,0],data[:,1],'bo')\n",
    "A,a = params\n",
    "plt.plot(x,gauss(x,A,a),'g-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **curve_fit** routine we just used is built on top of a very good general **minimization** capability in Scipy. You can learn more [at the scipy documentation pages](http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monte Carlo and random numbers\n",
    "Many methods in scientific computing rely on Monte Carlo integration, where a sequence of (pseudo) random numbers are used to approximate the integral of a function. Python has good random number generators in the standard library. The **random()** function gives pseudorandom numbers uniformly distributed between 0 and 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff2b3e64278>]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "from random import random\n",
    "rands = []\n",
    "for i in range(100):\n",
    "    rands.append(random())\n",
    "plt.plot(rands)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**random()** uses the [Mersenne Twister](http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html) algorithm, which is a highly regarded pseudorandom number generator. There are also functions to generate random integers, to randomly shuffle a list, and functions to pick random numbers from a particular distribution, like the normal distribution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff2b3e1ae10>]"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "from random import gauss\n",
    "grands = []\n",
    "for i in range(100):\n",
    "    grands.append(gauss(0,1))\n",
    "plt.plot(grands)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is generally more efficient to generate a list of random numbers all at once, particularly if you're drawing from a non-uniform distribution. Numpy has functions to generate vectors and matrices of particular types of random distributions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff2b155feb8>]"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.plot(np.random.rand(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# III. Introduction to Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Series\n",
    "\n",
    "A Series is a one-dimensional array-like object containing an array of data and an associated array of data labels.  The data can be any NumPy data type and the labels are the Series' index."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a Series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     1\n",
       "1     1\n",
       "2     2\n",
       "3    -3\n",
       "4    -5\n",
       "5     8\n",
       "6    13\n",
       "dtype: int64"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_1 = pd.Series([1, 1, 2, -3, -5, 8, 13])\n",
    "ser_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get the array representation of a Series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  1,  2, -3, -5,  8, 13])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_1.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index objects are immutable and hold the axis labels and metadata such as names and axis names.\n",
    "\n",
    "Get the index of the Series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RangeIndex(start=0, stop=7, step=1)"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_1.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a Series with a custom index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1\n",
       "b    1\n",
       "c    2\n",
       "d   -3\n",
       "e   -5\n",
       "dtype: int64"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_2 = pd.Series([1, 1, 2, -3, -5], index=['a', 'b', 'c', 'd', 'e'])\n",
    "ser_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get a value from a Series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_2[4] == ser_2['e']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get a set of values from a Series by passing in a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c    2\n",
       "a    1\n",
       "b    1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_2[['c', 'a', 'b']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get values great than 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1\n",
       "b    1\n",
       "c    2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_2[ser_2 > 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scalar multiply:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a     2\n",
       "b     2\n",
       "c     4\n",
       "d    -6\n",
       "e   -10\n",
       "dtype: int64"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_2 * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply a numpy math function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    2.718282\n",
       "b    2.718282\n",
       "c    7.389056\n",
       "d    0.049787\n",
       "e    0.006738\n",
       "dtype: float64"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(ser_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Series is like a fixed-length, ordered dict.  \n",
    "\n",
    "Create a series by passing in a dict:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "foo    100\n",
       "bar    200\n",
       "baz    300\n",
       "dtype: int64"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1 = {'foo' : 100, 'bar' : 200, 'baz' : 300}\n",
    "ser_3 = pd.Series(dict_1)\n",
    "ser_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Re-order a Series by passing in an index (indices not found are NaN):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "foo    100.0\n",
       "bar    200.0\n",
       "baz    300.0\n",
       "qux      NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = ['foo', 'bar', 'baz', 'qux']\n",
    "ser_4 = pd.Series(dict_1, index=index)\n",
    "ser_4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check for NaN with the pandas method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "foo    False\n",
       "bar    False\n",
       "baz    False\n",
       "qux     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.isnull(ser_4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check for NaN with the Series method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "foo    False\n",
       "bar    False\n",
       "baz    False\n",
       "qux     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_4.isnull()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Series automatically aligns differently indexed data in arithmetic operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bar    400.0\n",
       "baz    600.0\n",
       "foo    200.0\n",
       "qux      NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_3 + ser_4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Name a Series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "ser_4.name = 'foobarbazqux'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Name a Series index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "ser_4.index.name = 'label'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "label\n",
       "foo    100.0\n",
       "bar    200.0\n",
       "baz    300.0\n",
       "qux      NaN\n",
       "Name: foobarbazqux, dtype: float64"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rename a Series' index in place:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fo    100.0\n",
       "br    200.0\n",
       "bz    300.0\n",
       "qx      NaN\n",
       "Name: foobarbazqux, dtype: float64"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_4.index = ['fo', 'br', 'bz', 'qx']\n",
    "ser_4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DataFrame\n",
    "\n",
    "A DataFrame is a tabular data structure containing an ordered collection of columns.  Each column can have a different type.  DataFrames have both row and column indices and is analogous to a dict of Series.  Row and column operations are treated roughly symmetrically.  Columns returned when indexing a DataFrame are views of the underlying data, not a copy.  To obtain a copy, use the Series' copy method.\n",
    "\n",
    "Create a DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "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>state</th>\n",
       "      <th>year</th>\n",
       "      <th>pop</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>VA</td>\n",
       "      <td>2012</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>VA</td>\n",
       "      <td>2013</td>\n",
       "      <td>5.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>VA</td>\n",
       "      <td>2014</td>\n",
       "      <td>5.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>MD</td>\n",
       "      <td>2014</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>MD</td>\n",
       "      <td>2015</td>\n",
       "      <td>4.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  state  year  pop\n",
       "0    VA  2012  5.0\n",
       "1    VA  2013  5.1\n",
       "2    VA  2014  5.2\n",
       "3    MD  2014  4.0\n",
       "4    MD  2015  4.1"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_1 = {'state' : ['VA', 'VA', 'VA', 'MD', 'MD'],\n",
    "          'year' : [2012, 2013, 2014, 2014, 2015],\n",
    "          'pop' : [5.0, 5.1, 5.2, 4.0, 4.1]}\n",
    "df_1 = pd.DataFrame(data_1)\n",
    "df_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2012</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop\n",
       "0  2012    VA  5.0\n",
       "1  2013    VA  5.1\n",
       "2  2014    VA  5.2\n",
       "3  2014    MD  4.0\n",
       "4  2015    MD  4.1"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_2 = pd.DataFrame(data_1, columns=['year', 'state', 'pop'])\n",
    "df_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like Series, columns that are not present in the data are NaN:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2012</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop unempl\n",
       "0  2012    VA  5.0    NaN\n",
       "1  2013    VA  5.1    NaN\n",
       "2  2014    VA  5.2    NaN\n",
       "3  2014    MD  4.0    NaN\n",
       "4  2015    MD  4.1    NaN"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3 = pd.DataFrame(data_1, columns=['year', 'state', 'pop', 'unempl'])\n",
    "df_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Retrieve a column by key, returning a Series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    VA\n",
       "1    VA\n",
       "2    VA\n",
       "3    MD\n",
       "4    MD\n",
       "Name: state, dtype: object"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3['state']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Retrive a column by attribute, returning a Series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2012\n",
       "1    2013\n",
       "2    2014\n",
       "3    2014\n",
       "4    2015\n",
       "Name: year, dtype: int64"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3.year"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Retrieve a row by position:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "year      2012\n",
       "state       VA\n",
       "pop          5\n",
       "unempl     NaN\n",
       "Name: 0, dtype: object"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3.iloc[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Update a column by assignment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2012</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop  unempl\n",
       "0  2012    VA  5.0       0\n",
       "1  2013    VA  5.1       1\n",
       "2  2014    VA  5.2       2\n",
       "3  2014    MD  4.0       3\n",
       "4  2015    MD  4.1       4"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3['unempl'] = np.arange(5)\n",
    "df_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assign a Series to a column (note if assigning a list or array, the length must match the DataFrame, unlike a Series):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2012</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "      <td>6.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop  unempl\n",
       "0  2012    VA  5.0     NaN\n",
       "1  2013    VA  5.1     NaN\n",
       "2  2014    VA  5.2     6.0\n",
       "3  2014    MD  4.0     6.0\n",
       "4  2015    MD  4.1     6.1"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unempl = pd.Series([6.0, 6.0, 6.1], index=[2, 3, 4])\n",
    "df_3['unempl'] = unempl\n",
    "df_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assign a new column that doesn't exist to create a new column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "      <th>state_dup</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2012</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>VA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "      <td>VA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>6.0</td>\n",
       "      <td>VA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>MD</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "      <td>6.1</td>\n",
       "      <td>MD</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop  unempl state_dup\n",
       "0  2012    VA  5.0     NaN        VA\n",
       "1  2013    VA  5.1     NaN        VA\n",
       "2  2014    VA  5.2     6.0        VA\n",
       "3  2014    MD  4.0     6.0        MD\n",
       "4  2015    MD  4.1     6.1        MD"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3['state_dup'] = df_3['state']\n",
    "df_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Delete a column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2012</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "      <td>6.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop  unempl\n",
       "0  2012    VA  5.0     NaN\n",
       "1  2013    VA  5.1     NaN\n",
       "2  2014    VA  5.2     6.0\n",
       "3  2014    MD  4.0     6.0\n",
       "4  2015    MD  4.1     6.1"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del df_3['state_dup']\n",
    "df_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transpose the DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <td>2012</td>\n",
       "      <td>2013</td>\n",
       "      <td>2014</td>\n",
       "      <td>2014</td>\n",
       "      <td>2015</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>state</th>\n",
       "      <td>VA</td>\n",
       "      <td>VA</td>\n",
       "      <td>VA</td>\n",
       "      <td>MD</td>\n",
       "      <td>MD</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pop</th>\n",
       "      <td>5</td>\n",
       "      <td>5.1</td>\n",
       "      <td>5.2</td>\n",
       "      <td>4</td>\n",
       "      <td>4.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>unempl</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>6.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           0     1     2     3     4\n",
       "year    2012  2013  2014  2014  2015\n",
       "state     VA    VA    VA    MD    MD\n",
       "pop        5   5.1   5.2     4   4.1\n",
       "unempl   NaN   NaN     6     6   6.1"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a DataFrame from a nested dict of dicts (the keys in the inner dicts are unioned and sorted to form the index in the result, unless an explicit index is specified):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "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>VA</th>\n",
       "      <th>MD</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013</th>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2014</th>\n",
       "      <td>5.2</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2015</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       VA   MD\n",
       "2013  5.1  NaN\n",
       "2014  5.2  4.0\n",
       "2015  NaN  4.1"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop = {'VA' : {2013 : 5.1, 2014 : 5.2},\n",
    "       'MD' : {2014 : 4.0, 2015 : 4.1}}\n",
    "df_4 = pd.DataFrame(pop)\n",
    "df_4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a DataFrame from a dict of Series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "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>VA</th>\n",
       "      <th>MD</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2014</th>\n",
       "      <td>5.2</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2015</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       VA   MD\n",
       "2014  5.2  NaN\n",
       "2015  NaN  4.1"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_2 = {'VA' : df_4['VA'][1:],\n",
    "          'MD' : df_4['MD'][2:]}\n",
    "df_5 = pd.DataFrame(data_2)\n",
    "df_5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set the DataFrame index name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "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>VA</th>\n",
       "      <th>MD</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2014</th>\n",
       "      <td>5.2</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2015</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       VA   MD\n",
       "year          \n",
       "2014  5.2  NaN\n",
       "2015  NaN  4.1"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_5.index.name = 'year'\n",
    "df_5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set the DataFrame columns name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "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>state</th>\n",
       "      <th>VA</th>\n",
       "      <th>MD</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2014</th>\n",
       "      <td>5.2</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2015</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "state   VA   MD\n",
       "year           \n",
       "2014   5.2  NaN\n",
       "2015   NaN  4.1"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_5.columns.name = 'state'\n",
    "df_5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Return the data contained in a DataFrame as a 2D ndarray:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5.2, nan],\n",
       "       [nan, 4.1]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_5.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the columns are different dtypes, the 2D ndarray's dtype will accomodate all of the columns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2012, 'VA', 5.0, nan],\n",
       "       [2013, 'VA', 5.1, nan],\n",
       "       [2014, 'VA', 5.2, 6.0],\n",
       "       [2014, 'MD', 4.0, 6.0],\n",
       "       [2015, 'MD', 4.1, 6.1]], dtype=object)"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reindexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a new object with the data conformed to a new index.  Any missing values are set to NaN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2012</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "      <td>6.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop  unempl\n",
       "0  2012    VA  5.0     NaN\n",
       "1  2013    VA  5.1     NaN\n",
       "2  2014    VA  5.2     6.0\n",
       "3  2014    MD  4.0     6.0\n",
       "4  2015    MD  4.1     6.1"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reindexing rows returns a new frame with the specified index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015.0</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "      <td>6.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014.0</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014.0</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013.0</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2012.0</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     year state  pop  unempl\n",
       "5     NaN   NaN  NaN     NaN\n",
       "4  2015.0    MD  4.1     6.1\n",
       "3  2014.0    MD  4.0     6.0\n",
       "2  2014.0    VA  5.2     6.0\n",
       "1  2013.0    VA  5.1     NaN\n",
       "0  2012.0    VA  5.0     NaN"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3.reindex(list(reversed(range(0, 6))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reindex columns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "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>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "      <th>year</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>VA</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>6.0</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "      <td>6.1</td>\n",
       "      <td>2015</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  state  pop  unempl  year\n",
       "0    VA  5.0     NaN  2012\n",
       "1    VA  5.1     NaN  2013\n",
       "2    VA  5.2     6.0  2014\n",
       "3    MD  4.0     6.0  2014\n",
       "4    MD  4.1     6.1  2015"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3.reindex(columns=['state', 'pop', 'unempl', 'year'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dropping Entries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drop rows from a Series or DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "      <td>6.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop  unempl\n",
       "2  2014    VA  5.2     6.0\n",
       "3  2014    MD  4.0     6.0\n",
       "4  2015    MD  4.1     6.1"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_7 = df_3.drop([0, 1])\n",
    "df_7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop\n",
       "2  2014    VA  5.2\n",
       "3  2014    MD  4.0\n",
       "4  2015    MD  4.1"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_7 = df_7.drop('unempl', axis=1)\n",
    "df_7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing, Selecting, Filtering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas supports indexing into a DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2012</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "      <td>6.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop  unempl\n",
       "0  2012    VA  5.0     NaN\n",
       "1  2013    VA  5.1     NaN\n",
       "2  2014    VA  5.2     6.0\n",
       "3  2014    MD  4.0     6.0\n",
       "4  2015    MD  4.1     6.1"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select specified columns from a DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "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>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>5.2</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4.1</td>\n",
       "      <td>6.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   pop  unempl\n",
       "0  5.0     NaN\n",
       "1  5.1     NaN\n",
       "2  5.2     6.0\n",
       "3  4.0     6.0\n",
       "4  4.1     6.1"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3[['pop', 'unempl']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select a slice from a DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2012</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop  unempl\n",
       "0  2012    VA  5.0     NaN\n",
       "1  2013    VA  5.1     NaN"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop  unempl\n",
       "1  2013    VA  5.1     NaN\n",
       "2  2014    VA  5.2     6.0"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3.iloc[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select from a DataFrame based on a filter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop  unempl\n",
       "1  2013    VA  5.1     NaN\n",
       "2  2014    VA  5.2     6.0"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3[df_3['pop'] > 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select a slice of rows from a specific column of a DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "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>year</th>\n",
       "      <th>state</th>\n",
       "      <th>pop</th>\n",
       "      <th>unempl</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2012</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014</td>\n",
       "      <td>VA</td>\n",
       "      <td>5.2</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015</td>\n",
       "      <td>MD</td>\n",
       "      <td>4.1</td>\n",
       "      <td>6.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   year state  pop  unempl\n",
       "0  2012    VA  5.0     NaN\n",
       "1  2013    VA  5.1     NaN\n",
       "2  2014    VA  5.2     6.0\n",
       "3  2014    MD  4.0     6.0\n",
       "4  2015    MD  4.1     6.1"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_3.loc[0:2, 'pop']\n",
    "df_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic and Data Alignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding DataFrame objects results in the union of index pairs for rows and columns if the pairs are not the same, resulting in NaN for indices that do not overlap:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.548814</td>\n",
       "      <td>0.715189</td>\n",
       "      <td>0.602763</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.544883</td>\n",
       "      <td>0.423655</td>\n",
       "      <td>0.645894</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.437587</td>\n",
       "      <td>0.891773</td>\n",
       "      <td>0.963663</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          a         b         c\n",
       "0  0.548814  0.715189  0.602763\n",
       "1  0.544883  0.423655  0.645894\n",
       "2  0.437587  0.891773  0.963663"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "df_8 = pd.DataFrame(np.random.rand(9).reshape((3, 3)),\n",
    "                 columns=['a', 'b', 'c'])\n",
    "df_8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "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>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.417022</td>\n",
       "      <td>0.720324</td>\n",
       "      <td>0.000114</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.302333</td>\n",
       "      <td>0.146756</td>\n",
       "      <td>0.092339</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.186260</td>\n",
       "      <td>0.345561</td>\n",
       "      <td>0.396767</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          b         c         d\n",
       "0  0.417022  0.720324  0.000114\n",
       "1  0.302333  0.146756  0.092339\n",
       "2  0.186260  0.345561  0.396767"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "df_9 = pd.DataFrame(np.random.rand(9).reshape((3, 3)),\n",
    "                 columns=['b', 'c', 'd'])\n",
    "df_9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.132211</td>\n",
       "      <td>1.323088</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0.725987</td>\n",
       "      <td>0.792650</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.078033</td>\n",
       "      <td>1.309223</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    a         b         c   d\n",
       "0 NaN  1.132211  1.323088 NaN\n",
       "1 NaN  0.725987  0.792650 NaN\n",
       "2 NaN  1.078033  1.309223 NaN"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_8 + df_9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set a fill value instead of NaN for indices that do not overlap:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.548814</td>\n",
       "      <td>1.132211</td>\n",
       "      <td>1.323088</td>\n",
       "      <td>0.000114</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.544883</td>\n",
       "      <td>0.725987</td>\n",
       "      <td>0.792650</td>\n",
       "      <td>0.092339</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.437587</td>\n",
       "      <td>1.078033</td>\n",
       "      <td>1.309223</td>\n",
       "      <td>0.396767</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          a         b         c         d\n",
       "0  0.548814  1.132211  1.323088  0.000114\n",
       "1  0.544883  0.725987  0.792650  0.092339\n",
       "2  0.437587  1.078033  1.309223  0.396767"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_10 = df_8.add(df_9, fill_value=0)\n",
    "df_10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like NumPy, pandas supports arithmetic operations between DataFrames and Series.\n",
    "\n",
    "Match the index of the Series on the DataFrame's columns, broadcasting down the rows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.003930</td>\n",
       "      <td>-0.406224</td>\n",
       "      <td>-0.530438</td>\n",
       "      <td>0.092224</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.111226</td>\n",
       "      <td>-0.054178</td>\n",
       "      <td>-0.013864</td>\n",
       "      <td>0.396653</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          a         b         c         d\n",
       "0  0.000000  0.000000  0.000000  0.000000\n",
       "1 -0.003930 -0.406224 -0.530438  0.092224\n",
       "2 -0.111226 -0.054178 -0.013864  0.396653"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_8 = df_10.iloc[0]\n",
    "df_11 = df_10 - ser_8\n",
    "df_11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Match the index of the Series on the DataFrame's columns, broadcasting down the rows and union the indices that do not match:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0\n",
       "d    1\n",
       "e    2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ser_9 = pd.Series(range(3), index=['a', 'd', 'e'])\n",
    "ser_9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>-1.000000</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.003930</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>-0.907776</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.111226</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>-0.603347</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          a   b   c         d   e\n",
       "0  0.000000 NaN NaN -1.000000 NaN\n",
       "1 -0.003930 NaN NaN -0.907776 NaN\n",
       "2 -0.111226 NaN NaN -0.603347 NaN"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_11 - ser_9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function Application and Mapping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy ufuncs (element-wise array methods) operate on pandas objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.003930</td>\n",
       "      <td>0.406224</td>\n",
       "      <td>0.530438</td>\n",
       "      <td>0.092224</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.111226</td>\n",
       "      <td>0.054178</td>\n",
       "      <td>0.013864</td>\n",
       "      <td>0.396653</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          a         b         c         d\n",
       "0  0.000000  0.000000  0.000000  0.000000\n",
       "1  0.003930  0.406224  0.530438  0.092224\n",
       "2  0.111226  0.054178  0.013864  0.396653"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_11 = np.abs(df_11)\n",
    "df_11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply a function on 1D arrays to each column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.115157\n",
       "b    0.460402\n",
       "c    0.544302\n",
       "d    0.488877\n",
       "dtype: float64"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_11.apply(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply a function on 1D arrays to each row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.000000\n",
       "1    1.032816\n",
       "2    0.575922\n",
       "dtype: float64"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_11.apply(sum, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply an element-wise Python function to a DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.00</td>\n",
       "      <td>0.41</td>\n",
       "      <td>0.53</td>\n",
       "      <td>0.09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.11</td>\n",
       "      <td>0.05</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.40</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      a     b     c     d\n",
       "0  0.00  0.00  0.00  0.00\n",
       "1  0.00  0.41  0.53  0.09\n",
       "2  0.11  0.05  0.01  0.40"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def func_3(x): \n",
    "    return '%.2f' %x\n",
    "df_11.applymap(func_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "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>c</th>\n",
       "      <th>a</th>\n",
       "      <th>b</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       c  a   b   d\n",
       "three  0  1   2   3\n",
       "one    4  5   6   7\n",
       "two    8  9  10  11"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_12 = pd.DataFrame(np.arange(12).reshape((3, 4)),\n",
    "                  index=['three', 'one', 'two'],\n",
    "                  columns=['c', 'a', 'b', 'd'])\n",
    "df_12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sort a DataFrame by its index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "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>c</th>\n",
       "      <th>a</th>\n",
       "      <th>b</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       c  a   b   d\n",
       "one    4  5   6   7\n",
       "three  0  1   2   3\n",
       "two    8  9  10  11"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_12.sort_index()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sort a DataFrame by columns in descending order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "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>d</th>\n",
       "      <th>c</th>\n",
       "      <th>b</th>\n",
       "      <th>a</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>11</td>\n",
       "      <td>8</td>\n",
       "      <td>10</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        d  c   b  a\n",
       "three   3  0   2  1\n",
       "one     7  4   6  5\n",
       "two    11  8  10  9"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_12.sort_index(axis=1, ascending=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sort a DataFrame's values by column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "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>c</th>\n",
       "      <th>a</th>\n",
       "      <th>b</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       c  a   b   d\n",
       "three  0  1   2   3\n",
       "one    4  5   6   7\n",
       "two    8  9  10  11"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_12.sort_values(by=['d', 'c'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summarizing and Computing Descriptive Statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike NumPy arrays, Pandas descriptive statistics automatically exclude missing data.  NaN values are excluded unless the entire row or column is NA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>cat1</th>\n",
       "      <th>cat2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-2.363469</td>\n",
       "      <td>1.135345</td>\n",
       "      <td>-1.017014</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.637362</td>\n",
       "      <td>-0.859907</td>\n",
       "      <td>1.772608</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-1.110363</td>\n",
       "      <td>0.181214</td>\n",
       "      <td>0.564345</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.566510</td>\n",
       "      <td>0.729976</td>\n",
       "      <td>0.372994</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.533811</td>\n",
       "      <td>-0.091973</td>\n",
       "      <td>1.913820</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.330797</td>\n",
       "      <td>1.141943</td>\n",
       "      <td>-1.129595</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>-0.850052</td>\n",
       "      <td>0.960820</td>\n",
       "      <td>-0.217418</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.158515</td>\n",
       "      <td>0.873418</td>\n",
       "      <td>-0.111383</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>-1.038039</td>\n",
       "      <td>-1.009480</td>\n",
       "      <td>-1.058257</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.656284</td>\n",
       "      <td>-0.062492</td>\n",
       "      <td>-1.738654</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          a         b         c  cat1  cat2\n",
       "0 -2.363469  1.135345 -1.017014   0.0   1.0\n",
       "1  0.637362 -0.859907  1.772608   2.0   1.0\n",
       "2 -1.110363  0.181214  0.564345   0.0   1.0\n",
       "3 -0.566510  0.729976  0.372994   2.0   1.0\n",
       "4  0.533811 -0.091973  1.913820   2.0   1.0\n",
       "5  0.330797  1.141943 -1.129595   0.0   1.0\n",
       "6 -0.850052  0.960820 -0.217418   1.0   0.0\n",
       "7  0.158515  0.873418 -0.111383   2.0   0.0\n",
       "8 -1.038039 -1.009480 -1.058257   1.0   1.0\n",
       "9  0.656284 -0.062492 -1.738654   0.0   0.0"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_15 = pd.DataFrame(np.random.randn(10, 3),\n",
    "                     columns=['a', 'b', 'c'])\n",
    "df_15['cat1'] = (np.random.rand(10) * 3).round(0)\n",
    "df_15['cat2'] = (np.random.rand(10)).round(0)\n",
    "df_15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sum and Mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a       -3.611664\n",
       "b        2.998865\n",
       "c       -0.648555\n",
       "cat1    10.000000\n",
       "cat2     7.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_15.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   -1.245137\n",
       "1    4.550063\n",
       "2    0.635196\n",
       "3    3.536459\n",
       "4    5.355658\n",
       "5    1.343144\n",
       "6    0.893349\n",
       "7    2.920550\n",
       "8   -1.105775\n",
       "9   -1.144862\n",
       "dtype: float64"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_15.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a      -0.361166\n",
       "b       0.299886\n",
       "c      -0.064856\n",
       "cat1    1.000000\n",
       "cat2    0.700000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_15.mean(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Descriptive analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    10.000000\n",
       "mean     -0.361166\n",
       "std       0.993980\n",
       "min      -2.363469\n",
       "25%      -0.991042\n",
       "50%      -0.203998\n",
       "75%       0.483057\n",
       "max       0.656284\n",
       "Name: a, dtype: float64"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_15['a'].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0    4\n",
       "0.0    4\n",
       "1.0    2\n",
       "Name: cat1, dtype: int64"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_15['cat1'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pivot tables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### group by cat1 and calculate mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>cat2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>cat1</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0.0</th>\n",
       "      <td>-0.621688</td>\n",
       "      <td>0.599003</td>\n",
       "      <td>-0.830230</td>\n",
       "      <td>0.75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1.0</th>\n",
       "      <td>-0.944046</td>\n",
       "      <td>-0.024330</td>\n",
       "      <td>-0.637837</td>\n",
       "      <td>0.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2.0</th>\n",
       "      <td>0.190794</td>\n",
       "      <td>0.162878</td>\n",
       "      <td>0.987010</td>\n",
       "      <td>0.75</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             a         b         c  cat2\n",
       "cat1                                    \n",
       "0.0  -0.621688  0.599003 -0.830230  0.75\n",
       "1.0  -0.944046 -0.024330 -0.637837  0.50\n",
       "2.0   0.190794  0.162878  0.987010  0.75"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.pivot_table(df_15, index='cat1', aggfunc=np.mean)"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}