python_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial, we will introduce Python 3 from a hands-on view.\n",
    "These are what we will cover:\n",
    "* Basic data types: Numbers, booleans, strings\n",
    "* Containers: Lists, dictionaries, sets, tuples\n",
    "* Flow control: if, for, while\n",
    "* Functions\n",
    "* Classes\n",
    "* Mutable vs. Immutable\n",
    "\n",
    "If you are already familiar with Python 2, we scroll down to the last part: __Python 2 to Python 3 conversion guide__, for a quick look of the difference between Python 2 and 3.\n",
    "\n",
    "A good amount of the material in this notebook comes from:\n",
    "* [CS231n Python & NumPy Tutorial by Justin Johnson](http://cs231n.github.io/python-numpy-tutorial/)\n",
    "* [CS228 Python Tutorial by Volodymyr Kuleshov and Isaac Caswell.](https://github.com/kuleshov/cs228-material/blob/master/tutorials/python/cs228-python-tutorial.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic\n",
    "\n",
    "Python is a high-level, dynamically typed multiparadigm programming language. Python code is often said to be almost like pseudocode, since it allows you to express very powerful ideas in very few lines of code while being very readable. As an example, here is an implementation of the classic quicksort algorithm in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 3, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "def quicksort(arr):\n",
    "    if len(arr) <= 1:\n",
    "        return arr\n",
    "    pivot = arr[len(arr) // 2]\n",
    "    left = [x for x in arr if x < pivot]\n",
    "    middle = [x for x in arr if x == pivot]\n",
    "    right = [x for x in arr if x > pivot]\n",
    "    return quicksort(left) + middle + quicksort(right)\n",
    "\n",
    "print(quicksort([3,6,8,10,1,2,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic data types\n",
    "\n",
    "Like most languages, Python has a number of basic types including integers, floats, booleans, and strings. These data types behave in ways that are familiar from other programming languages.\n",
    "\n",
    "### Numbers\n",
    "\n",
    "Integers and floats work as you would expect from other languages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "print(type(x)) \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "2\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "print(x + 1)   # Addition\n",
    "print(x - 1)   # Subtraction\n",
    "print(x * 2)   # Multiplication\n",
    "print(x ** 2)  # Exponentiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "x += 1\n",
    "print(x)\n",
    "x *= 2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "2.5 3.5 5.0 6.25\n"
     ]
    }
   ],
   "source": [
    "y = 2.5\n",
    "print(type(y))\n",
    "print(y, y + 1, y * 2, y ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that unlike many languages, Python does not have unary increment (`x++`) or decrement (`x--`) operators.\n",
    "\n",
    "Python also has built-in types for complex numbers; you can find all of the details [in the documentation.](https://docs.python.org/3.5/library/stdtypes.html#numeric-types-int-float-complex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Booleans\n",
    "\n",
    "Python implements all of the usual operators for Boolean logic, but uses English words rather than symbols (`&&`, `||`, etc.):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "t = True\n",
    "f = False\n",
    "print(type(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(t and f) # Logical AND\n",
    "print(t or f)  # Logical OR\n",
    "print(not t)   # Logical NOT\n",
    "print(t != f)  # Logical XOR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings\n",
    "Python has great support for strings:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "hello = 'hello'    # String literals can use single quotes\n",
    "world = \"world\"    # or double quotes; it does not matter.\n",
    "print(hello)\n",
    "print(len(hello))  # String length;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "hw = hello + ' ' + world  # String concatenation\n",
    "print(hw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world 12\n"
     ]
    }
   ],
   "source": [
    "hw12 = '%s %s %d' % (hello, world, 12)  # sprintf style string formatting\n",
    "print(hw12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world 12\n"
     ]
    }
   ],
   "source": [
    "hw12 = \"{} {} {}\".format(hello,world,12)\n",
    "print(hw12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world 12\n"
     ]
    }
   ],
   "source": [
    "hw12 = f'{hello} {world} {24//2}'\n",
    "print(hw12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String objects have a bunch of useful methods; for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "HELLO\n",
      "  hello\n",
      " hello \n",
      "he(ell)(ell)o\n",
      "world\n",
      "['this', 'is', 'a', 'book']\n"
     ]
    }
   ],
   "source": [
    "s = \"hello\"\n",
    "print(s.capitalize())  # Capitalize a string\n",
    "print(s.upper())       # Convert a string to uppercase\n",
    "print(s.rjust(7))      # Right-justify a string, padding with spaces\n",
    "print(s.center(7))     # Center a string, padding with spaces\n",
    "print(s.replace('l', '(ell)'))  # Replace all instances of one substring with another\n",
    "print('  world '.strip())  # Strip leading and trailing whitespace\n",
    "print('this is a book'.split())  # Split with whitespace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find a list of all string methods [in the documentation.](https://docs.python.org/3.5/library/stdtypes.html#string-methods)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Containers\n",
    "\n",
    "Python includes several built-in container types: lists, dictionaries, sets, and tuples.\n",
    "\n",
    "### Lists\n",
    "\n",
    "A list is the Python equivalent of an array, but is resizeable and can contain elements of different types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 2]\n",
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "xs = [3, 1, 2]    # Create a list\n",
    "print(xs)\n",
    "print(xs[2])  \n",
    "print(xs[-1])     # Negative indices count from the end of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 'foo']\n"
     ]
    }
   ],
   "source": [
    "xs[2] = 'foo'     # Lists can contain elements of different types\n",
    "print(xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 'foo', 'bar']\n"
     ]
    }
   ],
   "source": [
    "xs.append('bar')  # Add a new element to the end of the list\n",
    "print(xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bar [3, 1, 'foo']\n",
      "[1, 'foo']\n"
     ]
    }
   ],
   "source": [
    "x = xs.pop()      # Remove and return the last element of the list\n",
    "print(x, xs)\n",
    "del xs[0]         # Remove the first element of the list\n",
    "print(xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual, you can find all the gory details about lists [in the documentation.](https://docs.python.org/3.5/tutorial/datastructures.html#more-on-lists)\n",
    "\n",
    "### Slicing \n",
    "In addition to accessing list elements one at a time, Python provides concise syntax to access sublists; this is known as _slicing_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "[2, 3]\n",
      "[2, 3, 4]\n",
      "[0, 1]\n",
      "[0, 1, 2, 3, 4]\n",
      "[0, 1, 2, 3]\n",
      "[0, 1, 8, 9, 4]\n"
     ]
    }
   ],
   "source": [
    "nums = list(range(5))     # range is a built-in function that creates a list of integers\n",
    "print(nums)               \n",
    "print(nums[2:4])          # Get a slice from index 2 to 4 (exclusive)\n",
    "print(nums[2:])           # Get a slice from index 2 to the end\n",
    "print(nums[:2])           # Get a slice from the start to index 2 (exclusive)\n",
    "print(nums[:])            # Get a slice of the whole list\n",
    "print(nums[:-1])          # Slice indices can be negative\n",
    "nums[2:4] = [8, 9]        # Assign a new sublist to a slice\n",
    "print(nums)             "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will see slicing again in the context of numpy arrays.\n",
    "\n",
    "### Loops: \n",
    "You can loop over the elements of a list like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat\n",
      "dog\n",
      "monkey\n"
     ]
    }
   ],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for animal in animals:\n",
    "    print(animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want access to the index of each element within the body of a loop, use the built-in `enumerate()` function:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1: cat\n",
      "#2: dog\n",
      "#3: monkey\n"
     ]
    }
   ],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for idx, animal in enumerate(animals):\n",
    "    print('#%d: %s' % (idx + 1, animal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehensions: \n",
    "When programming, frequently we want to transform one type of data into another. As a simple example, consider the following code that computes square numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "squares = []\n",
    "for x in nums:\n",
    "    squares.append(x ** 2)\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can make this code simpler using a __list comprehension__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "squares = [x ** 2 for x in nums]\n",
    "print(squares)   # Prints [0, 1, 4, 9, 16]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comprehensions can also contain conditions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "even_squares = [x ** 2 for x in nums if x % 2 == 0]\n",
    "print(even_squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "A dictionary stores (key, value) pairs, similar to a `Map` in Java or an object in Javascript. You can use it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cute\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "d = {'cat': 'cute', 'dog': 'furry'}  # Create a new dictionary with some data\n",
    "print(d['cat'])       # Get an entry from a dictionary\n",
    "print('cat' in d)     # Check if a dictionary has a given key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wet\n"
     ]
    }
   ],
   "source": [
    "d['fish'] = 'wet'     # Set an entry in a dictionary\n",
    "print(d['fish'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'monkey'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-78fc9745d9cf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'monkey'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# KeyError: 'monkey' not a key of d\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'monkey'"
     ]
    }
   ],
   "source": [
    "print(d['monkey'])  # KeyError: 'monkey' not a key of d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N/A\n",
      "wet\n"
     ]
    }
   ],
   "source": [
    "print(d.get('monkey', 'N/A'))  # Get an element with a default; prints \"N/A\"\n",
    "print(d.get('fish', 'N/A'))    # Get an element with a default; prints \"wet\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N/A\n"
     ]
    }
   ],
   "source": [
    "del d['fish']         # Remove an element from a dictionary\n",
    "print(d.get('fish', 'N/A')) # \"fish\" is no longer a key; prints \"N/A\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find all you need to know about dictionaries [in the documentation.](https://docs.python.org/3.5/library/stdtypes.html#dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Loops:__ It is easy to iterate over the keys in a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A person has 2 legs\n",
      "A cat has 4 legs\n",
      "A spider has 8 legs\n"
     ]
    }
   ],
   "source": [
    "d = {'person': 2, 'cat': 4, 'spider': 8}\n",
    "for animal in d:\n",
    "    legs = d[animal]\n",
    "    print('A %s has %d legs' % (animal, legs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want access to keys and their corresponding values, use the `.items()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A person has 2 legs\n",
      "A cat has 4 legs\n",
      "A spider has 8 legs\n"
     ]
    }
   ],
   "source": [
    "d = {'person': 2, 'cat': 4, 'spider': 8}\n",
    "for animal, legs in d.items():\n",
    "    print('A %s has %d legs' % (animal, legs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Dictionary comprehensions:__ These are similar to list comprehensions, but allow you to easily construct dictionaries. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 2: 4, 4: 16}\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}\n",
    "print(even_num_to_square)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "\n",
    "A set is an unordered collection of distinct elements. As a simple example, consider the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "animals = {'cat', 'dog'}\n",
    "print('cat' in animals)   # Check if an element is in a set\n",
    "print('fish' in animals)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "animals.add('fish')       # Add an element to a set\n",
    "print('fish' in animals)  \n",
    "print(len(animals))       # Number of elements in a set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "animals.add('cat')        # Adding an element that is already in the set does nothing\n",
    "print(len(animals))\n",
    "animals.remove('cat')     # Remove an element from a set\n",
    "print(len(animals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fish'}\n",
      "{'dog', 'fish', 'chicken'}\n",
      "{'dog'}\n",
      "{'dog', 'chicken'}\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "food = {'fish', 'chicken'}\n",
    "print(animals & food)    # Set intersection\n",
    "print(animals | food)    # Set union\n",
    "print(animals - food)    # Set difference\n",
    "print(animals ^ food)    # Set exclusive or\n",
    "print(animals > food)    # Is superset or not\n",
    "print(animals < food)    # Is subset or not"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual, everything you want to know about sets can be found [in the documentation.](https://docs.python.org/3.5/library/stdtypes.html#set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Loops:__ Iterating over a set has the same syntax as iterating over a list; however since sets are unordered, you cannot make assumptions about the order in which you visit the elements of the set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1: dog\n",
      "#2: fish\n",
      "#3: cat\n"
     ]
    }
   ],
   "source": [
    "animals = {'cat', 'dog', 'fish'}\n",
    "for idx, animal in enumerate(animals):\n",
    "    print('#%d: %s' % (idx + 1, animal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Set comprehensions:__ Like lists and dictionaries, we can easily construct sets using set comprehensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "nums = {int(sqrt(x)) for x in range(30)}\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "A tuple is an (immutable) ordered list of values. A tuple is in many ways similar to a list; one of the most important differences is that tuples can be used as keys in dictionaries and as elements of sets, while lists cannot. Here is a trivial example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "5\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "d = {(x, x + 1): x for x in range(10)}  # Create a dictionary with tuple keys\n",
    "t = (5, 6)        # Create a tuple\n",
    "print(type(t))    # Prints \"<class 'tuple'>\"\n",
    "print(d[t])       # Prints \"5\"\n",
    "print(d[(1, 2)])  # Prints \"1\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[The documentation](https://docs.python.org/3.5/tutorial/datastructures.html#tuples-and-sequences) has more information about tuples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flow Control\n",
    "\n",
    "### If\n",
    "\n",
    "'If' statement is quite straightforward in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is a positive number\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "if x == 0:\n",
    "    print('x is zero')\n",
    "elif x > 0:\n",
    "    print('x is a positive number')\n",
    "else:\n",
    "    print('x is a negative number')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For\n",
    "\n",
    "'For' is quite straightforward too. Different from other languages, 'For' is usually used for looping lists, dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is a negative number\n",
      "x is a negative number\n",
      "x is a negative number\n",
      "x is zero\n",
      "x is a positive number\n",
      "x is a positive number\n",
      "x is a positive number\n"
     ]
    }
   ],
   "source": [
    "series = [-3,-2,-1,0,1,2,3]\n",
    "for x in series:\n",
    "    if x == 0:\n",
    "        print('x is zero')\n",
    "    elif x > 0:\n",
    "        print('x is a positive number')\n",
    "    else:\n",
    "        print('x is a negative number')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you wish to perform simple 'for loop' that iterates n times, use the `range()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is a negative number\n",
      "x is a negative number\n",
      "x is a negative number\n",
      "x is zero\n",
      "x is a positive number\n",
      "x is a positive number\n",
      "x is a positive number\n"
     ]
    }
   ],
   "source": [
    "for idx in range(len(series)):\n",
    "    if series[idx] == 0:\n",
    "        print('x is zero')\n",
    "    elif series[idx] > 0:\n",
    "        print('x is a positive number')\n",
    "    else:\n",
    "        print('x is a negative number')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While\n",
    "\n",
    "Python only support one kind of while: checking condition at the start of each loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is a negative number\n",
      "x is a negative number\n",
      "x is a negative number\n",
      "x is zero\n",
      "x is a positive number\n",
      "x is a positive number\n",
      "x is a positive number\n"
     ]
    }
   ],
   "source": [
    "idx = 0\n",
    "while (idx < len(series)):\n",
    "    if series[idx] == 0:\n",
    "        print('x is zero')\n",
    "    elif series[idx] > 0:\n",
    "        print('x is a positive number')\n",
    "    else:\n",
    "        print('x is a negative number')\n",
    "    idx += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[The documentation](https://docs.python.org/3.5/tutorial/controlflow.html#) has more information about flow control tools."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Python functions are defined using the `def` keyword. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "negative\n",
      "zero\n",
      "positive\n"
     ]
    }
   ],
   "source": [
    "def sign(x):\n",
    "    if x > 0:\n",
    "        return 'positive'\n",
    "    elif x < 0:\n",
    "        return 'negative'\n",
    "    else:\n",
    "        return 'zero'\n",
    "\n",
    "for x in [-1, 0, 1]:\n",
    "    print(sign(x))\n",
    "# Prints \"negative\", \"zero\", \"positive\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will often define functions to take optional keyword arguments, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Bob\n",
      "HELLO, FRED!\n"
     ]
    }
   ],
   "source": [
    "def hello(name, loud=False):\n",
    "    if loud:\n",
    "        print('HELLO, %s!' % name.upper())\n",
    "    else:\n",
    "        print('Hello, %s' % name)\n",
    "\n",
    "hello('Bob') # Prints \"Hello, Bob\"\n",
    "hello('Fred', loud=True)  # Prints \"HELLO, FRED!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a lot more information about Python functions [in the documentation.](https://docs.python.org/3.5/tutorial/controlflow.html#defining-functions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes\n",
    "\n",
    "The syntax for defining classes in Python is straightforward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Fred\n",
      "HELLO, FRED!\n"
     ]
    }
   ],
   "source": [
    "class Greeter(object):\n",
    "\n",
    "    # Constructor\n",
    "    def __init__(self, name):\n",
    "        self.name = name  # Create an instance variable\n",
    "\n",
    "    # Instance method\n",
    "    def greet(self, loud=False):\n",
    "        if loud:\n",
    "            print('HELLO, %s!' % self.name.upper())\n",
    "        else:\n",
    "            print('Hello, %s' % self.name)\n",
    "\n",
    "g = Greeter('Fred')  # Construct an instance of the Greeter class\n",
    "g.greet()            # Call an instance method; prints \"Hello, Fred\"\n",
    "g.greet(loud=True)   # Call an instance method; prints \"HELLO, FRED!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can read a lot more about Python classes [in the documentation.](https://docs.python.org/3.5/tutorial/classes.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mutable vs. Immutable\n",
    "\n",
    "Unlike low-level programming language, we don't need to handle memory address and pointer in Python. Python already handle this part by classifying objects into 2 types: mutable or immutable.\n",
    "\n",
    "Lets dive deeper into the details of it. Everything in Python is an object. Each object contains three attribute when initiated:\n",
    "\n",
    "* __Identity:__ Usually corresponds to the object's location in the memory. Unchangeable once object is initiated. Can be viewed by calling `id()`.  \n",
    "* __Type:__ The type of an object. Unchangeable once object is initiated. Can be retrieved by `type()`.  \n",
    "* __Value:__ The real content of an object. Can be changeable for mutable object. Unchangeable for immutable object.  \n",
    "\n",
    "Common immutable objects include:\n",
    "* Basic data types: int, float, complex, string\n",
    "* Tuple\n",
    "\n",
    "Common mutable objects:\n",
    "* List\n",
    "* Dictionary\n",
    "* Set\n",
    "\n",
    "Let's look at a some examples to understand the mechanism:\n",
    "\n",
    "### Example 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4426243848\n",
      "4426243848\n",
      "[10, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "print(id(a))\n",
    "a[0] = 10\n",
    "print(id(a))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since list is a mutable object, its identity (memory address) is not changed even its element is altered.\n",
    "\n",
    "### Example 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: 1 , id: 4393839280\n",
      "b: 1 , id: 4393839280\n",
      "c: 2 , id: 4393839312\n",
      "a: 2 , id: 4393839312\n",
      "b: 1 , id: 4393839280\n",
      "c: 2 , id: 4393839312\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = a\n",
    "c = a + 1\n",
    "print('a:', a, ', id:', id(a))\n",
    "print('b:', b, ', id:', id(b))\n",
    "print('c:', c, ', id:', id(c))\n",
    "a = 2\n",
    "print('a:', a, ', id:', id(a))\n",
    "print('b:', b, ', id:', id(b))\n",
    "print('c:', c, ', id:', id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different from C++, '=' in Python indicates __assign by reference instead of assign by value__.  \n",
    "* In the first line 'a = 1', we create two objects: 'a' and integer 1. We assign 'a' to point to integer 1.  \n",
    "* Therefore when we enter 'b = a', we also assign 'b' to point to integer 1.  So 'b' and 'a' share the same identity.  \n",
    "* However, when we create 'c' by 'c = a + 1', 'c' should have value 2. So Python creates a new object: integer 2, then assign 'c' to point to integer 2.  \n",
    "* At last, the line 'a=2' infers Python to point 'a' to integer 2, which is already created by 'c'. So 'a' and 'c' now share the same identity.\n",
    "\n",
    "### Example 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4427002000\n"
     ]
    }
   ],
   "source": [
    "a = (1, 2, [3])\n",
    "print(id(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-47-c8548dbc0a7e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "a[0] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since tuple is immutable object, its value could not be changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4427002000\n",
      "(1, 2, [100])\n"
     ]
    }
   ],
   "source": [
    "a[2][0] = 100\n",
    "print(id(a))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if a immutable container (e.g. tuple) contains mutable object (e.g. list), the value within mutable object can be changed. It's because changes only apply to value of the mutable object, not identity.\n",
    "\n",
    "### Example 4\n",
    "\n",
    "See if you can understand the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "def haha(x):\n",
    "    x = 10\n",
    "    \n",
    "a = 1\n",
    "haha(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10]\n"
     ]
    }
   ],
   "source": [
    "def hihi(x):\n",
    "    x[0] = 10\n",
    "    \n",
    "b = [1]\n",
    "hihi(b)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, [10])\n"
     ]
    }
   ],
   "source": [
    "def hehe(x):\n",
    "    x[2][0] = 10\n",
    "    \n",
    "c = (1,2,[3])\n",
    "hehe(c)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, [3]]\n"
     ]
    }
   ],
   "source": [
    "def hoho(x):\n",
    "    x = [1]\n",
    "    \n",
    "d = [1,2,[3]]\n",
    "hoho(d)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python function creates copied objects for each argument.  \n",
    "* In the first snippet, haha() creates object 'x' on function call. In the function, we assign 'x' to a new object: integer 10. Hence 'a' is not changed.  \n",
    "* In the second snippet, hihi() creates object 'x' on function call. Different from first snippet, 'x' is a list, which is a mutable object. Once we change the value in the list by 'x\\[0\\] = 10', we change the value of the 'b' list as well.  \n",
    "* In the third snippet, hehe() performs the same as in example 3, but in a function call. So the changes made to the element in list, which is inside a tuple, is also visible outside function call.  \n",
    "* In the last snippet, hoho() creates a new object list '\\[1\\]', and assign 'x' to point to that list. Therefore 'd' is not changed.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python 2 to Python 3 conversion guide:\n",
    "\n",
    "There are currently two different supported versions of Python, 2.X and 3.X. Somewhat confusingly, Python 3.X introduced many __backwards-incompatible__ changes to the language, so code written for 2.X may not work under 3.X and vice versa. \n",
    "\n",
    "You can check your Python version at the command line by running `python --version`.\n",
    "\n",
    "We will be using Python 3.X through out this tutorial. If you're familiar with Python 2.X, here are some of the most common changes from Python 2.X to look out for.\n",
    "\n",
    "### Print is a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without parentheses, printing will not work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "Missing parentheses in call to 'print'. Did you mean print(\"Hello!\")? (<ipython-input-54-9d266092e9bc>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-54-9d266092e9bc>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    print \"Hello!\"\u001b[0m\n\u001b[0m                 ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m Missing parentheses in call to 'print'. Did you mean print(\"Hello!\")?\n"
     ]
    }
   ],
   "source": [
    "print \"Hello!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Floating point division by default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To do integer division, we use two backslashes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 // 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### No xrange\n",
    "\n",
    "The xrange from Python 2 is now merged into \"range\" for Python 3 and there is no xrange in Python 3. In Python 3, range(3) does not create a list of 3 elements as it would in Python 2, rather just creates a more memory efficient iterator.\n",
    "\n",
    "Hence,  \n",
    "xrange in Python 3: Does not exist  \n",
    "range in Python 3: Has very similar behavior to Python 2's xrange  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 3)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "# If need be, can use the following to get a similar behavior to Python 2's range:\n",
    "print(list(range(3)))"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}