Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to Python\n",
    "\n",
    "---\n",
    "\n",
    "**Difficulty level**: undergraduate\n",
    "\n",
    "\n",
    "### Objectives:\n",
    "\n",
    "1. Learn about Python\n",
    "2. Get to speed with writing programs in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Introducing Python\n",
    "---\n",
    "\n",
    "Python is:\n",
    "\n",
    "* A high-level programming langauge\n",
    "* Dynamically, Strongly typed\n",
    "* For general-purpose computing\n",
    "* Interpreted\n",
    "* Automatic/Internal Memory Management\n",
    "* Object-oriented, Structural, a \"little\" Functional and Aspect-Oriented\n",
    "\n",
    "CPython is an open-source implementation of Python\n",
    "\n",
    "Was first written in late 1980s by Guido van Rossum.\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Advantages of learning Python (over other high-level languages)\n",
    "---\n",
    "\n",
    "* Generally uses fewer lines of code to express concepts\n",
    "* Has libraries for literally anything you can think of (Web, Mobile, Scientific, Data Storage, etc.)\n",
    "* Dynamically and strongly typed? Has support for type-hinting\n",
    "* More productive; can be used for small to large products; prototyping to production-grade systems\n",
    "* Has an open-source implementation\n",
    "\n",
    "Most linux distributions ship with Python 2.7.\n",
    "\n",
    "In this course, we're going to use Python 3.4+. The Python 2 series are scheduled to be deprecated by 2020.\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Contents\n",
    "---\n",
    "\n",
    "** Basics **\n",
    "- The \"hello world\"\n",
    "- Basics\n",
    "    + Variable Assignments\n",
    "    + Function calls\n",
    "    + Variable scope\n",
    "    + Input and Output\n",
    "    + Exception handling\n",
    "    + Loops and conditional statements\n",
    "- Data Types\n",
    "    + Mutable and non-mutable types\n",
    "    + Iterators and Generators\n",
    "    + Closures\n",
    "    + Decorators\n",
    "- Packaged utilities\n",
    "    + Collections\n",
    "    + Itertools\n",
    "- A bit of OOP\n",
    "- Using external libraries\n",
    "- Basic packaging\n",
    "\n",
    "** Application Development Examples **\n",
    "- A web server\n",
    "- Data crunching with numpy and pandas\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The \"Hello World\"\n",
    "---\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    \n",
    "    print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Basics\n",
    "---\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "** Variable Assignments **\n",
    "\n",
    "Python uses duck-typing...\n",
    "It is dynamically, but strongly typed.\n",
    "\n",
    "x = 2 # int\n",
    "y = '5' # or y = \"5\"; String\n",
    "z = 2.0 # float\n",
    "t = [1, 2] # This is a list - which is similar to your linked list (more on this later)\n",
    "\n",
    "print(x + z) # Involves automatic type conversion to float, since z is a float\n",
    "\n",
    "del x # Deleting a variable\n",
    "\n",
    "try:\n",
    "    print(y + z) # Throws an error as type casting is not done.\n",
    "except TypeError:\n",
    "    print(\"TypeError occurred\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n",
      "TypeError occurred\n"
     ]
    }
   ],
   "source": [
    "x = 2 # int\n",
    "y = '5' # or y = \"5\"; String\n",
    "z = 2.0 # float\n",
    "t = [1, 2] # This is a list - which is similar to your linked list (more on this later)\n",
    "\n",
    "print(x + z) # Involves automatic type conversion to float, since z is a float\n",
    "\n",
    "del x # Deleting a variable\n",
    "\n",
    "try:\n",
    "    print(y + z) # Throws an error as type casting is not done.\n",
    "except TypeError:\n",
    "    print(\"TypeError occurred\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Function Calls**\n",
    "\n",
    "Built-in functions listed at: https://docs.python.org/3/library/functions.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "defining a function\n",
      "1 2 2\n",
      "1 2 5\n",
      "--\n",
      "defining a function with arbitrary number of arguments\n",
      "1\n",
      "--\n",
      "1\n",
      "2\n",
      "3\n",
      "defining a function with arbitrary number of arguments after compulsory arguments\n",
      "1 2 (3, 4, 5)\n",
      "calling a function using a dictionary of values that pose as arguments\n",
      "1 2 ()\n",
      "a function with arguments of all kinds\n",
      "1 2 (2, 3, 4) {'z': 5}\n",
      "anonymous function\n",
      "4\n",
      "examples of builtin functions\n",
      "sorted\n",
      "[1, 2, 10, 11, 22, 23, 33, 44]\n",
      "filter\n",
      "[22, 33, 44, 11, 23]\n",
      "length\n",
      "3\n",
      "max\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# defining a fucntion\n",
    "\n",
    "print (\"defining a function\")\n",
    "def foo(x, y, a=5): # x and y are positional parameters, a has a default value of 5\n",
    "    print(x, y, a)\n",
    "\n",
    "foo(1, 2, 2)\n",
    "foo(1, 2)\n",
    "print(\"--\")\n",
    "\n",
    "# defining a function with variable number of arguments\n",
    "print (\"defining a function with arbitrary number of arguments\")\n",
    "def foo(*args):\n",
    "    for a in args:\n",
    "        print(a)\n",
    "\n",
    "foo(1)\n",
    "print(\"--\")\n",
    "foo(1,2,3)\n",
    "\n",
    "# defining a function with variable number of arguments after compulsary arguments\n",
    "print (\"defining a function with arbitrary number of arguments after compulsory arguments\")\n",
    "def foo(x, y, *args):\n",
    "    print(x, y, args)\n",
    "    \n",
    "foo(1, 2, 3, 4, 5)\n",
    "\n",
    "# calling a function using a dictionary of values\n",
    "print (\"calling a function using a dictionary of values that pose as arguments\")\n",
    "foo(**{\"x\": 1, \"y\": 2})\n",
    "\n",
    "# everything in one function\n",
    "print(\"a function with arguments of all kinds\")\n",
    "def foo(x, *args, y=1, **kwargs):\n",
    "    print(x, y, args, kwargs)\n",
    "\n",
    "foo(1, 2, 3, 4, y=2, z=5)\n",
    "\n",
    "# anonymous functions\n",
    "print(\"anonymous function\")\n",
    "sqr = lambda x: x*x\n",
    "print(sqr(2))\n",
    "\n",
    "print(\"examples of builtin functions\")\n",
    "# some useful built-in functions\n",
    "print(\"sorted\")\n",
    "print(sorted([10, 2, 22, 1, 33, 44, 11, 23])) # sorted\n",
    "print(\"filter\")\n",
    "print(list(filter(lambda x: x > 10, [10, 2, 22, 1, 33, 44, 11, 23]))) # filter\n",
    "print(\"length\")\n",
    "print(len([1,2,3])) # len\n",
    "print(\"max\")\n",
    "print(max([1,2,3])) # max\n",
    "\n",
    "# checkout the documentation for other such built-ins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Variable Scope**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "0\n",
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "\n",
    "def foo():\n",
    "    x = 1\n",
    "    print(x)\n",
    "\n",
    "def foo2():\n",
    "    global x\n",
    "    x = 1\n",
    "    print(x)\n",
    "    \n",
    "print(x)\n",
    "foo()\n",
    "print(x)\n",
    "foo2()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "** Input and Ouput **\n",
    "\n",
    "Documentation: https://docs.python.org/3/tutorial/inputoutput.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "This is a test; number 1; float 2.000000\n",
      "This is a test; number 1; float 2.0\n",
      "Enter a number: 10\n",
      "10 <class 'str'>\n",
      "2\n",
      "3\n",
      "TypeError occurred\n"
     ]
    }
   ],
   "source": [
    "# Output\n",
    "x = 2\n",
    "print(x) # Output to screen\n",
    "\n",
    "# Formatting output\n",
    "print(\"This is a %s; number %d; float %f\" % (\"test\", 1, 2.0))\n",
    "print(\"This is a {}; number {}; float {}\".format(\"test\", 1, 2.0))\n",
    "\n",
    "open('test.txt', 'w').write(str(x)) # Output to file\n",
    "\n",
    "# Input\n",
    "x = input('Enter a number: ') # Read from screen\n",
    "print(x, type(x))\n",
    "\n",
    "x = open('test.txt', 'r').read() # Read from file\n",
    "print(x)\n",
    "\n",
    "# Type casting\n",
    "x = '2'\n",
    "print(int(x) + 1)\n",
    "try:\n",
    "    print(x + 1) # Will throw an error\n",
    "except TypeError:\n",
    "    print(\"TypeError occurred\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exception Handling**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ValueError occurred\n",
      "Error returned... invalid literal for int() with base 10: 'a'\n",
      "This gets executed irrespective of whether an exception occurred\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-67-9bb465064573>\", line 6, in <module>\n",
      "    x = int('a') # throws an exception as the string a cannot be cast to int\n",
      "ValueError: invalid literal for int() with base 10: 'a'\n"
     ]
    }
   ],
   "source": [
    "import traceback # this provides functions to get the error trace\n",
    "\n",
    "# Example of exception handling...\n",
    "\n",
    "try: # try statement\n",
    "    x = int('a') # throws an exception as the string a cannot be cast to int\n",
    "except ValueError as err: # catches an exception\n",
    "    print(\"ValueError occurred\")\n",
    "    traceback.print_exc() # prints details\n",
    "    print(\"Error returned...\", err)\n",
    "finally:\n",
    "    print(\"This gets executed irrespective of whether an exception occurred\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loops and Conditional Statements**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "if statement\n",
      "x is 5\n",
      "for loop\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "for loop: multiple vars\n",
      "1 4\n",
      "2 5\n",
      "3 6\n",
      "while loop\n",
      "0\n",
      "1\n",
      "2\n",
      "for loop with pass statement\n",
      "for loop with break statement\n",
      "0\n",
      "for loop with continue statement\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "in-line for loop\n",
      "[4, 9]\n"
     ]
    }
   ],
   "source": [
    "# if statement\n",
    "print(\"if statement\")\n",
    "x = 5\n",
    "if x == 5:\n",
    "    print(\"x is 5\")\n",
    "elif x > 5: # else if\n",
    "    print(\"x > 5\")\n",
    "else:\n",
    "    print(\"x < 5\")\n",
    "\n",
    "# for loop\n",
    "print(\"for loop\")\n",
    "for ii in range(10): # range(10) --> iterator giving 0 ... 9\n",
    "    print(ii)\n",
    "\n",
    "print(\"for loop: multiple vars\")\n",
    "for a, b in zip([1, 2, 3], [4, 5, 6]): # having multiple vars to iterate thru'\n",
    "    print(a, b)\n",
    "\n",
    "# while loop\n",
    "print(\"while loop\")\n",
    "c = 0\n",
    "while c < 3:\n",
    "    print(c)\n",
    "    c += 1\n",
    "    \n",
    "print(\"for loop with pass statement\")\n",
    "for ii in range(10):\n",
    "    pass # similar to nop in assembly code\n",
    "\n",
    "print(\"for loop with break statement\")\n",
    "for ii in range(10):\n",
    "    print(ii)\n",
    "    break # break from loop\n",
    "    \n",
    "print(\"for loop with continue statement\")\n",
    "for ii in range(10):\n",
    "    if ii < 5:\n",
    "        continue # skip loop to next iteration\n",
    "    print(ii)\n",
    "\n",
    "print(\"in-line for loop\")\n",
    "print([v * v for v in [1, 2, 3] if v >= 2]) # in-line for loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Data Types\n",
    "---\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "** Mutable and non-mutable types **\n",
    "\n",
    "Mutable Objects: Can be modified after instantiation\n",
    "non-Mutable: Can't!\n",
    "\n",
    "Python in-built data types,\n",
    "- str, int, float, complex, frozenset, tuple, bytes, complex, and bool are immutable\n",
    "- bytearray, list, set, and dict are mutable\n",
    "\n",
    "Some examples of data structures are given below.\n",
    "\n",
    "Documentation: https://docs.python.org/3/library/datatypes.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'a', 'bcd', 2.0, (2+3j), (5+6j), [5, 6]]\n",
      "[1, 2, 3, 'a', 'bcd', 2.0, (2+3j), (5+6j), [5, 6], 3]\n",
      "[1, 2, 3, 'a', 'bcd', 2.0, (2+3j), (5+6j), [5, 6], 3, 1, 2, 3]\n",
      "[2, 3, 'a', 'bcd', 2.0, (2+3j), (5+6j), [5, 6], 3, 1, 2, 3]\n",
      "[3, 2, 1, 3, [5, 6], (5+6j), (2+3j), 2.0, 'bcd', 'a', 3, 2]\n",
      "[]\n",
      "Even numbers in x [2, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "# List (A heterogeneous collection of elements)\n",
    "x = [1, int(2), 3, 'a', \"bcd\", 2.0, complex(2, 3), 5 + 6j, [5, 6]]\n",
    "print(x)\n",
    "\n",
    "# Adding an element\n",
    "x.append(3)\n",
    "print(x)\n",
    "\n",
    "# Adding many elements\n",
    "x.extend([1, 2, 3])\n",
    "print(x)\n",
    "\n",
    "# Removing (the first matching) element\n",
    "x.remove(1)\n",
    "print(x)\n",
    "\n",
    "# Reversing a list\n",
    "x.reverse()\n",
    "print(x)\n",
    "\n",
    "# Remove all elements\n",
    "x.clear()\n",
    "print(x)\n",
    "\n",
    "# Inline list comprehension\n",
    "x = [1, 2, 3, 4, 5, 6]\n",
    "print(\"Even numbers in x\", [v for v in x if v % 2 == 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'test': 1, 1: 100, 2.0: 2.35}\n",
      "{'test': 1, 1: 100, 2.0: 2.35}\n",
      "['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']\n",
      "Help on dict object:\n",
      "\n",
      "class dict(object)\n",
      " |  dict() -> new empty dictionary\n",
      " |  dict(mapping) -> new dictionary initialized from a mapping object's\n",
      " |      (key, value) pairs\n",
      " |  dict(iterable) -> new dictionary initialized as if via:\n",
      " |      d = {}\n",
      " |      for k, v in iterable:\n",
      " |          d[k] = v\n",
      " |  dict(**kwargs) -> new dictionary initialized with the name=value pairs\n",
      " |      in the keyword argument list.  For example:  dict(one=1, two=2)\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      True if D has a key k, else False.\n",
      " |  \n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      D.__sizeof__() -> size of D in memory, in bytes\n",
      " |  \n",
      " |  clear(...)\n",
      " |      D.clear() -> None.  Remove all items from D.\n",
      " |  \n",
      " |  copy(...)\n",
      " |      D.copy() -> a shallow copy of D\n",
      " |  \n",
      " |  fromkeys(iterable, value=None, /) from builtins.type\n",
      " |      Returns a new dict with keys from iterable and values equal to value.\n",
      " |  \n",
      " |  get(...)\n",
      " |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.\n",
      " |  \n",
      " |  items(...)\n",
      " |      D.items() -> a set-like object providing a view on D's items\n",
      " |  \n",
      " |  keys(...)\n",
      " |      D.keys() -> a set-like object providing a view on D's keys\n",
      " |  \n",
      " |  pop(...)\n",
      " |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n",
      " |      If key is not found, d is returned if given, otherwise KeyError is raised\n",
      " |  \n",
      " |  popitem(...)\n",
      " |      D.popitem() -> (k, v), remove and return some (key, value) pair as a\n",
      " |      2-tuple; but raise KeyError if D is empty.\n",
      " |  \n",
      " |  setdefault(...)\n",
      " |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D\n",
      " |  \n",
      " |  update(...)\n",
      " |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.\n",
      " |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]\n",
      " |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v\n",
      " |      In either case, this is followed by: for k in F:  D[k] = F[k]\n",
      " |  \n",
      " |  values(...)\n",
      " |      D.values() -> an object providing a view on D's values\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Dict (hashmap)\n",
    "\n",
    "x = {} # or x = dict()\n",
    "\n",
    "# Adding elements\n",
    "x['test'] = 1\n",
    "x[1] = 100\n",
    "x[2.0] = 2.35\n",
    "print(x)\n",
    "\n",
    "# Alternative initialization\n",
    "x = {'test': 1, 1: 100, 2.0: 2.35}\n",
    "print(x)\n",
    "\n",
    "# Removing an element\n",
    "del x['test']\n",
    "\n",
    "# To find out the methods available:\n",
    "print(dir(x))\n",
    "\n",
    "# Getting help\n",
    "help(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Iterators and Generators**\n",
    "\n",
    "- Generators are iterators: they are implemented using the *yield* keyword (that yields partial results of a function)\n",
    "- Iterators are iterables: they implement the __next__() and __iter__() methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<generator object foo at 0x7f092cb78eb8>\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "<generator object <genexpr> at 0x7f092cb78e60>\n"
     ]
    }
   ],
   "source": [
    "# Example of a generator\n",
    "\n",
    "def foo():\n",
    "    for ii in range(4):\n",
    "        yield ii # this gives out a partial result.\n",
    "\n",
    "t = foo()\n",
    "print(t) # --> Shows that the return value is a generator object\n",
    "import collections; isinstance(t, collections.Iterator) # --> This is an iterator object\n",
    "# (OOP concepts in python will be covered later...)\n",
    "\n",
    "for partial_result in t: # Iterating thru' a generator\n",
    "    print(partial_result)\n",
    "\n",
    "t = foo()\n",
    "\n",
    "#Another way to iterate thru' a generator\n",
    "while True:\n",
    "    try:\n",
    "        print(next(t))\n",
    "    except StopIteration:\n",
    "        break\n",
    "        \n",
    "# generator expressions\n",
    "t = (x*x for x in range(10))\n",
    "print(t) # --> t is a generator!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Closures**\n",
    "\n",
    "enables us to abstract out the state of a function.\n",
    "\n",
    "a closure is formed when the following three conditions are satisfied\n",
    "- there must be nested functions\n",
    "- the nested function must use the variables defined in the enclosing function\n",
    "- the enclosing function should return the nested function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 12, 13]\n",
      "[6, 11, 12, 13]\n"
     ]
    }
   ],
   "source": [
    "def thresholder(n=10):\n",
    "    def thresholding_function(lst):\n",
    "        return list(filter(lambda x: x > n, lst))\n",
    "    return thresholding_function\n",
    "\n",
    "x = [1, 2, 3, 4, 5, 6, 11, 12, 13]\n",
    "thresholder_10 = thresholder(10)\n",
    "print(thresholder_10(x))\n",
    "thresholder_5 = thresholder(5)\n",
    "print(thresholder_5(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Decorators**\n",
    "\n",
    "Decorators are a syntactic convenience that allow us to define what needs to be done to the output of a function before the function is called. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "Function 'add' took 0.0000 seconds.\n"
     ]
    }
   ],
   "source": [
    "# Example of an in-built decorator\n",
    "class Foo:\n",
    "    \n",
    "    @property # --> Foo.state is equivalent to property(state)\n",
    "    def state(self):\n",
    "        return True\n",
    "\n",
    "foo = Foo()\n",
    "print(foo.state)\n",
    "\n",
    "# Example of a custom decorator\n",
    "import time\n",
    "def timer(func):\n",
    "    def time_func(*args, **kwargs):\n",
    "        start_time = time.time()\n",
    "        func(*args, **kwargs)\n",
    "        print(\"Function '%s' took %3.4f seconds.\" %(func.__name__, time.time() - start_time))\n",
    "    return time_func\n",
    "\n",
    "@timer\n",
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "add(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Collections**\n",
    "\n",
    "Python offers an inbuilt library called collections that has several useful datastructures like: namedtuple, defaultDict, OrderedDict, deque, and Counter.\n",
    "A few basic examples are given below...\n",
    "\n",
    "Documentation https://docs.python.org/3/library/collections.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "defaultdict(<class 'int'>, {'test': 0, 'abc': 2})\n",
      "OrderedDict([('a', 1), ('b', 2)])\n",
      "Counter({'b': 20, 'a': 10})\n",
      "[('b', 20)]\n",
      "Counter()\n",
      "Counter({'b': 40, 'a': 20})\n"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "x = defaultdict(int) # an element that does not exist in the dictionary (hashmap) \n",
    "                     # will be assumed to be a 0 (Since int() returns 0)\n",
    "\n",
    "print(x['test'])\n",
    "x['abc'] = 2\n",
    "print(x)\n",
    "\n",
    "from collections import OrderedDict\n",
    "\n",
    "x = OrderedDict() # Stores items in the order of insertion\n",
    "x['a'] = 1\n",
    "x['b'] = 2\n",
    "\n",
    "print(x)\n",
    "\n",
    "from collections import Counter\n",
    "x = Counter() # A counter\n",
    "x['a'] = 10\n",
    "x['b'] = 20\n",
    "print(x)\n",
    "print(x.most_common(1))\n",
    "print(x - x)\n",
    "print(x + x)\n",
    "\n",
    "# Deque is left as an exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Packaged Utilities\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Itertools**\n",
    "\n",
    "Efficient set of functions for various constructs inspiried from other languages... \n",
    "\n",
    "Documentation: https://docs.python.org/3/library/itertools.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "Break\n",
      "Cycle\n",
      "A\n",
      "B\n",
      "C\n",
      "A\n",
      "B\n",
      "Break\n",
      "Repeat\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "Break\n",
      "Accumulate\n",
      "0\n",
      "1\n",
      "3\n",
      "6\n",
      "10\n",
      "15\n",
      "21\n",
      "28\n",
      "36\n",
      "45\n",
      "Groupby\n",
      "[[1, 7], [2, 3], [3, 6], [5, 9]]\n"
     ]
    }
   ],
   "source": [
    "from itertools import count, cycle, repeat, accumulate, groupby\n",
    "\n",
    "def exec_func(func, x=10):\n",
    "    c = 0\n",
    "    for ii in func(x):\n",
    "        print(ii)\n",
    "        c += 1\n",
    "        if c == 5:\n",
    "            print(\"Break\")\n",
    "            break\n",
    "\n",
    "# count\n",
    "print(\"Count\")\n",
    "exec_func(count, 10)\n",
    "\n",
    "#cycle\n",
    "print(\"Cycle\")\n",
    "exec_func(cycle, \"ABC\")\n",
    "\n",
    "#repeat\n",
    "print(\"Repeat\")\n",
    "exec_func(repeat, 10)\n",
    "\n",
    "# accumulate\n",
    "print(\"Accumulate\")\n",
    "for entry in accumulate(range(0,10)):\n",
    "    print(entry)\n",
    "\n",
    "# Groupby\n",
    "print(\"Groupby\")\n",
    "x = [1,1,2,2,3,3,3,3,5,5,5,5,5,5,1,1,1,3,5,1,1,3,5,5,2]\n",
    "fd = [[a, len(list(b))] for a, b in groupby(sorted(x))] # Computing the frequency distribution\n",
    "print(fd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "source": [
    "A bit of OOP\n",
    "--\n",
    "\n",
    "Python supports object-oriented programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Defining object oriented concepts**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "This is a static method\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "# defining a class\n",
    "\n",
    "class Foo:\n",
    "    \n",
    "    svar = 25 # static variable\n",
    "    \n",
    "    def __init__(self, x): # Constructor; self refers to the instance\n",
    "        self.x = x # object variable\n",
    "        self.__x = x # private variable\n",
    "    \n",
    "    @property\n",
    "    def state(self):\n",
    "        return self.x\n",
    "\n",
    "    def add(self, a, b): # method\n",
    "        return a + b\n",
    "    \n",
    "    def __private_method(self, a): # private method (mostly syntactic sugar)\n",
    "        print(a)\n",
    "    \n",
    "    @staticmethod\n",
    "    def t():\n",
    "        print(\"This is a static method\")\n",
    "\n",
    "foo = Foo(5) # instantiating a class\n",
    "print(foo.state)\n",
    "Foo.t() # calling a static method\n",
    "print(Foo.svar) # calling static variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Inheritence, polymorphism, encapsulation..**\n",
    "\n",
    "- General philosophy is that data is strictly not hidden, but there is a convention of using \"_\" or \"__\" to mark private variables.\n",
    "- Polymorphism is achieved through the ability to accept arbitrary (and keyword) arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "This is a Bar method\n",
      "This is a Foo method\n"
     ]
    }
   ],
   "source": [
    "# Example of inheritence\n",
    "\n",
    "class Foo:\n",
    "    def __init__(self, x):\n",
    "        self.x = x\n",
    "    \n",
    "    @property\n",
    "    def state(self):\n",
    "        return self.x\n",
    "\n",
    "    def method(self):\n",
    "        print(\"This is a Foo method\")\n",
    "    \n",
    "class Bar(Foo): # Bar inherits Foo\n",
    "    def __init__(self):\n",
    "        Foo.__init__(self, 10)\n",
    "\n",
    "    def method(self): # Overriding\n",
    "        print(\"This is a Bar method\")\n",
    "        super(Bar, self).method() # Calling method of super class\n",
    "        \n",
    "bar = Bar()\n",
    "print(bar.state)\n",
    "bar.method()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using external libraries\n",
    "---\n",
    "\n",
    "Python comes with a large set of community managed libraries.\n",
    "To use them, you can use one of the existing \"package managers\" like easy_install or pip (python-in-python).\n",
    "\n",
    "First, you have to install the package manager; in a debian-based system, it amounts to:\n",
    "\n",
    "`sudo apt-get install python3-pip`\n",
    "\n",
    "or \n",
    "\n",
    "`sudo apt-get install python-setuptools`\n",
    "\n",
    "After that, you can install a package of your choice using:\n",
    "\n",
    "`pip3 install <package_name>`\n",
    "\n",
    "example: `pip3 install web.py` to install web.py - which is a simple web server library for python\n",
    "\n",
    "or `easy_install <package_name>`\n",
    "\n",
    "Here are a few popular libraries:\n",
    "\n",
    "- Data Analysis: numpy, scipy, pandas, jupyter-notebook\n",
    "- Web Development: tornado, gunicorn, flask, web.py, web2py, django\n",
    "- Mobile Development: kivy\n",
    "- Desktop Application Development: pyqt, pygtk\n",
    "- Machine Learning: sklearn, sklearn-image\n",
    "- NLP: nltk, spacy\n",
    "- DevOps: fabric\n",
    "\n",
    "There are many, many more...!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Application Development Examples\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Web Service**\n",
    "\n",
    "An example is given below using bottle.py\n",
    "\n",
    "Documentation: http://bottlepy.org/docs/dev/index.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting bottle\n",
      "Installing collected packages: bottle\n",
      "Successfully installed bottle-0.12.13\n",
      "\u001b[33mYou are using pip version 8.1.1, however version 9.0.1 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Bottle v0.12.13 server starting up (using WSGIRefServer())...\n",
      "Listening on http://localhost:9000/\n",
      "Hit Ctrl-C to quit.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "! pip3 install -U bottle\n",
    "\n",
    "from bottle import route, run, template\n",
    "\n",
    "@route('/hello/<name>')\n",
    "def index(name):\n",
    "    return template('<b>Hello {{name}}</b>!', name=name)\n",
    "\n",
    "run(host='localhost', port=9000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Data crunching with numpy and pandas**\n",
    "\n",
    "numpy and pandas have to be separately installed using pip/easy_install\n",
    "\n",
    "Read numpy documentation at: http://www.numpy.org/\n",
    "Read pandas documentation at: http://pandas.pydata.org/\n",
    "\n",
    "The functionalities are too large to fall within the scope of the current discussion.\n",
    "\n",
    "For completeness and to give you a taste of how it is to use these libraries, a few (very basic) examples are given below..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "[38 26]\n",
      "[[ -7.50000000e-01  -1.26882631e-16   2.50000000e-01]\n",
      " [ -2.75000000e+00   1.00000000e+00   2.50000000e-01]\n",
      " [  2.41666667e+00  -6.66666667e-01  -2.50000000e-01]]\n",
      "   0  1  2\n",
      "0  1  2  3\n",
      "1  1  5  6\n",
      "2  7  6  9\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "1    5\n",
       "2    6\n",
       "Name: 1, dtype: int64"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Examples of numpy\n",
    "import numpy as np\n",
    "\n",
    "x = np.array([1, 2, 3]) # one of the basic data types in numpy as an np-array\n",
    "y = np.array([2, 3, 4])\n",
    "print(x.dot(y)) # dot product of two vectors\n",
    "y = np.array([[5, 6, 7], [3, 4, 5]])\n",
    "print(np.matmul(x, y.T)) # matrix multiplication\n",
    "z = np.array([[1, 2, 3], [1, 5, 6], [7, 6, 9]])\n",
    "print(np.linalg.inv(z)) # matrix inverse\n",
    "\n",
    "# Examples of pandas\n",
    "import pandas as pd\n",
    "x = pd.DataFrame(z) # one of the basic data types in pandas is a DataFrame\n",
    "print(x)\n",
    "x.iloc[1] # indexing 2nd row"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}