cs107-lecture-examples

python_1.ipynb (32918B)

---

 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Introductory Python"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The main topic for today's lecture is Python and some of it's basic\n",
     "functionality.  We will cover the basics of \n",
     "\n",
     "* using Python as a calculator\n",
     "* `print` statements\n",
     "* the list concept\n",
     "* opening and reading from files\n",
     "* dictionaries\n",
     "* strings\n",
     "\n",
     "I will show you some very basic examples and you will put them all together in a\n",
     "small script for your exercise.  The exercise is displayed at the top of this\n",
     "notebook.  If you already know how to do it, then just write up your script now.\n",
     "However, you may need some guidance.  You will find such guidance throughout the\n",
     "rest of the notebook."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Important, Useful Libraries"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You should always try to use existing technologies to accomplish your goals\n",
     "whenever possible.  For example, don't write your own function to compute the\n",
     "square root of a number.  That would be really hard and your implementation\n",
     "would most likely not be very efficient.  Instead, use built-in functionality or\n",
     "functionality from a nice library such as `numpy`\n",
     "([NUMericalPYthon](http://www.numpy.org/)).\n",
     "\n",
     "> NumPy is the fundamental package for scientific computing with Python. It\n",
     "> contains among other things:\n",
     ">\n",
     "> * a powerful N-dimensional array object \n",
     "> * sophisticated (broadcasting) functions \n",
     "> * tools for integrating C/C++ and Fortran code \n",
     "> * useful linear algebra, Fourier transform, and random number capabilities \n",
     ">\n",
     "> Besides its obvious scientific uses, NumPy can also be used as an efficient\n",
     "> multi-dimensional container of generic data. Arbitrary data-types can be\n",
     "> defined. This allows NumPy to seamlessly and speedily integrate with a wide\n",
     "> variety of databases.\n",
     "\n",
     "To import libraries into your Python application, do the following:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "# The %... is an iPython thing, and is not part of the Python language.\n",
     "# In this case we're just telling the plotting library to draw things on\n",
     "# the notebook, instead of on a separate window.\n",
     "%matplotlib inline \n",
     "# the line above prepares IPython notebook for working with matplotlib\n",
     "\n",
     "import numpy as np # imports a fast numerical programming library\n",
     "import scipy as sp #imports stats functions, amongst other things\n",
     "import matplotlib as mpl # this actually imports matplotlib\n",
     "import matplotlib.cm as cm #allows us easy access to colormaps\n",
     "import matplotlib.pyplot as plt #sets up plotting under plt\n",
     "import pandas as pd #lets us handle data as dataframes\n",
     "#sets up pandas table display\n",
     "pd.set_option('display.width', 500)\n",
     "pd.set_option('display.max_columns', 100)\n",
     "pd.set_option('display.notebook_repr_html', True)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The way to understand these imports is as follows: _import the library `library`\n",
     "with the alias `lib`_ where `library` could be `numpy` or `matplotlib` or\n",
     "whatever you want and `lib` is the alias used to refer to that library in our\n",
     "code.  Using this flow, we can call methods like `plt.plot()` instead of\n",
     "`matplotlib.pyplot.plot()`.  It makes life easier."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "**NOTE:** It is not necessary to import _all_ of these libraries all of the\n",
     "time.  You should only import the ones you really need.  I listed a bunch above\n",
     "to give you a sampling of what's available.\n",
     "\n",
     "**NOTE:** DO NOT include `%matplotlib inline` in your Python scripts unless\n",
     "you're working in the Jupyter notebook."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "At the end of this course, someone should be able to `import\n",
     "your_kinetics_library` to use the kinetics library that you are about to start\n",
     "writing."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## The Very Basics"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We'll fly through this part because you should already know it.  If you don't\n",
     "understand something, please Google it and/or refer to the [Python\n",
     "Tutorial](https://docs.python.org/3/tutorial/).  I do not want to recreate the\n",
     "Python tutorial here; instead, I'll just summarize a few important ideas from\n",
     "Python.  We'll give more details a little later on how some of these language\n",
     "features work.\n",
     "\n",
     "Another very helpful resource that explains the basics below (and few additional\n",
     "topics) can be found here:\n",
     "[https://learnxinyminutes.com/docs/python/](https://learnxinyminutes.com/docs/python/)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Calculating"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We can tell the type of a number or variable by using the `type` function."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "(int, float)"
       ]
      },
      "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "type(3), type(3.0)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Remember, every variable in python gets a type. Python is a strongly typed\n",
     "language. It is also a dynamic language, in the sense that types are assigned at\n",
     "run-time, rather then \"compile\" time, as in a language like C. This makes it\n",
     "slower, as the way data is stored cannot be initially optimal, as when the\n",
     "program starts, you dont know what that variable will point to."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "All the usual calculations can be done in Python."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "6.0"
       ]
      },
      "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "2.0 + 4.0 # Adding two floats"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "6"
       ]
      },
      "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "2 + 4     # Adding two ints"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "0.3333333333333333"
       ]
      },
      "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "1.0 / 3.0 # Dividing two floats"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "0.3333333333333333"
       ]
      },
      "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "1 / 3     # Dividing two ints"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Note that in Python 2, the division of two ints would not be interpreted as a\n",
     "float; it is integer division.  This is new in Python 3!  Now, if you want\n",
     "integer division you have to use the `//` operator."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "0"
       ]
      },
      "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "1 // 3    # Integer division"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "32"
       ]
      },
      "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "2**5      # Powers"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "15"
       ]
      },
      "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "3 * 5     # Multiplication"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### More advanced operations\n",
     "\n",
     "We can use `numpy` to do some more advanced operations."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "13.974998513319154"
       ]
      },
      "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "np.pi * np.exp(2.0) + np.tanh(1.0) - np.sqrt(100.0)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Notice that I am always writing my floats with a decimal point.  You don't\n",
     "really need to do that in Python because Python will automatically convert\n",
     "between types.  For example:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "(numpy.float64, numpy.float64)"
       ]
      },
      "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "type(np.pi * np.exp(2.0) + np.tanh(1.0) - np.sqrt(100.0)), type(np.pi * np.exp(2) + np.tanh(1) - np.sqrt(100))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "However, I like to make the types as explicit as I can so there's no confusion."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### `print`"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The `print` function is the basic way to write information out to the screen.  I\n",
     "will briefly review the new form of the `print` function.  In Python 2, `print`\n",
     "was a `statement` rather than a `function`."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Good morning!  Today we are doing Python!\n",
       "3.0\n",
       "3.141592653589793 is a nice, trancendental number\n",
       "Eric is nice and so is Sarah\n",
       "  3.1415926535897931...: it goes on forever but 3 is just an int.\n"
      ]
     }
    ],
    "source": [
     "print('Good morning!  Today we are doing Python!')                                  # Basic print\n",
     "print(3.0)                                                                          # Print a float\n",
     "print('{} is a nice, trancendental number'.format(np.pi))                           # Print just one number\n",
     "print('{} is nice and so is {}'.format('Eric', 'Sarah'))                            # Print with two arguments\n",
     "print('{0:20.16f}...: it goes on forever but {1} is just an int.'.format(np.pi, 3)) # Print with formatting in argument 0"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Here are some additional resources for the `print` function and formatting:\n",
     "* [7. Input and Output](https://docs.python.org/3/tutorial/inputoutput.html)\n",
     "* [Formatted Output](https://www.python-course.eu/python3_formatted_output.php)\n",
     "* [`Print` function](https://docs.python.org/3/library/functions.html#print)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Variables"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We'll have more to say about variables in Python later.  For now, here's how you\n",
     "store them syntactically:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "1.0x^2 + -1.0x + -1.0 = 0.0\n"
      ]
     }
    ],
    "source": [
     "a = 1.0\n",
     "b = -1.0\n",
     "c = -1.0\n",
     "x = (1.0 + np.sqrt(5.0)) / 2.0\n",
     "val = a * x**2.0 + b * x + c\n",
     "print('{0}x^2 + {1}x + {2} = {3}'.format(a, b, c, val))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Python has this nice feature where you can assign more than one variable all on\n",
     "one line.  It's called the multiple assignment statement."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "1.0x^2 + -1.0x + -1.0 = 0.0\n"
      ]
     }
    ],
    "source": [
     "a, b, c = 1.0, -1.0, -1.0\n",
     "x = (1.0 + np.sqrt(5.0)) / 2.0\n",
     "val = a * x**2.0 + b * x + c\n",
     "print('{0}x^2 + {1}x + {2} = {3}'.format(a, b, c, val))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Looks a little cleaner now."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Lists and `for` loops"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Lists are central to Python.  Many things behave like lists.  For now, we'll\n",
     "just look at how to create them and do basic operations with them.  I will not\n",
     "go through all the details.  Please refer to\n",
     "[Lists](https://docs.python.org/3/tutorial/introduction.html#lists) for\n",
     "additional examples."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "First few primes are: [2, 3, 5, 7, 11, 13]\n",
       "Here are the primes up to the number 20: [2, 3, 5, 7, 11, 13, 17, 19]\n"
      ]
     }
    ],
    "source": [
     "primes = [2, 3, 5, 7, 11, 13]     # A list of primes\n",
     "more_primes = primes + [17, 19]   # List concatentation\n",
     "print('First few primes are: {primes}'.format(primes=primes))\n",
     "print('Here are the primes up to the number 20: {}'.format(more_primes))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Notice that Python knows that type of `primes`."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "primes is of type <class 'list'>\n"
      ]
     }
    ],
    "source": [
     "print('primes is of type {}'.format(type(primes)))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The `len` function can provide the number of elements in the list."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "There are 6 prime numbers less than or equal to 20.\n"
      ]
     }
    ],
    "source": [
     "print('There are {} prime numbers less than or equal to 20.'.format(len(primes)))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Now that we know what a list is, we can discuss `for` loops in Python.  The\n",
     "`for` loop iterates over an iterator such as a list.  For example:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "2\n",
       "3\n",
       "5\n",
       "7\n",
       "11\n",
       "13\n",
       "17\n",
       "19\n"
      ]
     }
    ],
    "source": [
     "for p in more_primes:\n",
     "    print(p)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "A useful iterator (but not a list!) is the `range` function."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "range(0, 10)\n",
       "<class 'range'>\n"
      ]
     }
    ],
    "source": [
     "print(range(10))\n",
     "print(type(range(10)))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "It's not a list anymore (it used to be in Python 2) and therefore can't be\n",
     "sliced like a list can (see below).  Still, you can use it in `for` loops which\n",
     "is where it finds most of its use."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "0\n",
       "1\n",
       "2\n",
       "3\n",
       "4\n",
       "5\n",
       "6\n",
       "7\n",
       "8\n",
       "9\n"
      ]
     }
    ],
    "source": [
     "for n in range(10):\n",
     "    print(n)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "There is something called a _list comprehension_ in Python.  List comprehensions\n",
     "are just a way to transform one list into another list."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "The new list is [0, 1, 1, 2, 3, 4, 5, 6]\n"
      ]
     }
    ],
    "source": [
     "not_all_primes = [p // 3 for p in more_primes]\n",
     "print('The new list is {}'.format(not_all_primes))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We can also count the number of each element in the list.  There are a number of\n",
     "ways of doing this, but one convenient way is to use the `collections` library."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Counter({1: 2, 0: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1})\n",
       "<class 'collections.Counter'>\n"
      ]
     }
    ],
    "source": [
     "import collections\n",
     "how_many = collections.Counter(not_all_primes)\n",
     "print(how_many)\n",
     "print(type(how_many))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We see that there are 2 ones, 1 two, 1 three, etc.\n",
     "\n",
     "We can even find the most common element of the list and how many occurrences of\n",
     "it there are and return the result as a list."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "[(1, 2), (0, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 1)]\n",
       "<class 'list'>\n"
      ]
     }
    ],
    "source": [
     "how_many_list = how_many.most_common()\n",
     "print(how_many_list)\n",
     "print(type(how_many_list))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We see that the result is a list of tuples with the most common element of our\n",
     "original list (`not_all_primes`) displayed first.  We want the most common\n",
     "element of our original list, so we just access the first element using a simple\n",
     "index."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "(1, 2)\n",
       "<class 'tuple'>\n"
      ]
     }
    ],
    "source": [
     "most_common = how_many_list[0]\n",
     "print(most_common)\n",
     "print(type(most_common))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We're almost there.  We recall the first element of this tuple is the value from\n",
     "our original list and the second element in the tuple is its frequency.  We're\n",
     "finally ready to get our result!"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "The number 1 is the most common value in our list.\n",
       "It occurs 2 times.\n"
      ]
     }
    ],
    "source": [
     "print('The number {} is the most common value in our list.'.format(most_common[0]))\n",
     "print('It occurs {} times.'.format(most_common[1]))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "List indexing is also very important.  It can also do much more than what we did\n",
     "above."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "5\n",
       "[5, 7, 11]\n",
       "13\n",
       "[7, 11, 13]\n"
      ]
     }
    ],
    "source": [
     "print(primes[2])   # print the 3rd entry \n",
     "print(primes[2:5]) # print the 3rd to 5th entries\n",
     "print(primes[-1])  # print the last entry\n",
     "print(primes[-3:]) # print the three entries"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Other types of slices and indexing can be done as well.  I leave it to you to\n",
     "look this up as you need it.  It is a **very** useful thing to know."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Two convenient built-in functions are `enumerate` and `zip`.  You may find\n",
     "various uses for them.\n",
     "\n",
     "* `enumerate` gives a representation of a list of tuples with each tuple of the\n",
     "  form `(index, value)`.  This provides an easy way to access the `index` of the\n",
     "  value in the `list`.\n",
     "* `zip` takes elements from each list and puts them together into a\n",
     "  representation of a list of tuples.  This provides a nice way to aggregate\n",
     "  lists."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We'll make two lists for the following examples:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 27,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "species = ['H2', 'O2', 'OH', 'H2O', 'H2O2']\n",
     "species_names = ['Hydrogen', 'Oxygen', 'Hydroxyl', 'Water', 'Hydrogen Peroxide']"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### `enumerate` example"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 28,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "<enumerate object at 0x10adecb40>\n"
      ]
     }
    ],
    "source": [
     "print(enumerate(species)) "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Notice that `enumerate()` just returns an iterator object.  To actually see\n",
     "what's in the iterator object, we need to convert the iterator object to a list"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 29,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "[(0, 'H2'), (1, 'O2'), (2, 'OH'), (3, 'H2O'), (4, 'H2O2')]\n"
      ]
     }
    ],
    "source": [
     "print(list(enumerate(species)))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We see that we have a list of tuples (in the form `(index, value)` where `index`\n",
     "starts from 0).  Here's just one way that this might be used:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 30,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "H2 is species 1\n",
       "O2 is species 2\n",
       "OH is species 3\n",
       "H2O is species 4\n",
       "H2O2 is species 5\n"
      ]
     }
    ],
    "source": [
     "for i, s in enumerate(species):\n",
     "    print('{species} is species {ind}'.format(species=s, ind=i+1))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "What happened is that the `for` loop iterated over the iterable (here\n",
     "`enumerate`).  The first index in the `for` loop corresponds to the first entry\n",
     "in the `enumerate` tuple and the second index in the `for` loop corresponds to\n",
     "the second entry in the `enumerate` tuple."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### `zip` example"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Let's see how `zip` works.  We'll aggregate the `species` and `species_names`\n",
     "lists."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "<zip object at 0x10adfb108>\n",
       "[('H2', 'Hydrogen'), ('O2', 'Oxygen'), ('OH', 'Hydroxyl'), ('H2O', 'Water'), ('H2O2', 'Hydrogen Peroxide')]\n"
      ]
     }
    ],
    "source": [
     "print(zip(species, species_names))\n",
     "print(list(zip(species, species_names)))"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "H2 is called Hydrogen\n",
       "O2 is called Oxygen\n",
       "OH is called Hydroxyl\n",
       "H2O is called Water\n",
       "H2O2 is called Hydrogen Peroxide\n"
      ]
     }
    ],
    "source": [
     "for s, name in zip(species, species_names):\n",
     "    print('{specie} is called {name}'.format(specie=s, name=name))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We see that this worked in a similar way to `enumerate`."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Finally, you will sometimes see `enumerate` and `zip` used together."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 33,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Species 1 is H2 and it is called Hydrogen.\n",
       "Species 2 is O2 and it is called Oxygen.\n",
       "Species 3 is OH and it is called Hydroxyl.\n",
       "Species 4 is H2O and it is called Water.\n",
       "Species 5 is H2O2 and it is called Hydrogen Peroxide.\n"
      ]
     }
    ],
    "source": [
     "for n, (s, name) in enumerate(zip(species, species_names), 1):\n",
     "    print('Species {ind} is {specie} and it is called {name}.'.format(ind=n, specie=s, name=name))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Opening Files"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "There are a variety of ways to open files in Python.  We'll see a bunch as the\n",
     "semester progresses.  Today, we'll focus on opening and reading text files."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 34,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "species_file = open(\"species.txt\") # Open the file\n",
     "species_text = species_file.read() # Read the lines of the file\n",
     "species_tokens = species_text.split() # Split the string and separate based on white spaces\n",
     "species_file.close()               # Close the file!"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 35,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "['H2', 'O2', 'OH', 'H2O', 'H2O2']\n",
       "<class 'list'>\n"
      ]
     }
    ],
    "source": [
     "print(species_tokens)\n",
     "print(type(species_tokens))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Notice that we get a list of strings."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Here's a better way to open a file.  The `close` operation is handled\n",
     "automatically for us."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 36,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "with open('species.txt') as species_file:\n",
     "    species_text = species_file.read()\n",
     "    species_tokens = species_text.split()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Dictionaries"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Dictionaries are extremely important in Python.  For particular details on\n",
     "dictionaries refer to\n",
     "[Dictionaries](https://docs.python.org/3/tutorial/datastructures.html#dictionaries).\n",
     "From that tutorial we have a few comments on dictionaries:\n",
     "\n",
     "> Unlike sequences, which are indexed by a range of numbers, dictionaries are\n",
     "> indexed by keys, which can be any immutable type; strings and numbers can\n",
     "> always be keys.\n",
     ">\n",
     "> It is best to think of a dictionary as an unordered set of key: value pairs,\n",
     "> with the requirement that the keys are unique (within one dictionary). A pair\n",
     "> of braces creates an empty dictionary: {}. Placing a comma-separated list of\n",
     "> key:value pairs within the braces adds initial key:value pairs to the\n",
     "> dictionary; this is also the way dictionaries are written on output.\n",
     ">\n",
     "> The main operations on a dictionary are storing a value with some key and\n",
     "> extracting the value given the key."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Let's create a chemical species dictionary."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 37,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "{'H2': 'Hydrogen', 'O2': 'Oxygen', 'OH': 'Hydroxyl', 'H2O': 'Water', 'H2O2': 'Hydrogen Peroxide'}\n"
      ]
     }
    ],
    "source": [
     "species_dict = {'H2':'Hydrogen', 'O2':'Oxygen', 'OH':'Hydroxyl', 'H2O':'Water', 'H2O2':'Hydrogen Peroxide'}\n",
     "print(species_dict)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The entries to the left of the colon are the keys and the entries to the right\n",
     "of the colon are the values.  To access a value we just reference the key."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 38,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Hydrogen\n"
      ]
     }
    ],
    "source": [
     "print(species_dict['H2'])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Pretty cool!\n",
     "\n",
     "Suppose we want to add another species to our dictionary.  No problem!"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 39,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "{'H2': 'Hydrogen', 'O2': 'Oxygen', 'OH': 'Hydroxyl', 'H2O': 'Water', 'H2O2': 'Hydrogen Peroxide', 'H': 'Atomic Hydrogen'}\n",
       "Atomic Hydrogen\n"
      ]
     }
    ],
    "source": [
     "species_dict['H'] = 'Atomic Hydrogen'\n",
     "print(species_dict)\n",
     "print(species_dict['H'])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Why should we use dictionaries at all?  Clearly they're very convenient.  But\n",
     "they're also fast.  See [indexnext |previous |How to Think Like a Computer\n",
     "Scientist: Learning with Python 3: 20.\n",
     "Dictionaries](http://openbookproject.net/thinkcs/python/english3e/dictionaries.html)\n",
     "for a decent explanation."
    ]
   }
  ],
  "metadata": {
   "jupytext": {
    "formats": "ipynb,md"
   },
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.6.5"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 2
 }