01_Python_Jupyter_Numpy_Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Computational Memory Lab Workshop\n",
    "\n",
    "### Introduction\n",
    "Welcome to the Computational Memory Lab (CML) Workshop on Cognitive Electrophysiology! In this Jupyter Notebook for Session 1, we'll learn about Jupyter and review the basics of Numpy and Pandas. By the end of this lesson, you'll be able to start writing your own code in JupyterLab Notebooks and have some understanding of the core tools used for numerical analysis of big data in Python.\n",
    "## Learning Python Skills for Data Science\n",
    "### Introduction to Python\n",
    "\n",
    "The Scipy lectures form a comprehensive book starting with an introduction to Python and going through object-oriented programming and tools for using Python for data science, such as numpy, scipy, and pandas.  (New lab members without a strong Python background should go through every marked section of the scipy lectures here and learn the unfamiliar content.)  We recommend the following sections:\n",
    "\n",
    "[Scipy Lectures](https://scipy-lectures.org/)\n",
    "* 1.1--1.3\n",
    "* 1.4--1.4.3\n",
    "* 1.4.4.2\n",
    "* 1.5--1.6\n",
    "* 2.1.1.1--2.1.1.3\n",
    "* 2.1.2--2. 1.2.2\n",
    "* 2.1.2.5\n",
    "* 2.1.3--2.1.3.1\n",
    "* 2.2.1--2.2.1.3\n",
    "* 2.3.1.1\n",
    "* 2.4--2.4.2.2\n",
    "* 2.4.3--2.4.4\n",
    "* 3.1\n",
    "\n",
    "#### Advanced topics\n",
    "* [Numpy broadcasting](http://scipy.github.io/old-wiki/pages/EricsBroadcastingDoc)\n",
    "* [PyCon 2015 talk on names and values](https://www.youtube.com/watch?v=_AEJHKGk9ns)\n",
    "  * [Print version of talk](https://nedbatchelder.com/text/names.html)\n",
    "\n",
    "### Official Documentation\n",
    "\n",
    "For Python and all of the packages referenced here, there are official\n",
    "descriptions of the functionality available written by the creators. A\n",
    "selection of these linked here and may serve invaluable in answering\n",
    "questions as they come up. Aside from python, these all point to the latest\n",
    "version. If something seems wrong, check that the version of your package\n",
    "matches the version of the documentation you're looking at!\n",
    "\n",
    "* [Python 3.7](https://docs.python.org/3.7/)\n",
    "* [Numpy 1.19](https://numpy.org/doc/1.19/contents.html#numpy-docs-mainpage)\n",
    "* [Scipy (latest)](https://docs.scipy.org/doc/scipy/reference/)\n",
    "* [Pandas (latest)](https://pandas.pydata.org/docs/)\n",
    "* [Matplotlib (latest)](https://matplotlib.org/3.3.3/index.html)\n",
    "\n",
    "### Jupyter Notebooks for Data Science\n",
    "The Jupyter Notebook (and Jupyter Lab) is a powerful interface to IPython for data science. The notebook structure keeps figures and outputs organized with their generating code, and supports integration with text and images. This lets data scientists (like you!) keep a full log of everything that went into an analysis or manuscript. The cell-based structure of Jupyter Notebooks -- as you'll see soon -- makes it easy to tweak analyses without needing to re-run your whole pipeline, saving lots of time. \n",
    "\n",
    "If you have not already done so, please follow the instructions in the README.md file to setup your conda environment and configure JupyterLab to work with that environment.\n",
    "\n",
    "Jupyter Notebooks can do some amazing things, but we don't have the time to discuss them all. Check out this list for some inspiration: https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color:blue\"> Congrats! Now you're ready to really get started with Notebook 1. Happy learning! </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy: Efficient array / multidimensional numerical calculation in Python\n",
    "If you've used Python before, you're likely familiar with the numpy module, which essentially gifts Python with many useful array operations. If you are familiar with MATLAB, you will recognize a similarity between MATLAB features and those of numpy. Numpy lets you perform operations on large amounts of multidimensional data with near-native efficiency (meaning comparable to languages like C, C++, or Fortran).  This contrasts with the way Python lists would require lots of for-loops, which are less efficient in Python. Let's explore some of Numpy's functionality. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  7,  9, 12])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# First, the import statement\n",
    "import numpy as np\n",
    "\n",
    "# Make an array froman existing list\n",
    "np.array([0, 1, 7, 9, 12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make a sequential array\n",
    "np.arange(0, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make a matrix of zeros\n",
    "np.zeros((3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.22363456, 0.10354797, 0.03039857, 0.35278781],\n",
       "       [0.82568437, 0.88156044, 0.25022265, 0.60172066],\n",
       "       [0.61351741, 0.29010281, 0.74429954, 0.91686304]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make a matrix of random floats from 0 to 1\n",
    "np.random.random((3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0],\n",
       "       [0, 0, 0],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note that data types can be specified, e.g.\n",
    "np.zeros((3, 3), dtype='int')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with arrays\n",
    "These concepts will be very familiar to MATLAB users."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Array attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)  # seed for reproducibility\n",
    "\n",
    "x1 = np.random.randint(10, size=6)  # One-dimensional array\n",
    "x2 = np.random.randint(10, size=(3, 4))  # Two-dimensional array\n",
    "x3 = np.random.randint(10, size=(3, 4, 5))  # Three-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x3 ndim:  3\n",
      "x3 shape: (3, 4, 5)\n",
      "x3 size:  60\n",
      "x3 dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Get some array attributes\n",
    "print(\"x3 ndim: \", x3.ndim)\n",
    "print(\"x3 shape:\", x3.shape)\n",
    "print(\"x3 size: \", x3.size)\n",
    "print(\"x3 dtype:\", x3.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Array indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 0, 3, 3, 7, 9])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Remember that Python is zero-indexed, meaning the first element is at index 0!\n",
    "x1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can index into arrays in reverse order\n",
    "x1[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 5, 2, 4],\n",
       "       [7, 6, 8, 8],\n",
       "       [1, 6, 7, 7]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexing goes by row, column\n",
    "x2[1, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3  5  2  4]\n",
      " [ 7  6 99  8]\n",
      " [ 1  6  7  7]]\n"
     ]
    }
   ],
   "source": [
    "# You can reset values with the same notation\n",
    "x2[1, 2] = 99\n",
    "print(x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Array slicing\n",
    "How to access sub-arrays. The general notation is as follows: \n",
    "\n",
    "<code>\n",
    "subarr = x[start:stop:step]\n",
    "</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:5] # the first five elements "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[5:] # elements after index 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[3:7] # elements from index 3 to 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[::2] # every other element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[::-1] # array in reverse!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 8, 9])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[-3:] # last three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3,  5,  2],\n",
       "       [ 7,  6, 99]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[:2, :3] # two rows, three columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[47  3 76 52 78 15 20 99 58 23]\n"
     ]
    }
   ],
   "source": [
    "# \"Fancy indexing\" lets us use arrays/lists to access multiple elements of an array\n",
    "x = np.random.randint(100, size=10)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([52, 99, 78])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ind = [3, 7, 4]\n",
    "x[ind]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[52, 99],\n",
       "       [78, 15]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# One thing to note is that fancy indexing yields an array with the shape of the index,\n",
    "# not the original array. Watch how we create a 2D array by indexing into a 1D array.\n",
    "ind = np.array([[3, 7],\n",
    "                [4, 5]])\n",
    "x[ind]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr1: [[52 99]\n",
      " [78 15]]\n",
      "arr2: [[104.5 198.5]\n",
      " [156.5  30.5]]\n"
     ]
    }
   ],
   "source": [
    "# Vector operations allow doing operations on large amounts of data at once:\n",
    "arr1 = x[ind]\n",
    "arr2 = arr1 * 2 + 0.5\n",
    "print('arr1:', arr1)\n",
    "print('arr2:', arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean Operations\n",
    "Boolean operations are a key way to filter data by their values (called \"masks\"). The syntax is pretty simple (and almost identical to MATLAB):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False,  True,  True,  True,\n",
       "        True])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.arange(5, 15, 1)\n",
    "y > 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 12, 13, 14])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Index according to a boolean operation\n",
    "y[y > 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False False False  True  True  True False False False]\n",
      "[ True  True  True False False False False False  True  True]\n"
     ]
    }
   ],
   "source": [
    "# Multiple operations can be combined \n",
    "print((y > 8) & (y < 12))\n",
    "\n",
    "print((y > 12) | (y < 8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that <code>and</code> and <code>or</code> are also used to make Boolean comparisons in Python, but these refer to the entire object, not to bits within the object. So for most array manipulations and masking purposes, you should use \"&\" and \" | \""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numpy Recarrays\n",
    "Numpy arrays can store more than numerical data in rows and columns. They can also be given attributes (like column headers), such that each column corresponds to a different kind of information. These kinds of arrays are called structured arrays or recarrays (\"record arrays\"). You'll see them pop up a few times in CML datasets, though typically you'll be using pandas (covered tomorrow). So, we'll touch on them very briefly.\n",
    "\n",
    "Imagine that we have several categories of data on a number of people (say, name, age, and weight), and we'd like to store these values for use in a Python program. It would be possible to store these in three separate arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('name', '<U10'), ('age', '<i4'), ('weight', '<f8')]\n"
     ]
    }
   ],
   "source": [
    "name = ['Alice', 'Bob', 'Cathy', 'Doug']\n",
    "age = [25, 45, 37, 19]\n",
    "weight = [55.0, 85.5, 68.0, 61.5]\n",
    "\n",
    "# Use a compound data type for structured arrays\n",
    "data = np.zeros(4, dtype={'names':('name', 'age', 'weight'),\n",
    "                          'formats':('U10', 'i4', 'f8')})\n",
    "print(data.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here 'U10' translates to \"Unicode string of maximum length 10,\" 'i4' translates to \"4-byte (i.e., 32 bit) integer,\" and 'f8' translates to \"8-byte (i.e., 64 bit) float.\" We'll discuss other options for these type codes in the following section.\n",
    "\n",
    "Now that we've created an empty container array, we can fill the array with our lists of values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Alice', 25, 55. ) ('Bob', 45, 85.5) ('Cathy', 37, 68. )\n",
      " ('Doug', 19, 61.5)]\n"
     ]
    }
   ],
   "source": [
    "data['name'] = name\n",
    "data['age'] = age\n",
    "data['weight'] = weight\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy also provides the np.recarray class, which is almost identical to the structured arrays just described, but with one additional feature: fields can be accessed as attributes rather than as dictionary keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([25, 45, 37, 19], dtype=int32)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_rec = data.view(np.recarray)\n",
    "data_rec.age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For anything more complicated than this, you're much better off using pandas! (To be covered below.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting (matplotlib)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll be plotting often in data science, especially with the ease-of-use of the Jupyter notebook. As with other Python topics, we're going to assume some level of familiarity with basic plotting functionality and the matplotlib library. These functions should also be very familiar to those of you coming in with a MATLAB background. But let's walk through a few examples, just to re-orient ourselves. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This 'magic' command tells the notebook how to display plots. We'll use 'inline' throughout this course.\n",
    "%matplotlib inline\n",
    "\n",
    "# import statement -- the old form was 'import pylab as plt', but this is deprecated in favor of:\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Basic line plotting examples\n",
    "import numpy as np\n",
    "x = np.linspace(0, 10, 100)\n",
    "\n",
    "fig = plt.figure()\n",
    "plt.plot(x, np.sin(x), '-')\n",
    "plt.plot(x, np.cos(x), '--');\n",
    "\n",
    "# And always be sure to label your axes!\n",
    "plt.xlabel('My X Values')\n",
    "plt.ylabel('My Y Values')\n",
    "\n",
    "# Saving figures is pretty easy.\n",
    "# You can also save as png files for other purposes,\n",
    "# but pdf figures are best for publication/presentation.\n",
    "plt.savefig('sample_files/my_figure.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "matplotlib also gives us access to a set of styles, which are kinda fun. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Y Vals')"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use('seaborn-whitegrid')\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = plt.axes()\n",
    "\n",
    "x = np.linspace(0, 10, 1000)\n",
    "ax.plot(x, np.sin(x));\n",
    "\n",
    "# Try playing around with colors and styles!\n",
    "ax.plot(x, np.cos(x), color='C2', linewidth=3, linestyle='--')\n",
    "\n",
    "plt.title('My New Plot', fontsize=14)\n",
    "plt.xlabel('X Vals'); plt.ylabel('Y Vals', fontsize=12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Histograms are also incredibly useful in data science."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Count')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(3.5, 3))\n",
    "ax = plt.subplot(111)\n",
    "\n",
    "# Let's look at some synthetic distributions.\n",
    "a = np.random.randn(100)+1.5\n",
    "b = np.random.randn(100)\n",
    "\n",
    "# alpha values let us set the transparency of plotted objects.\n",
    "plt.hist(a, color='C0', alpha=0.5)\n",
    "plt.hist(b, color='C1', alpha=0.5)\n",
    "plt.xlabel('Value'); plt.ylabel('Count')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The matshow function is incredibly useful for plotting time-frequency information, or anything 2D.\n",
    "fig = plt.figure(figsize=(6, 3)); ax=plt.subplot(111)\n",
    "\n",
    "# Generate some fake 2D data.\n",
    "mydata = np.random.randn(30, 60)\n",
    "\n",
    "# The RdBu_r colormap is a nice choice. It's often useful to set the range to be symmetrical.\n",
    "plt.matshow(mydata, fignum=0, aspect='auto', cmap='RdBu_r', vmin=-3.5, vmax=3.5)\n",
    "plt.colorbar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise: Load power T-stats from an example subject (\"R1001P_powers.npy\") and create a time-frequency plot of electrode 70**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the data file R1001P_tstats.npy from the npy_files directory:\n",
    "# The os.path.join command concatenates the sample_files subdirectory with the filename\n",
    "# in an OS-independent manner.\n",
    "# Resulting data dimensions in t are [frequencies, electrodes, time bins].\n",
    "import os\n",
    "t = np.load(os.path.join('sample_files', 'R1001P_tstats.npy'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise: Create a time-frequency plot where only power values exceeding a T-stat of 2 are shown**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with Pandas\n",
    "\n",
    "Pandas is a Python module built on top of Numpy, allowing users to store and manipulate flexible data array objects with row and column headers. Essentially, it provides some Excel-like functionality to Python. The core of pandas is the <b>DataFrame</b>, which you can think of as a table (like numpy recarray) that supports any kind of data and has explicit labels for rows and columns. \n",
    "\n",
    "Before getting into DataFrames, let's first discuss the <b>Series</b> object -- pandas' version of an array, but it has some unique properties. For example, it can be indexed by non-integer data (unlike numpy arrays): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.25\n",
       "b    0.50\n",
       "c    0.75\n",
       "d    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# Create a new Series object with strings as indices.\n",
    "# By default, Series will come with standard integer indices.\n",
    "data = pd.Series([0.25, 0.5, 0.75, 1.0],\n",
    "                 index=['a', 'b', 'c', 'd'])\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# data can be retrieved via string indices (like a Python dictionary).\n",
    "data['b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    38332521\n",
       "Illinois      12882135\n",
       "Texas         26448193\n",
       "New York      19651127\n",
       "Florida       19552860\n",
       "dtype: int64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A dictionary can also be used to define a pandas Series:\n",
    "population_dict = {\n",
    "    'California': 38332521,\n",
    "    'Illinois': 12882135,\n",
    "    'Texas': 26448193,\n",
    "    'New York': 19651127,\n",
    "    'Florida': 19552860\n",
    "  }\n",
    "population = pd.Series(population_dict)\n",
    "population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    38332521\n",
       "Illinois      12882135\n",
       "Texas         26448193\n",
       "dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Series objects can be sliced, just like numpy arrays.\n",
    "population['California':'Texas']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A DataFrame is a sequence of of aligned Series objects, essentially turning indexed lists into indexed 2D arrays, or tables. For example, let's create a table of information about our states: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    423967\n",
       "Illinois      149995\n",
       "Texas         695662\n",
       "New York      141297\n",
       "Florida       170312\n",
       "dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a new Series object with info about state areas.\n",
    "area_dict = {'California': 423967, 'Illinois': 149995, 'Texas': 695662,\n",
    "             'New York': 141297, 'Florida': 170312, }\n",
    "area = pd.Series(area_dict)\n",
    "area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "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>population</th>\n",
       "      <th>area</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>38332521</td>\n",
       "      <td>423967</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Illinois</th>\n",
       "      <td>12882135</td>\n",
       "      <td>149995</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>26448193</td>\n",
       "      <td>695662</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>19651127</td>\n",
       "      <td>141297</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>19552860</td>\n",
       "      <td>170312</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            population    area\n",
       "California    38332521  423967\n",
       "Illinois      12882135  149995\n",
       "Texas         26448193  695662\n",
       "New York      19651127  141297\n",
       "Florida       19552860  170312"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "states = pd.DataFrame({'population': population,\n",
    "                       'area': area})\n",
    "states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['California', 'Illinois', 'Texas', 'New York', 'Florida'], dtype='object')\n",
      "Index(['population', 'area'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# See which indices we're using (rows).\n",
    "print(states.index)\n",
    "\n",
    "# See our column headers.\n",
    "print(states.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do note that indexing into DataFrames works a little differently than arrays. In many ways, pandas objects are more like dictionaries than arrays (but really, more of a dictionary-array hybrid):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try running states[0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    38332521\n",
       "Illinois      12882135\n",
       "Texas         26448193\n",
       "New York      19651127\n",
       "Florida       19552860\n",
       "Name: population, dtype: int64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# But now try:\n",
    "states['population']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    38332521\n",
       "Illinois      12882135\n",
       "Texas         26448193\n",
       "New York      19651127\n",
       "Florida       19552860\n",
       "Name: population, dtype: int64"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Also note that using a column name as an attribute will work.\n",
    "states.population\n",
    "\n",
    "# Although in general the dictionary-style indexing is more reliable, and can work with non-strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you really want to go back to the implicit integer index. There's a really easy way to do this, the iloc indexer: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "population    38332521\n",
       "area            423967\n",
       "Name: California, dtype: int64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the data for 'California' without using the explicit index.\n",
    "states.iloc[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "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>population</th>\n",
       "      <th>area</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>38332521</td>\n",
       "      <td>423967</td>\n",
       "      <td>90.413926</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Illinois</th>\n",
       "      <td>12882135</td>\n",
       "      <td>149995</td>\n",
       "      <td>85.883763</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>26448193</td>\n",
       "      <td>695662</td>\n",
       "      <td>38.018740</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>19651127</td>\n",
       "      <td>141297</td>\n",
       "      <td>139.076746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>19552860</td>\n",
       "      <td>170312</td>\n",
       "      <td>114.806121</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            population    area     density\n",
       "California    38332521  423967   90.413926\n",
       "Illinois      12882135  149995   85.883763\n",
       "Texas         26448193  695662   38.018740\n",
       "New York      19651127  141297  139.076746\n",
       "Florida       19552860  170312  114.806121"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Want to add a new column? It's easy! Just as if you were manipulating a Python dictionary.\n",
    "states['density'] = states['population'] / states['area']\n",
    "states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "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>population</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>19651127</td>\n",
       "      <td>139.076746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>19552860</td>\n",
       "      <td>114.806121</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          population     density\n",
       "New York    19651127  139.076746\n",
       "Florida     19552860  114.806121"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pandas methods even support combinations of indexing/slicing/masking.\n",
    "# The 'loc' method lets us only refer to explicit indices (the opposite of the iloc method)\n",
    "states.loc[states['density']>100, ['population', 'density']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    False\n",
       "Illinois      False\n",
       "Texas         False\n",
       "New York       True\n",
       "Florida        True\n",
       "Name: density, dtype: bool"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's break that down.  First the boolean mask:\n",
    "states['density']>100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>population</th>\n",
       "      <th>area</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>19651127</td>\n",
       "      <td>141297</td>\n",
       "      <td>139.076746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>19552860</td>\n",
       "      <td>170312</td>\n",
       "      <td>114.806121</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          population    area     density\n",
       "New York    19651127  141297  139.076746\n",
       "Florida     19552860  170312  114.806121"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Selecting indices by boolean mask:\n",
    "states.loc[states['density']>100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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>population</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>California</th>\n",
       "      <td>38332521</td>\n",
       "      <td>90.413926</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Illinois</th>\n",
       "      <td>12882135</td>\n",
       "      <td>85.883763</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Texas</th>\n",
       "      <td>26448193</td>\n",
       "      <td>38.018740</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>19651127</td>\n",
       "      <td>139.076746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>19552860</td>\n",
       "      <td>114.806121</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            population     density\n",
       "California    38332521   90.413926\n",
       "Illinois      12882135   85.883763\n",
       "Texas         26448193   38.018740\n",
       "New York      19651127  139.076746\n",
       "Florida       19552860  114.806121"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Column selection:\n",
    "states[['population', 'density']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>population</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>19651127</td>\n",
       "      <td>139.076746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>19552860</td>\n",
       "      <td>114.806121</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          population     density\n",
       "New York    19651127  139.076746\n",
       "Florida     19552860  114.806121"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# And put all together.\n",
    "# Selecting indices by boolean mask, and specific columns:\n",
    "states.loc[states['density']>100, ['population', 'density']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mType:\u001b[0m        property\n",
       "\u001b[0;31mString form:\u001b[0m <property object at 0x2b8661b8d710>\n",
       "\u001b[0;31mDocstring:\u001b[0m  \n",
       "Access a group of rows and columns by label(s) or a boolean array.\n",
       "\n",
       "``.loc[]`` is primarily label based, but may also be used with a\n",
       "boolean array.\n",
       "\n",
       "Allowed inputs are:\n",
       "\n",
       "- A single label, e.g. ``5`` or ``'a'``, (note that ``5`` is\n",
       "  interpreted as a *label* of the index, and **never** as an\n",
       "  integer position along the index).\n",
       "- A list or array of labels, e.g. ``['a', 'b', 'c']``.\n",
       "- A slice object with labels, e.g. ``'a':'f'``.\n",
       "\n",
       "  .. warning:: Note that contrary to usual python slices, **both** the\n",
       "      start and the stop are included\n",
       "\n",
       "- A boolean array of the same length as the axis being sliced,\n",
       "  e.g. ``[True, False, True]``.\n",
       "- A ``callable`` function with one argument (the calling Series or\n",
       "  DataFrame) and that returns valid output for indexing (one of the above)\n",
       "\n",
       "See more at :ref:`Selection by Label <indexing.label>`\n",
       "\n",
       "Raises\n",
       "------\n",
       "KeyError\n",
       "    If any items are not found.\n",
       "\n",
       "See Also\n",
       "--------\n",
       "DataFrame.at : Access a single value for a row/column label pair.\n",
       "DataFrame.iloc : Access group of rows and columns by integer position(s).\n",
       "DataFrame.xs : Returns a cross-section (row(s) or column(s)) from the\n",
       "    Series/DataFrame.\n",
       "Series.loc : Access group of values using labels.\n",
       "\n",
       "Examples\n",
       "--------\n",
       "**Getting values**\n",
       "\n",
       ">>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],\n",
       "...      index=['cobra', 'viper', 'sidewinder'],\n",
       "...      columns=['max_speed', 'shield'])\n",
       ">>> df\n",
       "            max_speed  shield\n",
       "cobra               1       2\n",
       "viper               4       5\n",
       "sidewinder          7       8\n",
       "\n",
       "Single label. Note this returns the row as a Series.\n",
       "\n",
       ">>> df.loc['viper']\n",
       "max_speed    4\n",
       "shield       5\n",
       "Name: viper, dtype: int64\n",
       "\n",
       "List of labels. Note using ``[[]]`` returns a DataFrame.\n",
       "\n",
       ">>> df.loc[['viper', 'sidewinder']]\n",
       "            max_speed  shield\n",
       "viper               4       5\n",
       "sidewinder          7       8\n",
       "\n",
       "Single label for row and column\n",
       "\n",
       ">>> df.loc['cobra', 'shield']\n",
       "2\n",
       "\n",
       "Slice with labels for row and single label for column. As mentioned\n",
       "above, note that both the start and stop of the slice are included.\n",
       "\n",
       ">>> df.loc['cobra':'viper', 'max_speed']\n",
       "cobra    1\n",
       "viper    4\n",
       "Name: max_speed, dtype: int64\n",
       "\n",
       "Boolean list with the same length as the row axis\n",
       "\n",
       ">>> df.loc[[False, False, True]]\n",
       "            max_speed  shield\n",
       "sidewinder          7       8\n",
       "\n",
       "Conditional that returns a boolean Series\n",
       "\n",
       ">>> df.loc[df['shield'] > 6]\n",
       "            max_speed  shield\n",
       "sidewinder          7       8\n",
       "\n",
       "Conditional that returns a boolean Series with column labels specified\n",
       "\n",
       ">>> df.loc[df['shield'] > 6, ['max_speed']]\n",
       "            max_speed\n",
       "sidewinder          7\n",
       "\n",
       "Callable that returns a boolean Series\n",
       "\n",
       ">>> df.loc[lambda df: df['shield'] == 8]\n",
       "            max_speed  shield\n",
       "sidewinder          7       8\n",
       "\n",
       "**Setting values**\n",
       "\n",
       "Set value for all items matching the list of labels\n",
       "\n",
       ">>> df.loc[['viper', 'sidewinder'], ['shield']] = 50\n",
       ">>> df\n",
       "            max_speed  shield\n",
       "cobra               1       2\n",
       "viper               4      50\n",
       "sidewinder          7      50\n",
       "\n",
       "Set value for an entire row\n",
       "\n",
       ">>> df.loc['cobra'] = 10\n",
       ">>> df\n",
       "            max_speed  shield\n",
       "cobra              10      10\n",
       "viper               4      50\n",
       "sidewinder          7      50\n",
       "\n",
       "Set value for an entire column\n",
       "\n",
       ">>> df.loc[:, 'max_speed'] = 30\n",
       ">>> df\n",
       "            max_speed  shield\n",
       "cobra              30      10\n",
       "viper              30      50\n",
       "sidewinder         30      50\n",
       "\n",
       "Set value for rows matching callable condition\n",
       "\n",
       ">>> df.loc[df['shield'] > 35] = 0\n",
       ">>> df\n",
       "            max_speed  shield\n",
       "cobra              30      10\n",
       "viper               0       0\n",
       "sidewinder          0       0\n",
       "\n",
       "**Getting values on a DataFrame with an index that has integer labels**\n",
       "\n",
       "Another example using integers for the index\n",
       "\n",
       ">>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],\n",
       "...      index=[7, 8, 9], columns=['max_speed', 'shield'])\n",
       ">>> df\n",
       "   max_speed  shield\n",
       "7          1       2\n",
       "8          4       5\n",
       "9          7       8\n",
       "\n",
       "Slice with integer labels for rows. As mentioned above, note that both\n",
       "the start and stop of the slice are included.\n",
       "\n",
       ">>> df.loc[7:9]\n",
       "   max_speed  shield\n",
       "7          1       2\n",
       "8          4       5\n",
       "9          7       8\n",
       "\n",
       "**Getting values with a MultiIndex**\n",
       "\n",
       "A number of examples using a DataFrame with a MultiIndex\n",
       "\n",
       ">>> tuples = [\n",
       "...    ('cobra', 'mark i'), ('cobra', 'mark ii'),\n",
       "...    ('sidewinder', 'mark i'), ('sidewinder', 'mark ii'),\n",
       "...    ('viper', 'mark ii'), ('viper', 'mark iii')\n",
       "... ]\n",
       ">>> index = pd.MultiIndex.from_tuples(tuples)\n",
       ">>> values = [[12, 2], [0, 4], [10, 20],\n",
       "...         [1, 4], [7, 1], [16, 36]]\n",
       ">>> df = pd.DataFrame(values, columns=['max_speed', 'shield'], index=index)\n",
       ">>> df\n",
       "                     max_speed  shield\n",
       "cobra      mark i           12       2\n",
       "           mark ii           0       4\n",
       "sidewinder mark i           10      20\n",
       "           mark ii           1       4\n",
       "viper      mark ii           7       1\n",
       "           mark iii         16      36\n",
       "\n",
       "Single label. Note this returns a DataFrame with a single index.\n",
       "\n",
       ">>> df.loc['cobra']\n",
       "         max_speed  shield\n",
       "mark i          12       2\n",
       "mark ii          0       4\n",
       "\n",
       "Single index tuple. Note this returns a Series.\n",
       "\n",
       ">>> df.loc[('cobra', 'mark ii')]\n",
       "max_speed    0\n",
       "shield       4\n",
       "Name: (cobra, mark ii), dtype: int64\n",
       "\n",
       "Single label for row and column. Similar to passing in a tuple, this\n",
       "returns a Series.\n",
       "\n",
       ">>> df.loc['cobra', 'mark i']\n",
       "max_speed    12\n",
       "shield        2\n",
       "Name: (cobra, mark i), dtype: int64\n",
       "\n",
       "Single tuple. Note using ``[[]]`` returns a DataFrame.\n",
       "\n",
       ">>> df.loc[[('cobra', 'mark ii')]]\n",
       "               max_speed  shield\n",
       "cobra mark ii          0       4\n",
       "\n",
       "Single tuple for the index with a single label for the column\n",
       "\n",
       ">>> df.loc[('cobra', 'mark i'), 'shield']\n",
       "2\n",
       "\n",
       "Slice from index tuple to single label\n",
       "\n",
       ">>> df.loc[('cobra', 'mark i'):'viper']\n",
       "                     max_speed  shield\n",
       "cobra      mark i           12       2\n",
       "           mark ii           0       4\n",
       "sidewinder mark i           10      20\n",
       "           mark ii           1       4\n",
       "viper      mark ii           7       1\n",
       "           mark iii         16      36\n",
       "\n",
       "Slice from index tuple to index tuple\n",
       "\n",
       ">>> df.loc[('cobra', 'mark i'):('viper', 'mark ii')]\n",
       "                    max_speed  shield\n",
       "cobra      mark i          12       2\n",
       "           mark ii          0       4\n",
       "sidewinder mark i          10      20\n",
       "           mark ii          1       4\n",
       "viper      mark ii          7       1\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# When you want to look up details of what you can do, use\n",
    "# the built-in docstrings.  You can throw a question mark after\n",
    "# the function / class name in ipython/JupyterLab, or run\n",
    "# help(states.loc) in any compliant Python interpreter.\n",
    "states.loc?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manipulating pandas DataFrames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas has some fantastic string methods for finding and manipulating data in a DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     peter\n",
       "1      Paul\n",
       "2      MARY\n",
       "3    gEORGE\n",
       "4      mark\n",
       "dtype: object"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = ['peter', 'Paul', 'MARY', 'gEORGE', 'mark']\n",
    "names = pd.Series(data)\n",
    "names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     Peter\n",
       "1      Paul\n",
       "2      Mary\n",
       "3    George\n",
       "4      Mark\n",
       "dtype: object"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names.str.capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1     True\n",
       "2    False\n",
       "3    False\n",
       "4    False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names.str.endswith('l')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Particularly useful is the .contains() method, which can be used to find strings where they appear in a column. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2     True\n",
       "3    False\n",
       "4     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names.loc[:] = names.str.capitalize()  # first lets standardize the capitalization\n",
    "names.str.contains('ar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Masking and the .query() method are your friends. You'll find yourself using these often to access subarrays of a dataframe. For example..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "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>population</th>\n",
       "      <th>area</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>19651127</td>\n",
       "      <td>141297</td>\n",
       "      <td>139.076746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>19552860</td>\n",
       "      <td>170312</td>\n",
       "      <td>114.806121</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          population    area     density\n",
       "New York    19651127  141297  139.076746\n",
       "Florida     19552860  170312  114.806121"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Similar to an example we looked at before\n",
    "states[states['density']>100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "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>population</th>\n",
       "      <th>area</th>\n",
       "      <th>density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>19651127</td>\n",
       "      <td>141297</td>\n",
       "      <td>139.076746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Florida</th>\n",
       "      <td>19552860</td>\n",
       "      <td>170312</td>\n",
       "      <td>114.806121</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          population    area     density\n",
       "New York    19651127  141297  139.076746\n",
       "Florida     19552860  170312  114.806121"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Which could also be written as:\n",
    "states.query('density>100')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try looking up the docstring on query to see some details on how it is used.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is just a taste of some of the most useful functionality in Pandas. For a full overview of all pandas functionality, check out this tutorial: https://jakevdp.github.io/PythonDataScienceHandbook/03.00-introduction-to-pandas.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assignment 1\n",
    "\n",
    "While solving this assignment, do your best to write code which would work just as well if you swapped out your analysis file with a file from a completely different subject or session.  This means don't hard-code values, but use elements of the data, as variables, to make the computer do the work of extracting what you are looking for.  Consult the docstrings and online documentation as needed to familiarize yourself with the libraries used.\n",
    "\n",
    "1. Use the Pandas CSV file reader, pd.read_csv, to open sample_files/R1292E_FR1_0_channels.csv as a Pandas DataFrame, where each row will be an intracranial EEG channel.  Examine the columns, and use the Stein Region column to extract a DataFrame of channels in the CA1 region of the hippocampus.  How many channels are in your CA1 DataFrame?\n",
    "\n",
    "2. Compare the mni.x, mni.y, and mni.z coordinate columns of the CA1 channels, and answer the question of which coordinate reveals the left versus the right hemisphere.\n",
    "\n",
    "3. Use the mni coordinate you found to make a boolean mask for separating your channels into two DataFrames, corresponding to left versus right hemisphere CA1 channels, and then create numpy arrays directly from each Pandas Series for the mni coordinates.  Use numpy to evaluate the mean and standard deviation of each coordinate axis for the left and right hemisphere CA1 channels.  Be certain that you have used a sample standard deviation, and not a population standard deviation.  If you detect any bias between these values other than that of hemisphere, consider how the data was acquired, and provide an explanation for why that might have happened.\n",
    "\n",
    "4. If time remains, use matplotlib to generate a 3D scatter plot of all the CA1 channel mni coordinates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}