intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A whirlwind tour of python\n",
    "\n",
    "The goal of this notebook is to quickly get you refreshed with the basic constructs of python. Knowledge of prior programming experience is assumed. This is by no means a complete guide, just key points you can build around.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# 1. Getting started\n",
    "\n",
    "Working with python is simple. Two main ways use the interpreter, writing your code in a `.py` file and executing it with python as such `python my_prog.py`, or opening the python interpreter and directly interacting with it -\n",
    "```\n",
    "[ ~/Desktop ] » python\n",
    "Python 2.7.6 (default, Sep  9 2014, 15:04:36) \n",
    "[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.39)] on darwin\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    "```\n",
    "```python\n",
    ">>> print \"hello world\"\n",
    "hello world\n",
    ">>> \n",
    "```\n",
    "The interpreter mode is great for testing code snippets and playing with language features. Note that given that python is an interpreted language, there is no compiling to be done."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simplest program we can start with is the traditional hello world program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "print \"hello world\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# 2. Variables and types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables don't need to be declared with a type (as in most statically typed languages), just assign a value to a variable and start using it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "how are you\n"
     ]
    }
   ],
   "source": [
    "greeting = \"how are you\"\n",
    "print greeting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "num = 5\n",
    "print num+3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note :** If you try to use a variable before assigning it, then the interpreter will throw an error (NameError)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'xyz' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-2ff31fe8e453>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mprint\u001b[0m \u001b[0mxyz\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'xyz' is not defined"
     ]
    }
   ],
   "source": [
    "print xyz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are various inbuilt types in Python, few key ones are **:** *`int, float, str, None, bool, dict, list, tuple \n",
    "Exception, method, function, generator, iterator, etc`*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`int` and `float` are the general numeral types, and you can perform arithmetic operations on them. \n",
    "\n",
    "`str` is the string type, `bool` is boolean, `dict, list, tuple` are commonly used built in data structures.\n",
    "\n",
    "`None` is similar to \"null\" which we see in other languages. It basically signifies that the variable holds no value as such.\n",
    "\n",
    "The rest we'll cover later!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(cover truthsy and falsey values here) -- or as a note later on?\n",
    "\n",
    "Booleans can hold two values - True or False. `True` and `False` are python reserved words. General boolean operators apply. Boolean operators are not represented by the traditional characters such as `||, &&, !` rather by the corresponding words `or, and, not`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "t = True\n",
    "f = False\n",
    "\n",
    "print t or f\n",
    "print t and f\n",
    "print not t\n",
    "print t == f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other than True and False there is also a concept of Truthy and Falsey values.\n",
    "Truthy and Falsey are values of other types (like integer and string) that evaluate to True and False. But aren't exactly equivalent. This concept of truthy and falsey is extremely useful (in terms of syntactic sugar) while working with conditionals (if-else statements)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "y = 0\n",
    "s = \"\"\n",
    "r = \"hello\"\n",
    "\n",
    "# any value for which bool(val) == True is a truthy and bool(val) == False\n",
    "print bool(x) # for integers, any non zero is a truthy\n",
    "print bool(y)\n",
    "print bool(s) \n",
    "print bool(r) #for strings, any non empty sting is a truthy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Integers and Floats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integers and floats are numeric types and usual mathematical operations hold true. In case of integer division, the quotient gets floored. In case of operations involving both integers and floats, the result gets type converted to float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'int'>\n",
      "<type 'float'>\n",
      "128 615 118 24\n",
      "126.0 41.0\n"
     ]
    }
   ],
   "source": [
    "# random experiments\n",
    "x = 123\n",
    "y = 5\n",
    "z = 3.0\n",
    "print type(x)\n",
    "print type(z)\n",
    "print x+y, x*y, x-y, x/y\n",
    "print x+z, x/z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1.0\n",
      "5\n",
      "3.0\n"
     ]
    }
   ],
   "source": [
    "# more operations\n",
    "print x % y # modulo\n",
    "print y // z # for flored quotient in case of floats\n",
    "print int(y)\n",
    "print float(z)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are quite powerful in python, allowing a variety of operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10\n",
      "<type 'str'>\n",
      "5\n",
      "HELLO\n"
     ]
    }
   ],
   "source": [
    "s = \"hello\"\n",
    "print str(-10) # gets converted to string as is\n",
    "print type(\"abc\")\n",
    "print len(s)\n",
    "print s.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n",
      "--*----*----*--\n"
     ]
    }
   ],
   "source": [
    "#sting concatination\n",
    "\n",
    "s = \"Hello\"\n",
    "w = \"world!\"\n",
    "\n",
    "result = s + \", \"+ w\n",
    "print result\n",
    "\n",
    "# can concatinate by multiplying\n",
    "print \"--*--\" * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "H\n",
      "G\n",
      "BC\n",
      "ABCDEFGH\n",
      "ACEG\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Indexing a string -it behaves like an array\n",
    "s = \"ABCDEFGH\"\n",
    "print s[0] # 0th index\n",
    "print s[-1] # last index\n",
    "print s[-2] # last but one index\n",
    "\n",
    "# slicing\n",
    "print s[1:3] # 1st index till 3rd (3rd not included)\n",
    "print s[:] # whole string\n",
    "print s[::2] # skip every 2nd element starting from 1st one\n",
    "print s[-1:-5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello foo and bar\n",
      "hello one and two\n"
     ]
    }
   ],
   "source": [
    "template = \"hello %s and %s\"\n",
    "names = (\"foo\", \"bar\")\n",
    "print template % names # if there is only one formatter \"%s\", then names can be a string\n",
    "\n",
    "#t = \"hello {0} and {1}\"\n",
    "#print t.format(\"one\", \"two\") #this produces identical output as  the following\n",
    "\n",
    "t = \"hello {i} and {j}\"\n",
    "print t.format(i=\"one\", j=\"two\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The inbuilt list in python is simply the linked list data structure. It is a hetrogeneous list capable of having any kind of object, including more lists. Structure wise it is like an array, except that the List type supports more sophisticated operations. In terms of the nature of operations, it is quite similar to strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "<type 'list'>\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "print a\n",
    "print type(a)\n",
    "print len(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 6]\n",
      "['1', 2, 3.0, True]\n",
      "None\n",
      "[True, 2, 3.0, '1']\n"
     ]
    }
   ],
   "source": [
    "b = [3,6,2,1,0]\n",
    "b.sort()\n",
    "print b\n",
    "\n",
    "c = [\"1\", 2, 3.0, True]\n",
    "print c\n",
    "print c.sort() # no return value, hence prints None\n",
    "print c # shouldn't sort hetrogeneous lists :("
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "[6, 5, 4, 3, 2, 1, 0]\n",
      "['h', 'e', 'l', 'l', 'o']\n"
     ]
    }
   ],
   "source": [
    "a = [0,1,2,3,4,5,6]\n",
    "print a[0]\n",
    "print a[::-1] # reverses it - slicing is similar to strings\n",
    "# print a[100] - Error!\n",
    "\n",
    "print list(\"hello\") # each individual character becomes a list element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print [1,2, 3] + [4,5] # list concatination\n",
    "print [1,2,3] * 2 # again, similar to strings\n",
    "# print [1,2,3] * [4,5] -- Error!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# lists are mutable\n",
    "a = [1,2,3]\n",
    "b = a\n",
    "a.append(4)\n",
    "print a\n",
    "print b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are similar to lists, except for the fact that they are immutable. Conventionally they are used for homogeneous data (eg, to represent a point in coordinate space)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "2\n",
      "(1, 2, 3)\n",
      "(1, 2, 3, 4) (1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "a = (1,2,3)\n",
    "print a\n",
    "print a[1]\n",
    "print a[:]\n",
    "b = a\n",
    "# a[1] = 4 - Error! can't assign. tuples are immutable.\n",
    "a = a + (4,)\n",
    "print a, b # b remains unchanged"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.6 Dicts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries in python are similar to hashmaps. They store key value pairs. Dicts can store hetrogeneous values, the keys can be any type as far as it is \"hashable\". eg, Integers and Strings are hashable, lists are not. Unlike lists and tuples, there is no sense of order in a dict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one two\n",
      "['1', 2, 'three']\n",
      "['one', 'two', 3.0]\n",
      "None\n",
      "five\n"
     ]
    }
   ],
   "source": [
    "# way to declare a dictonary \n",
    "a = {\"1\" : \"one\", 2 : \"two\", \"three\" : 3.0}\n",
    "print a[\"1\"], a[2]\n",
    "\n",
    "# to get list of keys and values respectively\n",
    "print a.keys()\n",
    "print a.values()\n",
    "\n",
    "# print a[5] -- Error! Key doesn't exist\n",
    "print a.get(5) #safe way to do it\n",
    "print a.get(5, \"five\") # default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'1': 'one', 2: 'two', '5': 'five', 'three': 3.0, '4': 4}\n",
      "{'1': 'one', 2: 'two', '5': 'five', 'three': 3.0, '4': 4}\n",
      "{'1': 'one', '5': 'five', '4': 'four'}\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# to update the dict\n",
    "b = {\"4\" : 4, \"5\" : \"five\"}\n",
    "c = a\n",
    "a.update(b)\n",
    "print a # a is updated with b's value\n",
    "print c # dicts are mutable, c is also updated\n",
    "\n",
    "# to update a value\n",
    "a['4'] = 'four'\n",
    "\n",
    "# to delete a value\n",
    "a.pop(2)\n",
    "a.pop('three')\n",
    "print a\n",
    "print len(a) # to get the size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two kinds of looping constructs in python. `for` and `while`\n",
    "\n",
    "The `for loop` expects an iterable to \"loop over\". Each time in the loop, the loop variable picks the next value from the iterable object. Lists, dicts, tuples and strings are examples of iterable objects. An object that has an `__iter__` and `next()` method is said to be iterable.\n",
    "\n",
    "range and xrange are two other builtin functions that are iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number 0\n",
      "number 1\n",
      "number 2\n"
     ]
    }
   ],
   "source": [
    "# for loops\n",
    "for i in range(3):\n",
    "    print \"number\", i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number 0\n",
      "number 1\n",
      "number 2\n"
     ]
    }
   ],
   "source": [
    "# while loops\n",
    "count = 0\n",
    "while count < 3:\n",
    "    print \"number\", count\n",
    "    count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "looping through list\n",
      "1 2 3 \n",
      "looping through tuple\n",
      "1 2 3 \n",
      "looping through dict\n",
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "print \"looping through list\"\n",
    "for i in [1,2,3]:\n",
    "    print i,\n",
    "\n",
    "print \"\\nlooping through tuple\"\n",
    "for i in (1,2,3):\n",
    "    print i,\n",
    "\n",
    "print \"\\nlooping through dict\"\n",
    "for i in {1:1, 2:4, 3:9}:\n",
    "    print i,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "continue statement\n",
      "cont.\n",
      "cont.\n",
      "break statement\n",
      "brk\n"
     ]
    }
   ],
   "source": [
    "print \"continue statement\"\n",
    "for i in range(2):\n",
    "    print \"cont.\"\n",
    "    continue\n",
    "    print \"oops\" # never printed\n",
    "\n",
    "print \"break statement\"\n",
    "for i in range(10):\n",
    "    print \"brk\"\n",
    "    break # loop exited"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ok\n",
      "ok\n",
      "loop exited normally\n",
      "----------\n",
      "ok\n"
     ]
    }
   ],
   "source": [
    "# here the loop exits\n",
    "for i in range(2):\n",
    "    print \"ok\"\n",
    "else:\n",
    "    print \"loop exited normally\"\n",
    "    \n",
    "print \"-\" * 10\n",
    "# here the loop exits\n",
    "for i in range(2):\n",
    "    print \"ok\"\n",
    "    break\n",
    "else:\n",
    "    print \"the one with break\" # gets printed only when loop terminates by loop condition becoming false!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------\n",
    "\n",
    "Do check out different ways to use `range`, read up about `itertools`, different ways of iterating through dicts and writing your own iterator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's conditional constructs include `if`, `else` and `elif`. Unlike C like languages, it does not support switch case.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a :  4\n"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "b = 0\n",
    "if a:\n",
    "    print \"a : \", a\n",
    "if b:\n",
    "    print \"b : \", b # not printed as 0 is a falsey value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x\n",
      "z\n"
     ]
    }
   ],
   "source": [
    "if a:\n",
    "    print \"x\"\n",
    "if b:\n",
    "    print \"y\"\n",
    "else: #this links to closest if at the same indentation level\n",
    "    print \"z\"\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x\n"
     ]
    }
   ],
   "source": [
    "if a:\n",
    "    print \"x\"\n",
    "    if b:    # nested if, does not affect outer else\n",
    "        print \"y\"\n",
    "else:\n",
    "    print \"z\"\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d\n"
     ]
    }
   ],
   "source": [
    "if b:\n",
    "    print \"b\"\n",
    "elif 3>4:\n",
    "    # evaluates to false\n",
    "    print \"c\"\n",
    "elif \"hi\":\n",
    "    # \"hi\" is a truthy (non empty string)\n",
    "    print \"d\"\n",
    "else:\n",
    "    print \"e\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If statements can also be used to assign values to variables, this is somewhat similar to ternary operators in C like languages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "a = True \n",
    "# of the format \"var = val_1 if cond else val_2\"\n",
    "b = 5 if a else 6\n",
    "print b\n",
    "\n",
    "# due to operator precedence and short-circuiting the following statement is equivalent to the \"if else\" one\n",
    "b = a and '1' or '2'\n",
    "print b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "functions, how they're objects, passing them around, multiple params, default values (also talk about lists), deconstructing tuple return values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "def foo(a,b):\n",
    "    '''This is a doc string, used for documentation'''\n",
    "    return a+b\n",
    "\n",
    "print foo(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "def bar(func, a,b):\n",
    "    return func(a,b)\n",
    "\n",
    "# functions can be passed around like any other objects\n",
    "print bar(foo, 1,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Functions are objects!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function foo at 0x10a843f50> <type 'function'>\n",
      "Function name is foo\n",
      "DOC STRING : This is a doc string, used for documentation\n"
     ]
    }
   ],
   "source": [
    "print foo, type(foo)\n",
    "print \"Function name is\", foo.func_name\n",
    "print \"DOC STRING :\", foo.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "(2, 3, 4)\n",
      "{'six': 6, 'five': 5}\n"
     ]
    }
   ],
   "source": [
    "# functions can take multiple parameters - both named and unnamed\n",
    "\n",
    "def demo(fixed, *args, **kwargs):\n",
    "    print fixed\n",
    "    print args # comes in as a list\n",
    "    print kwargs # comes in as a dict\n",
    "    \n",
    "demo(1, 2, 3, 4, five=5, six=6)\n",
    "# note the order \n",
    "# - first necessary params should be \n",
    "# - second all unnamed parameters should follow\n",
    "# - finally the key value pairs    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "(2, 3, 4)\n",
      "{'six': 6, 'five': 5}\n"
     ]
    }
   ],
   "source": [
    "# lists and dicts can be deconstructed on the fly\n",
    "demo(1, *[2,3,4], **{\"five\" : 5, \"six\" : 6})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# function parameters can have default values\n",
    "def foo(a, b=5):\n",
    "    print a+b\n",
    "\n",
    "foo(1) # takes default value of b\n",
    "foo(1,2) # overide value of b \n",
    "foo(a=2, b=2)\n",
    "\n",
    "#note the order while dealing with default values\n",
    "# as follows - def foo(a, b=5, *args, **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 1, 1, 4]\n",
      "[1, 2, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "# careful while assigning default values that are mutable in nature\n",
    "def foo(a,l=[1,2]):\n",
    "    l.append(a)\n",
    "    print l\n",
    "    \n",
    "foo(3)\n",
    "foo(4, [1,1,1])\n",
    "foo(5) # old value of 'l' is reused!!\n",
    "\n",
    "# This happens as the default value (in this case [1,2]) \n",
    "#  is bound to the variable when the function is defined!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 6\n",
      "(5, 6) <type 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "# multiple return values\n",
    "\n",
    "def foo(a,b):\n",
    "    return a+b, a*b\n",
    "\n",
    "add, prod = foo(2,3)\n",
    "print add, prod\n",
    "\n",
    "# python functions cannot return multiple values, though it seems like that\n",
    "# what it's actually returning is a tuple, which gets deconstructed on the LHS\n",
    "print foo(2,3), type(foo(2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classes serve the same purpose in python as it does in any other language - it provides user defined abstraction. It gives you a way to create custom objects which are a type of your class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "class Point(object):\n",
    "    def __init__(self, x, y):\n",
    "        #self refers to the object itself\n",
    "        # now define the instance variables\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def print_x(self):\n",
    "        print self.x\n",
    "\n",
    "    def print_y(self):\n",
    "        print self.y\n",
    "        \n",
    "p = Point(2,3)\n",
    "p.print_x()\n",
    "p.print_y()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "This is y: 2\n",
      "This is z : 3\n"
     ]
    }
   ],
   "source": [
    "class Point3D(Point):\n",
    "    def __init__(self, x, y, z):\n",
    "        # if child class does not have a init, directly goes to parent. \n",
    "        # If child has init does not automatically go to parent's __init__\n",
    "        self.z = z\n",
    "        super(Point3D, self).__init__(x, y)\n",
    "    \n",
    "    def print_z(self):\n",
    "        print \"This is z :\", self.z\n",
    "        \n",
    "    def print_y(self):\n",
    "        print \"This is y:\", self.y\n",
    "        \n",
    "pp = Point3D(1,2,3)\n",
    "pp.print_x() # goes to base class's print_x\n",
    "pp.print_y() # override\n",
    "pp.print_z() \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "<class '__main__.test'>\n",
      "<class '__main__.test2'>\n",
      "10 10 10 10\n"
     ]
    }
   ],
   "source": [
    "class test(object):\n",
    "    fox = 10\n",
    "    \n",
    "    @staticmethod\n",
    "    def s_met():\n",
    "        return test.fox\n",
    "    \n",
    "    @classmethod\n",
    "    def c_met(cls):\n",
    "        # cls passed is the object's cls, not necessarily this class\n",
    "        # so in case a obj of child class calls this, cls will be the child class\n",
    "        print cls \n",
    "        \n",
    "\n",
    "class test2(test):\n",
    "    pass\n",
    "    \n",
    "t = test()\n",
    "print t.s_met()\n",
    "t.c_met()\n",
    "\n",
    "t2 = test2()\n",
    "t2.c_met()\n",
    "print t.fox, t2.fox, test.fox, test2.fox # all resolve to same variable "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exceptions are quite similar to what you would expect in any other language. general syntax :\n",
    "```py\n",
    "try:\n",
    "  # try block\n",
    "except XyzException as e:\n",
    "  # exception handling\n",
    "finally:\n",
    "  # so something\n",
    "```\n",
    "\n",
    "Most of the builtin exceptions are named of the form XyzError, where Xyz is the error type. All exceptions inherit from the BaseException class. User defined exceptions should inherit from Exception class (which inturn inherits BaseException)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trying\n",
      "integer division or modulo by zero <type 'exceptions.ZeroDivisionError'>\n",
      "integer division or modulo by zero\n",
      "Finally block\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Python/2.7/site-packages/ipykernel/__main__.py:8: DeprecationWarning: BaseException.message has been deprecated as of Python 2.6\n"
     ]
    }
   ],
   "source": [
    "def foo():\n",
    "    try:\n",
    "        print \"trying\"\n",
    "        print 0/0\n",
    "        print \"oops...\"\n",
    "    except ZeroDivisionError as e: \n",
    "        # we could have ommited \"ZeroDivisionError\" for a catch-all case, but thats bad practice\n",
    "        print e, type(e)\n",
    "        print e.message\n",
    "    finally:\n",
    "        print \"Finally block\"\n",
    "\n",
    "foo()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trying\n",
      "list index out of range\n",
      "||| finally |||\n"
     ]
    },
    {
     "ename": "ZeroDivisionError",
     "evalue": "integer division or modulo by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-214-bd6f9555855b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     16\u001b[0m         \u001b[0;32mprint\u001b[0m \u001b[0;34m\"||| finally |||\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m \u001b[0mfoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-214-bd6f9555855b>\u001b[0m in \u001b[0;36mfoo\u001b[0;34m()\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mIndexError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m         \u001b[0;32mprint\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m         \u001b[0;32mprint\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     13\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mZeroDivisionError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m         \u001b[0;32mprint\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: integer division or modulo by zero"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "\n",
    "# In a try except block, an exception can be caught only once.\n",
    "# if an exception is thrown within an except block, \n",
    "#    finally immediately executes and the new exception is propogated!\n",
    "def foo():\n",
    "    try:\n",
    "        print \"trying\"\n",
    "        print a[1]\n",
    "    except IndexError as e:\n",
    "        print e\n",
    "        print 0/0\n",
    "    except ZeroDivisionError as e: \n",
    "        print e\n",
    "    finally:\n",
    "        print \"||| finally |||\"\n",
    "\n",
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trying\n",
      "1\n",
      "everything went fine\n",
      "finally\n"
     ]
    }
   ],
   "source": [
    "# a try except else block is also possible\n",
    "# like how finally executes irrespective of whether except has been executed or not, \n",
    "#   else executes only if an except block has not been executed\n",
    "\n",
    "def foo():\n",
    "    try:\n",
    "        print \"trying\"\n",
    "        print 1/1\n",
    "    except ZeroDivisionError as e: \n",
    "        print e\n",
    "    else:\n",
    "        print \"everything went fine\"\n",
    "    finally:\n",
    "        print \"finally\"\n",
    "\n",
    "foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------\n",
    "**Note** that KeyboardInterrupt (thrown when crtl+C) inherits directly from BaseException (and not Exception) so as to not be caught by mistake by a catch all exception clause."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}