Python basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this brief tutorial, we'll explore some Python basics - math, strings, lists, dictionaries, tuples, sets, branching, loops, comments, logical values, functions and modules. We'll also introduce the concept of Pythonic code.  \n",
    "\n",
    "If you're new to Python, don't try to absorb everything at once. It's an expansive language with a rich syntax, lot's of built in functions and modules for evertyhing from machine learning to symbolic computing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Floating point math operations work the way you would expect, following C/C++ conventions and operation precedence. As a convenience, an exponentiation operator (\\*\\*) is provided"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "((1.0 + 3.0 - 1.0) * 3.0)**2 / 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most integer operations work as expected too"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "((1 + 3 - 1) * 3)**2 % 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just be careful of integer divisions. Unlike C/C++ and other languages, integers are converted to floating point values first.  \n",
    "If you want C/C++ integer division, use \"//\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5//4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Booleans and logical operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's Boolean values are True and False (always capitalized). Many other things are treated as false - empty strings, zero (floating point, complex and integer), empty sets and lists. By default, everything else is treated as true - non-empty strings, numeric values that do not equate to zero, non-emtpy sets and lists.\n",
    "\n",
    "In my opinion, Python feels like it was designed for humans. Contrast with C and Perl, which feel like they were designed for machines or robots. Syntax tends to more straightforward, more readable. Python uses \"and, or, not\" rather than \"&&, ||, !\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 < 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 > 2 and 5 < 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Single line comments start with \"#\" and extend to the end of the line. The start and finish of multi-line comments are marked using three single quotes (''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Line 1 of a multi-line comment\n",
    "Line 2 of a multi-line comment\n",
    "Line 3 of a multi-line comment\n",
    "'''\n",
    "# Comment on its own line\n",
    "\n",
    "1 + 2*3 # Comment at the end of a line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python strings act a lot like lists, which we'll discuss later. Characters within the string are accessed by index starting with 0, like C/C+. Ranges of characters can be accessed using slices [start:end], but note that the last index is not included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr = 'abcdef'\n",
    "print(mystr[2])\n",
    "print(mystr[0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you were paying attention, you'll notice that we snuck in a new Python feature, the \"print\" function. If an expression is evaluated and not assigned to a variable, the result is printed to the standard output. If an iPython notebook cell contains more than one expression, only the last one is displayed. The following cell illustrates this.  \n",
    "\n",
    "If you had been programming in Python 2, note that print has changed. In Python 2, print was a statement and was called without parentheses. In Python 3, it's a function and the parentheses are required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr[2]\n",
    "mystr[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The length of a string can be obtained with the len() function. This can be used to access the last element of the string [len-1]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"String length: \", len(mystr))\n",
    "print(\"Last element: \", mystr[len(mystr)-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **Pythonic** way to access the last element is with index '-1'. Pythonic means code that doesn't just get the syntax right but that follows the conventions of the Python community and uses the language in the way it is intended to be used. Non-Pythonic code is not necessarily wrong, but tends to be uglier, awkward looking, harder to read and possibly less efficient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One important way that string different from lists is that strings are immutable. We an assign a new value to the string, but we can't update individual elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr[3] = 'X' # This will produce an error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a lot of built in string methods. A few are illustrated below, see the documentation for a more complete list https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr = \"abCdefgHij\"\n",
    "print(\"Original string:\", mystr)\n",
    "print(\"Convert to upper case:\", mystr.upper())\n",
    "print(\"Convert to lower case:\", mystr.lower())\n",
    "print(\"Capitalize the string:\", mystr.capitalize())\n",
    "print(\"Is the string all alphabetical characters:\", mystr.isalpha())\n",
    "print(\"Is the string all lower case:\", mystr.islower())\n",
    "print(\"Is the string all digits:\", mystr.isdigit())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a method for finding the first occurence of a substring within a string, but if you just want to know whether a string contains a substring (don't care about location), the Pythonic way is to use the \"in\" operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mystr.find('def')) # Returns index (-1 if not found)\n",
    "print('def' in mystr)    # Returns True/False\n",
    "print(mystr.find('xyz')) # Returns index (-1 if not found)\n",
    "print('xyz' in mystr)    # Returns True/False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can be concatenated using the \"+\" operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str1 = 'abc'\n",
    "str2 = 'def'\n",
    "str3 = 'ghi'\n",
    "str1 + str2 + str3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are arbitrary collections of elements. The elements can be strings, integers, Booleans, floating point numbers and even other lists, sets, tuples or dictionaries (we'll talk about sets etc. later).  \n",
    "\n",
    "Unlike strings, lists are mutable, which means that we can change the values of elements. The same element can appear multiple times in a list and elements have defined positions. These properties distinguish lists from Python's other built-in data structures. Lists are enclosed by square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list containing integers\n",
    "ilist = [2, 3, 5, 7, 11]\n",
    "print(ilist)\n",
    "\n",
    "# list containing strings\n",
    "slist = ['date', 'apple', 'banana', 'cantaloupe', 'date', 'apple']\n",
    "print(slist)\n",
    "\n",
    "# list containing lists\n",
    "clist = [[1,2,3], [4,5], [6,7,8,9]]\n",
    "print(clist)\n",
    "\n",
    "# An empty list\n",
    "elist = []\n",
    "print(elist)\n",
    "\n",
    "# A neat way to initialize a list with multiple copies of an element\n",
    "rlist = ['x']*5 + ['y']*5\n",
    "print(rlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List elements are accessed by index and length of list is obtained using the len() function, just like for strings. We demostrate this below along with the mutability of lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(slist)\n",
    "print(slist[0])\n",
    "print(slist[-1])\n",
    "print(slist[2:4])\n",
    "slist[0] = 'avocado'\n",
    "print(\"Number of elements in list is\", len(slist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python contains built in functions for interrogating and modifying lists. A few examples are shown below, but see https://docs.python.org/3/tutorial/datastructures.html#more-on-lists for additional examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reinitialize the list so that we can run this cell multiple times without growing list\n",
    "slist = ['date', 'apple', 'banana', 'cantaloupe', 'date', 'apple']\n",
    "\n",
    "print(\"Appending to end of a list\")\n",
    "print(\"Original list\", slist)\n",
    "slist.append('eggplant')\n",
    "print(\"Modified list\", slist)\n",
    "print()\n",
    "\n",
    "print(\"Deleting a list element\")\n",
    "print(\"Original list\", slist)\n",
    "del slist[2] # Using the del statement\n",
    "print(\"Modified list\", slist)\n",
    "print()\n",
    "\n",
    "print(\"Reversing a list\")\n",
    "print(\"Original list\", slist)\n",
    "slist.reverse() # Note that reverse is done in place\n",
    "print(\"Modified list\", slist)\n",
    "print()\n",
    "\n",
    "print(\"Sorting a list\")\n",
    "print(\"Original list\", slist)\n",
    "slist.sort() # Note that sort is done in place\n",
    "print(\"Modified list\", slist)\n",
    "print()\n",
    "\n",
    "print(\"Counting the number of times an item appears in a list\")\n",
    "print(\"apple appears\", slist.count('apple'), \"times\")\n",
    "print(\"banana appears\", slist.count('banana'), \"times\")\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are unordered collections of key-value pairs. The equivalent structure in other languages is sometimes called a hash or an associative array. In my opinion, choosing the name \"dictionary\" over the alteratives is yet another example of how Python was designed to be more intuitive and human friendly.  \n",
    "\n",
    "Like lists, dictionaries are mutable. While the values can be arbitrary, the key must be a simple \"hashable\" data type (e.g. lists cannot serve as keys). A key can only appear once and assigning a new value to a key will overwrite the original value. Values can appear multiple times. Dictionaries are enclosed by curly braces and values of the dictionary are accessed using the key name in square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initialize the dictionary with a few key-value pairs\n",
    "fruit_colors = {'apple':'red', 'banana':'yellow'}\n",
    "\n",
    "# Add a few more elements\n",
    "fruit_colors['lime'] = 'green'\n",
    "fruit_colors['lemon'] = 'yellow'\n",
    "\n",
    "# And print out the current contents of the dictionary\n",
    "print(\"Original dictionary\")\n",
    "print(fruit_colors)\n",
    "print()\n",
    "\n",
    "# Now delete an entry and print the new contents\n",
    "del fruit_colors['lime']\n",
    "print(\"Dictionary after deleting entry\")\n",
    "print(fruit_colors)\n",
    "print()\n",
    "\n",
    "print(\"List the keys and values\")\n",
    "print(\"keys:\", fruit_colors.keys())\n",
    "print(\"values:\", fruit_colors.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A set is an unordered collection of items without repeats. Python provides all the set operations you would expect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1 = {'apple', 'banana', 'orange', 'blueberry'}\n",
    "set2 = {'strawberry', 'persimmon', 'banana', 'clementine', 'grape'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Union - could also use the | operator\n",
    "set1.union(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Intersection - could also use the & operator\n",
    "set1.intersection(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set difference - items in set1, but not set 2\n",
    "set1 - set2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Empty set must be defined using the set() function, {} creates an empty dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set3 = set()\n",
    "set3.add('apple')\n",
    "set3.add('orange')\n",
    "set3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Members can be added with the add() method and removed with discard()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set3.add('kiwi')\n",
    "set3.add('apple') # Adding an existing member does not change the set\n",
    "print(set3)\n",
    "\n",
    "set3.discard('orange')\n",
    "print(set3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the properties of sets, we can easily find the unique elements of the list. In the example below, we convert the result back to a list after finding unique element with the set function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = ['a', 'a', 'b', 'c', 'a', 'b', 'b', 'a']\n",
    "list(set(mylist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples (and a first look at iterators)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tuple is a Python data structure that is similar to a list except that tuples are immutable. A tuple is enclosed by parentheses and tuple elements are accessed by index in the same way as list elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = ('a', 'b', 'c')\n",
    "print(t)\n",
    "for x in t:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you need a tuple that contains a single element. For example, a function may require a tuple as an argument, regardless of the number of elements in the tuple. In this case, follow the element of the tuple with a comma. Otherwise, the commas are interpreted in the mathematical sense. We introduce the type() function below and will explain shortly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = (3)\n",
    "type(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = (3,)\n",
    "type(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The zip() built-in function takes one or more lists and generates an iterator of tuples built from the corresponding elements of the list. Convert to a list if you need to use in a list context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = ['a', 'b', 'c', 'd']\n",
    "list2 = ['A', 'B', 'C', 'D']\n",
    "list3 = [1, 2, 3, 4]\n",
    "t = zip(list1, list2, list3)\n",
    "print(list(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normally you would use the zip() function with lists of the same lengths. If lists of different lengths are used, the number of tuples will be determined by the length of the shortest list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = ['a', 'b', 'c', 'd', 'e', 'f']\n",
    "list2 = ['A', 'B', 'C', 'D', 'E']\n",
    "list3 = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "t = zip(list1, list2, list3)\n",
    "print(list(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An iterator returns the next element in the sequence and is exhausted after the last element has been returned. You can think of an iterator as providing a stream of data. Iterators can improve performance and reduce memory usage since elements in the sequence are only generated as needed.\n",
    "\n",
    "Iterators are a key concept in functional programming. We won't get into this topic, but if you're interested you can read more about it here https://docs.python.org/3/howto/functional.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = zip(list1, list2, list3)\n",
    "print(list(t))\n",
    "print(list(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although you'll rarely need to do this, the next element in an iterator can be obtained using the next() function or the \\_\\_next\\_\\_() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = zip(list1, list2, list3)\n",
    "print(next(t))\n",
    "print(next(t))\n",
    "print(t.__next__())\n",
    "print(t.__next__())\n",
    "print(list(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A zipped object can be unzipped using the zip command with the argument preceded by an asterisk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = zip(list1, list2, list3)\n",
    "x, y, z = zip(*t)\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting information on objects "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've seen a number of different Python objects: integers, strings, lists, dictionaries, tuples, sets, iterators. It's easy to lose track of the objects that we've declared or the return types of functions. Fortunately, Python provides a few useful functions.\n",
    "\n",
    "If you just need information on a single object, use the type() function. If you want information on all objects, you can use dir(), globals() or locals(), but when working within a Jupyter notebook, we have access to the IPython \"magic\" commands %who and %whos that are much more user friendly. A full listing if IPythons magic commands can be found here http://ipython.readthedocs.io/en/stable/interactive/magics.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=1\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1.2\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = zip(list1, list2, list3)\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%who"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignments, copies, deep copies and shallow copies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the biggest stumbling blocks in Python is dealing with assignment and copies. Let's start with a simple example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['apple', 'banana', 'orange']\n",
    "print(a)\n",
    "b = a\n",
    "b[0] = 'lemon'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The assignment \"b = a\" does not create a new list. The two lists point to the same memory location and b is simply an alias or another name for a. To get a copy of the list we need to use the copy method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "a = ['apple', 'banana', 'orange']\n",
    "print(a)\n",
    "b = copy.copy(a)\n",
    "b[0] = 'lemon'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For compound objects, the behavior is more complex and we need to use a deep copy if we want to recursively copy the entire object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['apple', 'banana', 'orange', ['lime', 'peach']]\n",
    "print(a)\n",
    "b = copy.copy(a)\n",
    "b[0] = 'cherry'\n",
    "b[3][0] = 'mango'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['apple', 'banana', 'orange', ['lime', 'peach']]\n",
    "print(a)\n",
    "b = copy.deepcopy(a)\n",
    "b[0] = 'cherry'\n",
    "b[3][0] = 'mango'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Branching and conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Branching is done using if-elif-else constructs. A few examples are shown below.  \n",
    "\n",
    "The indentation is required and defines the boundaries of code blocks. I see this as a decision on the part of the Python developers to make the language more readable. The use of indentation in this way is sometimes called the \"off-side rule\", borrowed from the name of a penalty in American football."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = 1, 2\n",
    "\n",
    "# Note the colon (:) after if/elif/else and indentation of code block\n",
    "\n",
    "print(\"If constuct\")\n",
    "if x < y:\n",
    "    print (\"x is less than y\\n\")\n",
    "    \n",
    "print(\"If-else constuct\")  \n",
    "if x < y:\n",
    "    print (\"x is less than y\\n\")\n",
    "else:\n",
    "    print (\"x is not less than y\\n\")\n",
    "    \n",
    "print(\"If-elif-else constuct\")\n",
    "x, y = 2,2\n",
    "if x < y:\n",
    "    print (\"x is less than y\\n\")\n",
    "elif x > y:\n",
    "    print (\"x is greater than y\\n\")\n",
    "else:\n",
    "    print (\"x is equal to y\\n\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you were still paying attention, you might have noticed that I slipped in one more Python feaure to simultaneously assign values to x and y. We could have done the following, but it's not very Pythonic ;)\n",
    "\n",
    "```python\n",
    "# Something a C progrmmer would do\n",
    "x = 1; y = 2\n",
    "```\n",
    "\n",
    "And in the spirit of being Pythonic, note that we didn't put parentheses aroound the logical tests. For example, we wrote \"x < y\" instead of \"(x < y)\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you would expect, conditionals can be nested to an arbitray level of depth. Just be sure to do your indentation correctly or you may get unexpected results. In the example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y, z = 1, 2, 0\n",
    "print (\"x,y,z = 1,2,0 - Both tests produce same results\")\n",
    "\n",
    "if x < y:\n",
    "    if x < z:\n",
    "        print (\"x is less than y and z\")\n",
    "    elif x > z:\n",
    "        print (\"x is less than y, and greater than z\")\n",
    "else: # This else is associated with the test \"x < y\"\n",
    "    print (\"x is not less than y\")\n",
    "        \n",
    "if x < y:\n",
    "    if x < z:\n",
    "        print (\"x is less than y and z\")\n",
    "    elif x > z:\n",
    "        print (\"x is less than y, and greater than z\")\n",
    "    else: # This else is associated with the test \"x < z\"\n",
    "        print (\"x is not less than y\")\n",
    "\n",
    "print()\n",
    "        \n",
    "x, y, z = 1, 2, 1\n",
    "print (\"x,y,z = 1,2,1 - Tests produce different results\")\n",
    "\n",
    "if x < y:\n",
    "    if x < z:\n",
    "        print (\"x is less than y and z\")\n",
    "    elif x > z:\n",
    "        print (\"x is less than y, and greater than z\")\n",
    "else: # This else is associated with the test \"x < y\"\n",
    "    print (\"x is not less than y\")\n",
    "        \n",
    "if x < y:\n",
    "    if x < z:\n",
    "        print (\"x is less than y and z\")\n",
    "    elif x > z:\n",
    "        print (\"x is less than y, and greater than z\")\n",
    "    else: # This else is associated with the test \"x < z\"\n",
    "        print (\"x is not less than y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Python for loop is used to iterate over the items of a sequence. Unlike C/C++, you don't always need to loop over a numerical index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['Adam', 'Billie', 'Carlos', 'David', 'Ernesto', 'Francis']\n",
    "for n in names:\n",
    "    print(n, ': length =', len(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, Python makes it very easy to avoid looping over a numerical index. In the example below, we use the enumerate function to return the list item and its position index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, n in enumerate(names):\n",
    "    print(i, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the zip command to print the corresponding elements of multiple lists, thereby avoiding the use of a  numerical index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lowers = ['a', 'b', 'c']\n",
    "uppers = ['A', 'B', 'C']\n",
    "for t in zip(lowers, uppers):\n",
    "    print(t[0], t[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No need to split a string before iterating over characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "newstr = 'abcdefg'\n",
    "for c in newstr:\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you do need to iterate over a numerical index, use the range() function. Note that range() returns an iterable object instead of generating the complete list of integers. The next item is generated as needed. This saves memory and is more efficient. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(6):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But avoid doing the following, not very Pythonic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# How you might do this coming from a C/C++ programming background (not Pythonic)\n",
    "names = ['Adam', 'Billie', 'Carlos', 'David', 'Ernesto', 'Francis']\n",
    "for i in range(len(names)):\n",
    "    print(names[i], ': length =', len(names[i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When iterating over the key-value pairs in a dictionary, use the items() method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_colors = {'apple':'red', 'banana':'yellow', 'lime':'green', 'strawberry':'red'}\n",
    "for k,v in fruit_colors.items():\n",
    "    print(k,v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The break and continue keywords work just like in C/C++. Break exits the loop and continue steps to the next iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [2, 7, 8, 6, 15, 3, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "for n in numbers:\n",
    "    if n%5 == 0:\n",
    "        print(\"list element divisible by 5, break out of loop\")\n",
    "        break\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in numbers:\n",
    "    if n%2 == 0:\n",
    "        continue\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you would expect, loops can be nested to an arbitrary depth. Remember that code blocks are defined by the level of indentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(4):\n",
    "    for j in range(3):\n",
    "        print('(i,j) = ({},{})'.format(i,j))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's list comprehension functionality makes it very easy to create and populate a new list. We'll show an example first using the loop syntax and then demonstrate how much easier it is to do with list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Populate a list of squares using a loop\n",
    "squares = []\n",
    "for x in range(10):\n",
    "    squares.append(x*x)    \n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Populate a list of squares using list comprehension (very Pythonic)\n",
    "squares = [x*x + x - 2 for x in range(10)]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The general form of list comprehension is **[transformation iterator filter]**. In the example below, we use a more complex function and limit the list to values that are divisible by 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = [x*x + x - 2 for x in range(10) if (x*x + x - 2)%3 == 0]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One more thing about the range function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like many Python functions, range can be called with different numbers of arguments.\n",
    "\n",
    "+ range(n) --> integers 0 through n-1\n",
    "+ range(m,n) --> integers m through n-1\n",
    "+ range(m,n,p) --> integers m through n-1 with stride p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(2,20,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function definitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python functions are defined using the def keyword. \n",
    "\n",
    "From the Python reference manual: \"The function definition does not execute the function body; this gets executed only when the function is called\". One of the implications of this is that methods from modules that have not yet been loaded can be used at the time the function is declared (more on that soon)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    return x*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "square(3.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can take any number of arguments and optional arguments can be given default values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func1(x, y, z=1.0):\n",
    "    return x*y + z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func1(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func1(2,3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can return multiple objects packed into a tuple. The example below returns a tuple containing a scalar (integer or float depending on argument types) and a three element list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func2(x, y, z=1.0):\n",
    "    return x*y + z, [x*y, x*z, y*z]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func2(2, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We haven't gotten to modules yet, but we mentioned earlier that we can created a function definition that uses methods from modules that have not yet been loaded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def uses_numpy(x):\n",
    "    return np.sin(x) + np.cos(x) * np.sqrt(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The map built-in can be used to apply a function to all elements of an iterable. Note that map returns an iterator and will need to be converted to a list to use in a list context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [0.0, -0.25, 0.5, -0.75, 1.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = abs(x) # This does not do what you would hope and produces an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = map(abs, x) # Instead use map() which applies function (abs) to list (x)\n",
    "print(list(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python supports lambda functions. We won't get into the theory, but think of it as a way to declare a nameless function that can be used in certain contexts to simply your code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = [2,3,5,7,11]\n",
    "y = list(map(lambda a: a**2 + a**3, z))\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambda functions can take multiple arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = [2,3,5,7,11]\n",
    "w = [1,2,4,6,10]\n",
    "y = list(map(lambda a, b: a**2 + a**3 + b, z, w))\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python modules provide a mechanism for packaging function definitions and statements. You can develop your own modules or import standard modules such as numpy (numerical computing), pandas (machine learning) and matplotlib (plotting)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The contents of a module are imported using the import statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "numpy.sqrt(10.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Module names can be long and it's often convenient to abbreviate the name using the \"as\" clause. Although you can use any abbreviation you like, so long as it doesn't conflict with an existing name, many of the modules have standard abbreviations and we recommend using them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.sqrt(10.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Earlier, we had defined a function, uses_numpy, that required numpy's sin, cos and sqrt functions. Now that we've imported numpy, we can execute the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uses_numpy(1.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can import specific methods from modules using the following syntax. Note that the sqrt function no longer needs to be prefixed by \"numpy\" or \"np\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import sqrt\n",
    "sqrt(10.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's possible to import all names from a module using \"\\*\". For example,    \n",
    "\n",
    "    from numpy import *  \n",
    "\n",
    "This is not generally recommended. Since you don't generally know the full content of the module, you may introduce conflicts with existing function or variable names."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get version of a module and version of Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ To get a version of a module, use modulename.\\_\\_version.\\_\\_\n",
    "+ To get the Python version, use sys.version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numpy.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Phew, that was a lot to absorb! Fortunately, there's help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike C, which is an extremely terse language, Python is very expansive. There are a lot of built-in functions, many of which can be called with variable numbers of arguments. Add in the commonly used modules, such as numpy, and we end up with a lot more information than most of us can remember.\n",
    "\n",
    "Fortunately, Python provides excellent help capabilities. Just follow the function/method name with a question mark or pass the to the help() function. The former displays the help information in a new sub-window while the latter displays as the output of the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(abs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sqrt?"
   ]
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}