{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intermediate Python: Programming\n",
    "\n",
    "# Class 1\n",
    "\n",
    "Welcome to Intermediate Python: Programming from [fredhutch.io](http://www.fredhutch.io)! \n",
    "This class assumes you've completed [Introduction to Python](https://github.com/fredhutchio/python_intro) from fredhutch.io,\n",
    "or have equivalent knowledge about Python as used for data analysis\n",
    "(basic syntax including variables and functions, \n",
    "importing data, data types and structures, subsetting data).\n",
    "This course continues to build on this framework.\n",
    "Please see our [software recommendations](http://www.fredhutch.io/software/#course-specific-software-requirements) prior to beginning these materials.\n",
    "\n",
    "By the end of this course,\n",
    "you should be able to create fully documented and automated workflows to perform data analysis tasks.\n",
    "\n",
    "We'll begin this class by reviewing a few basic features of Python relevant to data analysis: \n",
    "loading data, assigning to variables, and general syntax.\n",
    "By the end of this class,\n",
    "you should be able to:\n",
    "- use `numpy` to create and subset arrays and perform summary statistics\n",
    "- create plots with matplotlib\n",
    "- use for loops to repeat tasks across multiple data files\n",
    "\n",
    "## Getting set up\n",
    "\n",
    "We recommend using a project-oriented approach to organizing code for this course.\n",
    "Create a project directory called `python_programming/`\n",
    "to hold your data and scripts associated with this course.\n",
    "Create a new script or notebook inside that directory \n",
    "named `class1` to contain the material for this session.\n",
    "We recommend creating a new notebook for each separate class session.\n",
    "Keeping them all in the same directory will allow you to access the dataset we'll download in this class.\n",
    "\n",
    "Enter and execute the following code to access the packages we'll use to obtain the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load libraries\n",
    "import os\n",
    "import urllib.request\n",
    "import zipfile\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These libraries will be used for working with your operating system (`os`),\n",
    "downloading files from the internet (`urllib.request`),\n",
    "unzipping and extracting zipped files (`zipfile`),\n",
    "and accessing functions for scientific computing (`numpy`).\n",
    "\n",
    "We'll get started by downloading our data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# download data\n",
    "urllib.request.urlretrieve(\"http://swcarpentry.github.io/python-novice-inflammation/data/python-novice-inflammation-data.zip\", \"python-novice-inflammation-data.zip\")\n",
    "# unzip data\n",
    "zipData = zipfile.ZipFile(\"python-novice-inflammation-data.zip\")\n",
    "zipData.extractall()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the files are extracted,\n",
    "you should see a new directory called `data/` in your project folder,\n",
    "as well as the original zipped file, `python-novice-inflammation-data.zip`.\n",
    "\n",
    "We'll be using [NumpPy](https://numpy.org) to load these data.\n",
    "This package includes provides a number of features useful for scientific computing,\n",
    "including importing data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# assign data to variable (so we can recall it later)\n",
    "data = np.loadtxt(fname=\"data/inflammation-01.csv\", delimiter=\",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've assigned these data to a variable named `data` so we can access them later. \n",
    "\n",
    "We'll now use some functions to assess the contents of this variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 1. ... 3. 0. 0.]\n",
      " [0. 1. 2. ... 1. 0. 1.]\n",
      " [0. 1. 1. ... 2. 1. 1.]\n",
      " ...\n",
      " [0. 1. 1. ... 1. 1. 1.]\n",
      " [0. 0. 0. ... 0. 2. 0.]\n",
      " [0. 0. 1. ... 1. 1. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# what is in the variable?\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you're accustomed to working with data in spreadsheets and/or `pandas` data frames, \n",
    "this output may seem somewhat confusing.\n",
    "Let's use another function to learn more about the object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# identify data structure\n",
    "print(type(data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This output indicates that our data are structured as a [NumPy array](https://jakevdp.github.io/PythonDataScienceHandbook/02.02-the-basics-of-numpy-arrays.html), \n",
    "with `ndarray` referencing that such arrays can be n-dimensional \n",
    "(e.g., one, two, or three dimensions).\n",
    "\n",
    "> If you're working in a Jupyter notebook,\n",
    "> the last line of code is synonymous with `type(data)`.\n",
    "> Remember that this is a shortcut allowed by the notebook;\n",
    "> later in this class, \n",
    "> we'll be writing Python scripts that will require `print()` statements,\n",
    "> so we'll periodically apply them to ensure we can receive appropriate output later.\n",
    "\n",
    "Next, we'll investigate the shape (dimensions) of the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(60, 40)\n"
     ]
    }
   ],
   "source": [
    "# show shape of data\n",
    "print(data.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This output includes two values, \n",
    "indicating our data are two dimensional.\n",
    "This is analogous to spreadsheet-style data,\n",
    "which in this case, means we have 60 rows and 40 columns.\n",
    "\n",
    "we can ask what kind of data the array contains using the `dtype` attribute (or member):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n"
     ]
    }
   ],
   "source": [
    "# identify data type (within array)\n",
    "print(data.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output above indicates these are float data,\n",
    "which represent numerical values which include decimal points.\n",
    "\n",
    "These values represent research data from a study on inflammation in patients associated with a new treatment for arthritis.\n",
    "**Rows** represent data from a single patient, \n",
    "while **columns** represent days sampled.\n",
    "Each number represents a measurement of the level of inflammation experienced by a patient each day \n",
    "(higher numbers mean more inflammation). \n",
    "\n",
    "> These data are derived from the Software Carpentry [Programming with Python](https://swcarpentry.github.io/python-novice-inflammation/) lesson,\n",
    "and represent synthetic data created specifically for training purposes.\n",
    "\n",
    "Throughout this course, \n",
    "we'll be working with these data to calculate summary statistics and visualize the data.\n",
    "Morevoer, we'll need to determine whether there have been errors in data entry,\n",
    "and also apply all analyses across a collection of similar datasets (in other files). \n",
    "\n",
    ">#### Challenge-import \n",
    "Import `small-01.csv` (included in your `data/` directory) \n",
    "and determine if these data differ in type or shape from our existing `data` object.\n",
    "\n",
    "## Manipulating arrays\n",
    "\n",
    "Now that we've taken a look at the basic organization of our array,\n",
    "we can start to review methods for referencing portions of the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "# extract or reference first element in array\n",
    "print(data[0, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This should be familiar if you've worked with `pandas` data frames:\n",
    "the first value input in square brackets is the row index, \n",
    "and the second value is the column index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "middle value in the data: 13.0\n"
     ]
    }
   ],
   "source": [
    "# extract middle value from array\n",
    "print(\"middle value in the data:\", data[30, 20]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The example above includes a label in the print statement\n",
    "so the output is recognizable.\n",
    "\n",
    "We can also reference a portion of the data using ranges,\n",
    "and also include empty start and end bounds \n",
    "(to suggest the beginning or end of the data, respectively)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 3., 0., 0.],\n",
       "       [1., 1., 0., 1.],\n",
       "       [2., 2., 1., 1.]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slicing data\n",
    "data[:3, 36:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can apply slicing by first highlighting values in the original dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 1., 3., 1., 2., 4., 7., 8., 3.],\n",
       "       [0., 1., 2., 1., 2., 1., 3., 2., 2., 6.],\n",
       "       [0., 1., 1., 3., 3., 2., 6., 2., 5., 9.],\n",
       "       [0., 0., 2., 0., 4., 2., 2., 1., 6., 7.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# view slice of original data\n",
    "data[0:4, 0:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we'll perform multiple the entire array by a consistent value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  2.,  6.,  2.,  4.,  8., 14., 16.,  6.],\n",
       "       [ 0.,  2.,  4.,  2.,  4.,  2.,  6.,  4.,  4., 12.],\n",
       "       [ 0.,  2.,  2.,  6.,  6.,  4., 12.,  4., 10., 18.],\n",
       "       [ 0.,  0.,  4.,  0.,  8.,  4.,  4.,  2., 12., 14.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiple entire array and view a slice\n",
    "doubledata = data * 2.0\n",
    "doubledata[0:4, 0:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A comparison between the same slice from `data` and `doubledata` shows the results we expect.\n",
    "\n",
    "If we perform a different type of math:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  3.,  9.,  3.,  6., 12., 21., 24.,  9.],\n",
       "       [ 0.,  3.,  6.,  3.,  6.,  3.,  9.,  6.,  6., 18.],\n",
       "       [ 0.,  3.,  3.,  9.,  9.,  6., 18.,  6., 15., 27.],\n",
       "       [ 0.,  0.,  6.,  0., 12.,  6.,  6.,  3., 18., 21.]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# add arrays together\n",
    "tripledata = doubledata + data\n",
    "tripledata[0:4, 0:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results here are also what we expect from adding each set of values together in the two arrays.\n",
    "\n",
    "Finally, NumPy includes a variety of methods to perform summary statistics:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.14875"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# perform summaries across entire array\n",
    "np.mean(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">#### Challenge-stats \n",
    "Find the maximum, minimum, and standard deviation across the entire array `data`, reported with meaningful print statements.\n",
    "\n",
    "While it is possible, \n",
    "and sometimes desirable,\n",
    "to perform each of these operations in separate lines of code,\n",
    "Python also allows multiple assignment:\n",
    "assigning multiple variables in one line of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.613833197118566\n"
     ]
    }
   ],
   "source": [
    "# multiple assignment: assign multiple variables at a once\n",
    "maxval, minval, stdval = np.max(data), np.min(data), np.std(data)\n",
    "print(stdval)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The examples above are summarizing across the entire array,\n",
    "which means all patients and all days.\n",
    "If you wanted to obtain the mean for each day, \n",
    "you could apply an argument to specify axis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.45      ,  1.11666667,  1.75      ,  2.43333333,\n",
       "        3.15      ,  3.8       ,  3.88333333,  5.23333333,  5.51666667,\n",
       "        5.95      ,  5.9       ,  8.35      ,  7.73333333,  8.36666667,\n",
       "        9.5       ,  9.58333333, 10.63333333, 11.56666667, 12.35      ,\n",
       "       13.25      , 11.96666667, 11.03333333, 10.16666667, 10.        ,\n",
       "        8.66666667,  9.15      ,  7.25      ,  7.33333333,  6.58333333,\n",
       "        6.06666667,  5.95      ,  5.11666667,  3.6       ,  3.3       ,\n",
       "        3.56666667,  2.48333333,  1.5       ,  1.13333333,  0.56666667])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# summarize by day\n",
    "np.mean(data, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`axis=0` means to summarize across rows, \n",
    "so each value represents the mean for a single day assessed. \n",
    "Alterntively,\n",
    "`axis=1` would summarize by patient.\n",
    "If this seems difficult to understand,\n",
    "you're not alone! \n",
    "[This blog post](https://www.sharpsightlabs.com/blog/numpy-axes-explained/) does a good job illustrating how axes work.\n",
    "\n",
    "It's hard to tell from the output whether we're getting the information we desire,\n",
    "but we can confirm we're obtaining the correct number of values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(40,)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# shape of output\n",
    "np.mean(data, axis=0).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are 40 values in the output, \n",
    "which corresponds to the number of days in the dataset, \n",
    "indicating we've calculated the mean by day.\n",
    "\n",
    "## Visualizing data\n",
    "\n",
    "Now that we've acquainted ourselves with arrays,\n",
    "and reviewed some basic data manipulation tasks,\n",
    "we can visualize our data.\n",
    "\n",
    "First, we'll load the library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can create the plot,\n",
    "with a basic plot being presented as a heatmap\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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": [
    "image = plt.imshow(data)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code above,\n",
    "the first line draws the image,\n",
    "while the second line instructs the plot to be shown.\n",
    "Depending on your Python interpreter \n",
    "(the interface in which you're executing Python code),\n",
    "you may not need to include the second line (`plt.show()`). \n",
    "Moreover, \n",
    "some interpreters (like Jupyter notebook)\n",
    "will allow you to execute only `plt.imshow(data)` \n",
    "in order for the plot to appear.\n",
    "\n",
    "The default plot shown above is a 2D raster,\n",
    "since the array is two-dimensional. \n",
    "Blue pixels represent low values;\n",
    "yellow represents high values.\n",
    "Since the x axis represents days\n",
    "and the y axis are individual patients, \n",
    "we can conclude that inflammation generally rises and falls over the 40-day period.\n",
    "\n",
    "We could also view average inflammation over time: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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": [
    "# plot average inflammation over time \n",
    "ave_inflammation = np.mean(data, axis=0)\n",
    "plt.plot(ave_inflammation)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> #### Challenge-data \n",
    "Plot the maximum and minimum inflammation across all patients for `data`. \n",
    "What can you conclude about the validity of the data based on these plots?\n",
    "\n",
    "So far, we've shown each individual plot by itself.\n",
    "If we wanted to show the collection of plots together,\n",
    "we would need to restructure our code. \n",
    "\n",
    ">#### Challenge-comment\n",
    "Look at the code below and include a comment for each new function or argument you see."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "data = np.loadtxt(fname='data/inflammation-01.csv', delimiter=',')\n",
    "\n",
    "fig = plt.figure(figsize=(10.0, 3.0))\n",
    "\n",
    "axes1 = fig.add_subplot(1, 3, 1)\n",
    "axes2 = fig.add_subplot(1, 3, 2)\n",
    "axes3 = fig.add_subplot(1, 3, 3)\n",
    "\n",
    "axes1.set_ylabel('average')\n",
    "axes1.plot(np.mean(data, axis=0))\n",
    "\n",
    "axes2.set_ylabel('max')\n",
    "axes2.plot(np.max(data, axis=0))\n",
    "\n",
    "axes3.set_ylabel('min')\n",
    "axes3.plot(np.min(data, axis=0))\n",
    "\n",
    "fig.tight_layout()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Repeating actions with loops\n",
    "\n",
    "The code we've written so far works well for a single dataset. \n",
    "What if we wanted to repeat the same plotting across all data files? \n",
    "How many lines of code would it take given the methods used so far?\n",
    "\n",
    "We'll be reviewing a programming structure called for loops,\n",
    "and then apply this method to accessing multiple data files.\n",
    "First, we'll explore for loops using a simple example:\n",
    "accessing elements in a variable.\n",
    "Let's get started by creating a new variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hutchinson'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a variable for a word\n",
    "word = \"hutchinson\"\n",
    "word"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access each element (letter) our string object by index position:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first letter = h\n",
      "last letter = n\n"
     ]
    }
   ],
   "source": [
    "print(\"first letter =\", word[0])\n",
    "print(\"last letter =\", word[9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This works fine when our word remains the same. \n",
    "What happens, though, when we change the word?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "word = \"hutch\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can still access `word[0]`, \n",
    "but Python returns an `IndexError` for `word[9]`,\n",
    "since that element doesn't exist in our shortened word.\n",
    "\n",
    "A for loop allows us to access each element in a set \n",
    "(in this case, a word)\n",
    "one at a time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h\n",
      "u\n",
      "t\n",
      "c\n",
      "h\n"
     ]
    }
   ],
   "source": [
    "# for loop to print characters in a word\n",
    "for char in word:\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> In some interpreters, you may need to experiment how to best execute multi-line code chunks. \n",
    "> Usually placing your cursor on the first line,\n",
    "> or selecting the entire code chunk,\n",
    "> is sufficient.\n",
    "\n",
    "For loops have a predictable structure: \n",
    "\n",
    "```python\n",
    "for VARIABLE in SET:\n",
    "    ACTION\n",
    "```\n",
    "\n",
    "`VARIABLE` represents a variable name internal to the for loop.\n",
    "`SET` represents the collection from which you are accessing elements.\n",
    "`ACTION` is the specific task you want completed for each element.\n",
    "\n",
    "In our example above, \n",
    "note that we must include a `print()` statement for the values to appear in the output. \n",
    "\n",
    "Because for loops repeat across the entire collection,\n",
    "this structure is not dependent on the length of the collection.\n",
    "\n",
    ">#### Challenge-vowels\n",
    "Given the following code,\n",
    "replace `ACTION` with code that will allow you to count the number of vowels:\n",
    "\n",
    "```python\n",
    "length = 0\n",
    "for vowel in \"aeiou\":\n",
    "    ACTION\n",
    "print(\"There are\", length, \"vowels\")\n",
    "```\n",
    "\n",
    "Before we can apply for loops to working with multiple files,\n",
    "we should explore working with filenames using `glob`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['data/inflammation-05.csv',\n",
       " 'data/inflammation-11.csv',\n",
       " 'data/inflammation-10.csv',\n",
       " 'data/inflammation-04.csv',\n",
       " 'data/inflammation-12.csv',\n",
       " 'data/inflammation-06.csv',\n",
       " 'data/inflammation-07.csv',\n",
       " 'data/inflammation-03.csv',\n",
       " 'data/inflammation-02.csv',\n",
       " 'data/inflammation-01.csv',\n",
       " 'data/inflammation-09.csv',\n",
       " 'data/inflammation-08.csv']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create collection of file names\n",
    "import glob\n",
    "\n",
    "glob.glob(\"data/inflammation*.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've applied an asterisk (`*`) as a wildcard,\n",
    "which means we'll find any files in the `data/` directory\n",
    "that begin with `inflammation` and end with `.csv`.\n",
    "\n",
    "We can use `glob` to create a list of filenames:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['data/inflammation-01.csv',\n",
       " 'data/inflammation-02.csv',\n",
       " 'data/inflammation-03.csv',\n",
       " 'data/inflammation-04.csv',\n",
       " 'data/inflammation-05.csv',\n",
       " 'data/inflammation-06.csv',\n",
       " 'data/inflammation-07.csv',\n",
       " 'data/inflammation-08.csv',\n",
       " 'data/inflammation-09.csv',\n",
       " 'data/inflammation-10.csv',\n",
       " 'data/inflammation-11.csv',\n",
       " 'data/inflammation-12.csv']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a list of files\n",
    "filenames = sorted(glob.glob(\"data/inflammation*.csv\")) \n",
    "filenames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, \n",
    "we've sorted the list to make the filenames appear in numerical order.\n",
    "\n",
    "We can then use a for loop to access each file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data/inflammation-01.csv\n",
      "data/inflammation-02.csv\n",
      "data/inflammation-03.csv\n",
      "data/inflammation-04.csv\n",
      "data/inflammation-05.csv\n",
      "data/inflammation-06.csv\n",
      "data/inflammation-07.csv\n",
      "data/inflammation-08.csv\n",
      "data/inflammation-09.csv\n",
      "data/inflammation-10.csv\n",
      "data/inflammation-11.csv\n",
      "data/inflammation-12.csv\n"
     ]
    }
   ],
   "source": [
    "# loop across all filenames\n",
    "for f in filenames:\n",
    "    print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">#### Challenge-files \n",
    "Do all of the data files contain the same amount of data \n",
    "(i.e., same number of elements)?\n",
    "Write a for loop that assesses the shape of each file.\n",
    "\n",
    ">#### Challenge-apply\n",
    "*Optional, covered at beginning of class 2:* Place our plotting code for the inflammation data in a loop so it will run across all data files.\n",
    "\n",
    "## Wrapping up\n",
    "\n",
    "These materials reviewed Python basics while introducing NumPy arrays.\n",
    "We also covered plotting with matplotlib and repeating actions across multiple files using for loops.\n",
    "\n",
    "In the next session, \n",
    "we'll explore conditional statements as a way to control whether Python executes our code, \n",
    "and also explore writing our own functions.\n",
    "Along the way, we'll continue applying these skills to our inflammation data.\n",
    "\n",
    "Answers to challenge questions are available in the [`solutions/`](solutions) directory."
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}