week2_examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Week 2 Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Topics include lists, tuples, basic iteration, exception handling, intro file I/O, debugging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "Lists are MUTABLE.  So we CAN change or assign to one or more items within an existing list.\n",
    "Lists can contain ANY mixture of data types, including other lists.  So they are very flexible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'orange', 'banananana']\n",
      "['apple', 'orange', 'banana']\n"
     ]
    }
   ],
   "source": [
    "fruit = ['apple', 'orange', 'banananana']\n",
    "print(fruit)\n",
    "fruit[2] = 'banana'  # correct the spelling of item #2\n",
    "print(fruit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'orange', 'banana', 'tomato']\n"
     ]
    }
   ],
   "source": [
    "fruit.append('tomato')  # this is how to add an item to the end of a list.\n",
    "print(fruit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "append() takes exactly one argument (3 given)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-14cb3063810e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfruit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'starfruit'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'tangerine'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'kiwi'\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# But this is invalid.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: append() takes exactly one argument (3 given)"
     ]
    }
   ],
   "source": [
    "fruit.append('starfruit', 'tangerine', 'kiwi')  # But this is invalid."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead, to add multiple items to a list at once, just concatenate 2 lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit += ['starfruit', 'tangerine', 'kiwi']\n",
    "fruit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are a \"sequence\" data type, so we can iterate through them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for f in fruit:\n",
    "    print(f, 'is a fruit')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the slicing / striding operations like we did on strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit[::-1]   # compute the reverse of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit[::3]  # extract every 3rd item from the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit[-3:]  # get the last 3 items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copying lists requires that you are careful. In some situations you'll get a shallow copy instead of what you expected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "other_fruits = fruit   # try to copy the list\n",
    "print(other_fruits)    # check its contents\n",
    "fruit[4] = 'kumquat'   # replace a member of fruit\n",
    "print(other_fruits)    # what just happened!?  I didn't mean to modify other_fruits!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, if you really mean to make a COPY of a list instead of just point to it, usually the copy() method is what you need:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "other_fruits = fruit.copy()  \n",
    "print(other_fruits)\n",
    "fruit.remove('tomato')   # modify the fruit list\n",
    "print(fruit)\n",
    "print(other_fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes!  Notice that now 'tomato' is gone from fruit but still exists in other_fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = [5, 3.14159, 'string', ['a', 'b', 'c'], (1, 2, 3, 4)]\n",
    "test\n",
    "test[3][1] = 'something completely different'\n",
    "test[4][3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "Tuples are IMMUTABLE like strings.  But they are still sequences of zero or more items, so they are iterable.\n",
    "Like lists, the items in tuples can be ANY data type, including other nested tuples. \n",
    "They are created by enclosing comma-separated items in parethenses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "deciduous = ('white oak', 'black walnut', 'red maple', 'silver maple', 'cottonwood')\n",
    "evergreen = ('holly', 'white pine', 'red cedar', 'blue spruce', 'hemlock')\n",
    "empty_tuple = ()\n",
    "one_item_tuple = (1, )   # notice the strange hanging comma here\n",
    "two_item_tuple = (1, 2)\n",
    "\n",
    "test = (1 + 5) * 3\n",
    "print(test)\n",
    "print(one_item_tuple)\n",
    "print(type(test))\n",
    "print(type(one_item_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use indexing and slicing just as with strings and lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(deciduous[1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trees = deciduous + evergreen  # we can concatenate tuples, they retain sequence.\n",
    "print(trees)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sorted(trees, reverse=True))  # we can use the builtin sorted() function on any iterable type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## type conversion\n",
    "It is easy to convert lists to tuples and vice versa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree_list = list(trees)\n",
    "tree_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_tuple = tuple(fruit)\n",
    "# fruit_tuple\n",
    "tuple(sorted(fruit_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries\n",
    "Dictionaries in Python are the same as data types called \"Hashmaps\" or \"Associative Arrays\" in other programming languages. They actually store a set of key/value pairs.  They work like a list or array except that their indexes (called \"keys\") can be arbitrary values that aren't necessarily integers. Also, the indexes don't have to be consecutive in any sense, and can even vary data types. Dictionaries turn out to be very handy for many common situations in coding. \n",
    "\n",
    "Note that the keys MUST be unique within a dictionary, and that the standard dictionary type does NOT preserve the order of keys or values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "favorite_foods = {'Joe': 'pizza', 'Bob': 'beer', 'Gina': 'spaghetti', 'Anita': 'salad'}\n",
    "for name in favorite_foods:\n",
    "    print(\"{}'s favorite food is {}\".format(name, favorite_foods[name]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "favorite_foods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are mutable, so we can definitely add and remove items (key/value pairs) to and from existing dictionaries.  Notice though that we CREATE a dictionary with curly braces, but we still use the square brackets to do indexing, even in assignments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "favorite_foods['George'] = 'banana'\n",
    "favorite_foods['Anita'] = 'salad'\n",
    "print(favorite_foods.keys())\n",
    "print(favorite_foods.values())\n",
    "\n",
    "flipped = {}\n",
    "for k in favorite_foods.keys():\n",
    "    v = favorite_foods[k]\n",
    "    if v in flipped.keys():\n",
    "        flipped[v] = k\n",
    "\n",
    "print(flipped)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Converting dictionaries\n",
    "Note that although we can convert from dictionaries to other data types, it's not as straightforward. Python doesn't know what we really want to do with the data structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(favorite_foods)  # this ends up creating a list of the keys, and ignoring the values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(favorite_foods.values())  # this is a way to make a list of the values (ignoring the keys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File Input/Output\n",
    "Many data files we use in Python are some type of \"text\" files.  These include plain text, CSV (comma-separated values), TSV (tab-separated values), and even XML or HTML files.  Python works with text files by applying \"character encoding\" to properly interpret and format the data characters.   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we create (output) the list of tree species into a new file, one per line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open('tree_species.txt', 'w') as f:\n",
    "    for tree in tree_list:\n",
    "        print(tree, file=f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we read in the textfile into a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('tree_species.txt', 'r') as input_file:\n",
    "    print(type(input_file))\n",
    "    new_tree_list = input_file.readlines()  \n",
    "    # readlines() scoops every line into a string, stored as an item in a list\n",
    "new_tree_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that worked, except it included the newline characters, keeping them at the end of each item.  We don't really want that in the data.  There are many ways to remove or avoid that behavior, one way is below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('tree_species.txt', 'r') as input_file:\n",
    "    new_tree_list = input_file.read().splitlines(keepends=False) \n",
    "    # This approach reads the whole file as one string, then splits into a list\n",
    "    # of individual lines in a separate step while discarding the line endings.\n",
    "\n",
    "print(new_tree_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next example, we read (input) that same file into a list, sort it, and then write a new file called 'sorted_tree_species.txt'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open('tree_species.txt', 'r') as input_file:\n",
    "    new_tree_list = input_file.read().splitlines(keepends=False) \n",
    "\n",
    "with open('sorted_tree_species.txt', 'w') as output_file:\n",
    "    for tree in sorted(new_tree_list):\n",
    "        print(tree, file=output_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exception Handling / error-checking\n",
    "That code above worked properly, but it's not very robust. In other words, it doesn't have any error-checking. For example, what if the tree_species.txt file doesn't exist or can't be opened?  We'll look at that in PyCharm...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Debugging\n",
    "Debugging is arguably either limited or complicated in Jupyter Notebooks, depending on your point of view. Let's have a look at the stepping debugger tools in PyCharm..."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}