NOTES - Think Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 3 : division returns float number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.3333333333333335"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "type(True)\n",
    "type(False)\n",
    "print(\"hello world\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "blast\n"
     ]
    }
   ],
   "source": [
    "def countdown(n):\n",
    "    if n<=0:\n",
    "        print(\"blast\")\n",
    "    else:\n",
    "        print(n)\n",
    "        countdown(n-1)\n",
    "        \n",
    "countdown(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "each python file starts in the function __main__\n",
    "it is analogus to java main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ipython can't take input using the function input()\n",
    "How to take input in IPython ? Is if even possible ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-2-6aca60c860e0>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-2-6aca60c860e0>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    print name\u001b[0m\n\u001b[1;37m             ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "name = input('What is your name ?\\n')\n",
    "print name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "n = 10.\n",
    "print(isinstance(n, int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(None, str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anunaya"
     ]
    }
   ],
   "source": [
    "s = 'anunaya'\n",
    "type(s)\n",
    "for e in s:\n",
    "    print(e, end='')  #print in same line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 7"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Iterations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Collatz Conjecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Take any natural number n. If n is even, divide it by 2 to get n / 2. If n is odd, multiply it by 3 and add 1 to obtain 3n + 1. Repeat the process (which has been called \"Half Or Triple Plus One\", or HOTPO[6]) indefinitely. The conjecture is that no matter what number you start with, you will always eventually reach 1. The property has also been called oneness."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 50 25 76 38 19 58 29 88 44 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 "
     ]
    }
   ],
   "source": [
    "def sequence(n):\n",
    "    while n != 1:\n",
    "        print(int(n), end = ' ')\n",
    "        if n%2 == 0:\n",
    "            n = n/2\n",
    "        else:\n",
    "            n = n*3 + 1\n",
    "            \n",
    "sequence(100)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-1-fc06c469b362>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-1-fc06c469b362>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    print(1, end = '')\u001b[0m\n\u001b[1;37m                 ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "print(1, end = '')\n",
    "print(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Printing in Python 2 and Python 3**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n"
     ]
    }
   ],
   "source": [
    "#python 2\n",
    "print \"1\",\n",
    "print \"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nprint(\"1\", end=\" \")\\nprint(\"2\")\\n'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# python 3\n",
    "\"\"\"\n",
    "print(\"1\", end=\" \")\n",
    "print(\"2\")\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n"
     ]
    }
   ],
   "source": [
    "# To get print() function in python2\n",
    "from __future__ import print_function\n",
    "print(\"1\", end=\" \")\n",
    "print(\"2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taking input from user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-12-6739574c3665>, line 5)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-12-6739574c3665>\"\u001b[1;36m, line \u001b[1;32m5\u001b[0m\n\u001b[1;33m    print line\u001b[0m\n\u001b[1;37m             ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    line = raw_input('> ')\n",
    "    if line == 'done':\n",
    "        break\n",
    "    print line\n",
    "\n",
    "print 'Done !'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Newton Raphson's method for finding square root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.00000 2.16667 2.00641 2.00001 2.00000 "
     ]
    }
   ],
   "source": [
    "# x: approx sqr_root of n\n",
    "def sqr_root(n, x):\n",
    "    epsilon = 0.00001\n",
    "    while True:\n",
    "        print(\"%.5f\" % x, end = ' ')\n",
    "        y = (x + n/x)/2\n",
    "        if abs(y-x) < epsilon:\n",
    "            break\n",
    "        x = y\n",
    "\n",
    "sqr_root(4, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function eval in module builtins:\n",
      "\n",
      "eval(...)\n",
      "    eval(source[, globals[, locals]]) -> value\n",
      "    \n",
      "    Evaluate the source in the context of globals and locals.\n",
      "    The source may be a string representing a Python expression\n",
      "    or a code object as returned by compile().\n",
      "    The globals must be a dictionary and locals can be any mapping,\n",
      "    defaulting to the current globals and locals.\n",
      "    If only globals is given, locals defaults to it.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# eval() takes a string and evaluates its values usign the Python interpreter\n",
    "\n",
    "help(eval)\n",
    "eval('1+2*3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.9e-16\n"
     ]
    }
   ],
   "source": [
    "# representing numbers in exponential form\n",
    "print(2.99e-15 - 2e-15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 8: Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "18\n",
      "!\n",
      "p\n"
     ]
    }
   ],
   "source": [
    "# string is a sequence of characters\n",
    "str = 'python is awesome!'\n",
    "\n",
    "# access chars using indices\n",
    "print(str[0])\n",
    "\n",
    "# length of string\n",
    "l = len(str)\n",
    "print(l)\n",
    "\n",
    "# accessing char backwards\n",
    "print(str[-1])\n",
    "print(str[-l])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p y t h o n   i s   a w e s o m e ! "
     ]
    }
   ],
   "source": [
    "# using for loop\n",
    "for c in str:\n",
    "    print(c, end = ' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pyth\n",
      "python is awesome!\n",
      "pyth\n",
      "on is awesome!\n",
      "python is awesome!\n",
      "python is awesome!\n",
      "python is awesome!\n"
     ]
    }
   ],
   "source": [
    "# selecting a range in string\n",
    "print(str[0:4])\n",
    "print(str[0:len(str)])\n",
    "print(str[:4])\n",
    "print(str[4:])\n",
    "print(str[:])\n",
    "\n",
    "print(str[:4] + str[4:])\n",
    "print(str[:100] + str[100:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### using $\\LaTeX$ syntax in markdown cell\n",
    "\n",
    "$\\forall x \\in X, \\quad \\exists y \\leq \\epsilon$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are **immutable**.  \n",
    "It is tempting to use the \\[ \\] operator on the left side of an assignment, with the intention of\n",
    "changing a character in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python is awesome!\n",
      "p\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-27-0049c5354b7b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mstr\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'A'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "print(str)\n",
    "print(str[0])\n",
    "str[0] = 'A'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aython is awesome!\n"
     ]
    }
   ],
   "source": [
    "# correct way of doing it is\n",
    "# using string concatenation\n",
    "print('A' + str[1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###String Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PYTHON IS AWESOMELY AWESOME !\n",
      "python is awesomely awesome !\n",
      "*****\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "str = 'python is awesomely awesome !'\n",
    "print(str.upper())\n",
    "print(str.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = str.find('awesome')\n",
    "y = str.find('awesome', x+1, len(str))  # find(str_to_find, start, end)\n",
    "print(x, y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The _in_ operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The word _in_ is a boolean operator that takes two strings and returns _True_ if the first appears as a substring in the second."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ba' in 'banana'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "d\n",
      "f\n"
     ]
    }
   ],
   "source": [
    "def in_both(word1, word2):\n",
    "    for letter in word1:\n",
    "        if letter in word2:\n",
    "            print(letter)\n",
    "            \n",
    "in_both('asdf', 'aedtwf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print('a' < 'A')\n",
    "print('abcd' < 'abcde')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pto saeoe\n",
      "!emosewa si nohtyp\n"
     ]
    }
   ],
   "source": [
    "str = 'python is awesome!'\n",
    "print(str[::2]) # step size = 2\n",
    "print(str[::-1]) # count in reverse. step-size is given in negative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# code to check pallindrome\n",
    "s = 'abcba'\n",
    "if(s == s[::-1]): print(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Converting char to ascii**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "98\n",
      "b\n"
     ]
    }
   ],
   "source": [
    "print(ord('a')+1)\n",
    "print(chr(98))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Chapter 9: Case Study - Word Play"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C:\\\\Users\\\\LG\\\\Documents\\\\IPython Notebooks'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_io.TextIOWrapper name='temp/words.txt' mode='r' encoding='cp1252'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'aa\\n'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fin = open('temp/words.txt')\n",
    "print(fin) # mode 'r' is for reading ie default mode is reading\n",
    "fin.readline() # the output also contains the new line char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aahing\n",
      "  =>  7\n"
     ]
    }
   ],
   "source": [
    "line = fin.readline()  # readlines() will return a list of lines from the file\n",
    "                # readlines() is not advisable for large file\n",
    "print(line, ' => ' , len(line))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function strip:\n",
      "\n",
      "strip(...) method of builtins.str instance\n",
      "    S.strip([chars]) -> str\n",
      "    \n",
      "    Return a copy of the string S with leading and trailing\n",
      "    whitespace removed.\n",
      "    If chars is given and not None, remove characters in chars instead.\n",
      "\n",
      ">anunayaaay\n",
      ">\n",
      "anun\n"
     ]
    }
   ],
   "source": [
    "help(str.strip) # trim function\n",
    "\n",
    "s = '\\nanunayaaay'\n",
    "print('>' + s.strip()) # strips whilespace\n",
    "print('>' + s.strip('ya')) # strips all the characters from the begin or end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Chapter 10: Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has **hetrogeneous lists** ie. it can contain elements of multiple types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List are **mutable**.  \n",
    "In Python, all arguments are passed by-object.  \n",
    "We pass arguments by-reference using lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['anu', 'sri'] [1, 100]\n"
     ]
    }
   ],
   "source": [
    "list = ['anu', 'sri']\n",
    "num = [1, 100]\n",
    "print(list, num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['anu', 'sri', 1, 100]\n"
     ]
    }
   ],
   "source": [
    "print(list + num)  # + operator combines the two lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "['anu', 'sri', [1, 100]]\n"
     ]
    }
   ],
   "source": [
    "# list.append(e) appends the element e at the end of the list\n",
    "# e can be another list. It will then produce a nested list.\n",
    "print(list.append(num)) \n",
    "print(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "list[2] = 99\n",
    "print(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(list[-1]) # negative index also allowed\n",
    "print('anu' in list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anu sri 99 "
     ]
    }
   ],
   "source": [
    "for i in range(len(list)):\n",
    "    print(list[i], end = ' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Rather than being a function, _range_ is actually an immutable sequence type**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 10)\n",
      "range(0, 10)\n",
      "range(0, 10, 2)\n"
     ]
    }
   ],
   "source": [
    "print(range(10))\n",
    "print(range(0,10)) # prints 0-9\n",
    "print(range(0,10,2)) # increment by 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2 4 6 8 "
     ]
    }
   ],
   "source": [
    "for i in range(0,10,2):\n",
    "    print(i, end =' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 1]\n",
      "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n",
      "[1, 1, 1]\n",
      "[1, 1, 1]\n",
      "[1, 1, 1, 1, 1, 1, 1, 1, 1]\n",
      "[1, 1, 1, 1, 1, 1, 1, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "# * operator repeats the elements\n",
    "l = [1] * 3\n",
    "print(l)\n",
    "\n",
    "l = [1,2,3] * 3\n",
    "print(l)\n",
    "\n",
    "x = 1\n",
    "l = [x] *3\n",
    "print(l)\n",
    "x = 2\n",
    "print(l)\n",
    "\n",
    "l1 = l*3\n",
    "print(l1)\n",
    "l[0] = 4\n",
    "print(l1)\n",
    "\n",
    "# l1 = l * 3 only initializes the elements of list l1 and doesn't refer to elements of l\n",
    "# changing the elements of l doesn't change the elements of l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "l = [1,2,3]\n",
    "k = l  # k refers to list l\n",
    "l[0] = 5  # changing l changes k\n",
    "print(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "slice operator - list[a:b:c] also works in lists  \n",
    "A slice operator on the left side of an assignment can update multiple elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 10, 20, 30, 6]\n"
     ]
    }
   ],
   "source": [
    "l = [1,2,3,4,5,6]\n",
    "l[2:5] = [10, 20, 30]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###List Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['anu']\n",
      "['anu', 'x', 'y', 'c', 'd']\n",
      "['anu', 'c', 'd', 'x', 'y']\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "s = ['x','y','c','d']\n",
    "t = [1,2,3]\n",
    "r = []\n",
    "\n",
    "r.append('anu') # adds a new element\n",
    "print(r)\n",
    "\n",
    "r.extend(s)  # appends all elements to the list\n",
    "print(r) \n",
    "\n",
    "r.sort()  # sorts the elemnts in the list\n",
    "print(r)\n",
    "\n",
    "print(sum(t))  # sums all the elements in the list\n",
    "# print(sum(s))  # sum doesn't work for strings\n",
    "\n",
    "u = [1,2,[3,4]]\n",
    "# print(sum(u)) # sum doesn't work for nested lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "3 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<map at 0x5a33eb8>"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(type(l))\n",
    "print(max(t), min(t))\n",
    "map(print, t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The concept of map, filter and reduce\n",
    "Most common list operations can be expressed as a combination of map, filter and reduce.\n",
    "Because these operations are so common, Python provides language features to support\n",
    "them, including the built-in function **map** and an operator called a “**list comprehension**.”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A B C D \n",
      "['a', 'b', 'c']\n"
     ]
    }
   ],
   "source": [
    "# del list  # del operator is used to delete an object\n",
    "\n",
    "# using map() function to create an iterable\n",
    "# map(f, list) applies function f to each element in list \n",
    "\n",
    "for ch in map(chr,[65,66,67,68]):\n",
    "    print(ch, end = ' ')\n",
    "print()\n",
    "    \n",
    "l = list(map(chr, [97, 98, 99]))\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. The result will be a new list resulting from evaluating the expression in the context of the for and if clauses which follow it. For example, this listcomp combines the elements of two lists if they are not equal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]\n",
    "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "# List comprehension\n",
    "\n",
    "squares = [x**2 for x in range(10)]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Deleting an elemnt from the list**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['x', 'y', 'y', 'c', 'd', 'x']\n",
      "['x', 'y', 'c', 'd', 'x']\n",
      "['x', 'y', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "# s += s\n",
    "print(s)\n",
    "\n",
    "s.pop(2)  # pops element index 2\n",
    "print(s)\n",
    "\n",
    "s.pop()  # pops last element\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['x', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "del s[1]  # del doesn't return a value\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "list.remove(x): x not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-204-164a741c9527>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ms\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'd'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0ms\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'd'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: list.remove(x): x not in list"
     ]
    }
   ],
   "source": [
    "s.remove('d')\n",
    "print(s)\n",
    "#s.remove('d')  # error if 'd' is not in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['x', 'c', 'x', 'y', 'd']\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "remove() takes exactly one argument (2 given)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-208-de26b81248cb>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#s += ['d','x','y', 'd']\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0ms\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'x'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# removes the first occurance of 'd'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: remove() takes exactly one argument (2 given)"
     ]
    }
   ],
   "source": [
    "#s += ['d','x','y', 'd']\n",
    "print(s)\n",
    "s.remove('d')  # removes the first occurance of 'd'\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['x', 'c', 'x', 'y', 'd']\n",
      "['x', 'y', 'd']\n"
     ]
    }
   ],
   "source": [
    "print(s)\n",
    "del s[1:3]  # deletes s[1], s[2] and NOT s[3]\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'n', 'u', 'n', 'a', 'y', 'a']\n"
     ]
    }
   ],
   "source": [
    "# convert string to list of char\n",
    "s = 'anunaya'\n",
    "t = list(s)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hello,', 'this', 'an', 'is', 'anunaya', '!']\n",
      "['hello, this ', ' is ', 'unaya !']\n",
      "hello,-this-an-is-anunaya-!\n",
      "hello,thisanisanunaya!\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "sequence item 0: expected str instance, int found",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-218-6f1fb14525cc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[0ms\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'-'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: sequence item 0: expected str instance, int found"
     ]
    }
   ],
   "source": [
    "s = 'hello, this an is anunaya !'\n",
    "t = s.split()\n",
    "print(t)\n",
    "print(s.split('an'))\n",
    "\n",
    "# join is the reverse of split\n",
    "print('-'.join(t))\n",
    "print(''.join(t))  # concatenate the elements of a string\n",
    "\n",
    "s = [1, 2, 3]\n",
    "#print('-'.join(s))   # join works only for list of str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _is_ operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# to check whether 2 variables refer to the same object\n",
    "# 'is' compares object. '==' compares values\n",
    "\n",
    "a = 'banana'\n",
    "b = 'banana'\n",
    "print(a is b)\n",
    "print(a == b)\n",
    "\n",
    "a = [1]\n",
    "b = [1]\n",
    "print(a is b)  # False\n",
    "print(a == b)  # True\n",
    "\n",
    "a = 1\n",
    "b = 1\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 2]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2]\n",
    "b = a  # both a and b point to same object. changing b will change a\n",
    "b[0] = 100\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2] [100, 2]\n"
     ]
    }
   ],
   "source": [
    "# how to copy an object to another object\n",
    "a = [1,2]\n",
    "b = a.copy()  # or use: b = copy.copy(a)\n",
    "b[0] = 100\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "^ This is called **aliasing** or **referencing**. Avoid aliasing when working with **mutable** objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94730568\n",
      "94684040\n",
      "**********\n",
      "94684040\n",
      "94684040\n",
      "**********\n",
      "Inside func: [4]\n",
      "[3, 4]\n"
     ]
    }
   ],
   "source": [
    "# slicing creates a new object\n",
    "# del doesn't create a new object\n",
    "t = [1,2,3,4]\n",
    "print(id(t))\n",
    "t = t[1:]  # t is reassigned to a new address\n",
    "print(id(t))\n",
    "\n",
    "print('*'*10)\n",
    "print(id(t))\n",
    "del t[0]  # t points to the same object\n",
    "print(id(t))\n",
    "print('*'*10)\n",
    "\n",
    "def bad_delete_head(t):\n",
    "    t = t[1:]    # does not change the object passed to the function\n",
    "                 # reference to the object is passed. this reference can't be changed i.e. t can't be reassigned\n",
    "    print('Inside func:',t)\n",
    "    \n",
    "bad_delete_head(t)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> 100 1000\n",
      "0.4560260772705078\n"
     ]
    }
   ],
   "source": [
    "# determine the time a function takes to run\n",
    "\n",
    "import time\n",
    "def timing(f, args):\n",
    "    t1 = time.time()\n",
    "    f(args)\n",
    "    t2 = time.time()\n",
    "    return (t2-t1)\n",
    "\n",
    "def s(a, b):\n",
    "    print('>',a,b)\n",
    "    for i in range(1000000):\n",
    "        a = a + b\n",
    "\n",
    "print(timing(s, 100, 1000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_io.TextIOWrapper name='temp/words.txt' mode='r' encoding='cp1252'>\n",
      "aa\n",
      "\n"
     ]
    }
   ],
   "source": [
    "fin = open('temp/words.txt')\n",
    "print(fin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1) 0.11900591850280762\n",
      "2) 0.13500690460205078\n",
      "3) 0.26601600646972656\n",
      "4) 0.1800098419189453\n"
     ]
    }
   ],
   "source": [
    "def using_readlines(filename):\n",
    "    fin = open(filename)\n",
    "    words = fin.readlines()\n",
    "    #print(words)\n",
    "    fin.close()\n",
    "    \n",
    "def using_append(filename):\n",
    "    fin = open(filename)\n",
    "    words = []\n",
    "    for line in fin:\n",
    "        words.append(line)\n",
    "    #print(words)\n",
    "    fin.close()\n",
    "    \n",
    "def using_plus(filename):\n",
    "    fin = open(filename)\n",
    "    words = []\n",
    "    for line in fin:\n",
    "        words += [line]\n",
    "    fin.close()\n",
    " \n",
    "def using_with(filename):\n",
    "    words = []\n",
    "    with open(filename) as fp:\n",
    "        for line in fp:\n",
    "            words.append(line)\n",
    "\n",
    "filename = 'temp/words.txt'\n",
    "\n",
    "print('1)', timing(using_readlines, filename))\n",
    "print('2)', timing(using_append, filename))\n",
    "print('3)', timing(using_plus, filename))\n",
    "print('4)', timing(using_with, filename))\n",
    "\n",
    "########################\n",
    "# readlines() is the fastest\n",
    "# 'with' is  preferred as is implicitly closes the file and frees the garbage collector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\LG\\Documents\\IPython Notebooks\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "print(os.getcwd())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 11: Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python _Dictionaries_ = Java _HashMap_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n",
      "{3: 3, 'one': 'uno', 'two': 2}\n"
     ]
    }
   ],
   "source": [
    "eng2sp = dict()  # OR eng2sp = {}\n",
    "print(eng2sp)\n",
    "\n",
    "eng2sp['one'] = 'uno'\n",
    "eng2sp['two'] = 2\n",
    "eng2sp[3] = 3\n",
    "print(eng2sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The key-set and value-set is of heterogeneous type **unlike** in Java."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The order of items in the dictionay is unpredictable.  \n",
    "If the key is not present in the dict we get an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'three'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-267-04fcdf8870b4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0meng2sp\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'three'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'three'"
     ]
    }
   ],
   "source": [
    "print(eng2sp['three'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# 'in' operator searches in the keys of a dict\n",
    "\n",
    "print('one' in eng2sp)\n",
    "print('uno' in eng2sp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys([3, 'one', 'two'])\n",
      "dict_values([3, 'uno', 2])\n",
      "<class 'dict_keys'>\n",
      "<class 'dict_values'>\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "keys = eng2sp.keys()\n",
    "print(keys)\n",
    "\n",
    "values = eng2sp.values()\n",
    "print(values)\n",
    "\n",
    "print(type(keys))\n",
    "print(type(values))\n",
    "\n",
    "print('uno' in values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'one': 1, 'two': 2}\n"
     ]
    }
   ],
   "source": [
    "# initializing dict\n",
    "\n",
    "d = {'one':1, 'two':2}\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**in operator** using different algorithms for searching a _list_ and a _dictonary_.  \n",
    "For lists, it uses linear search.  \n",
    "For dict, is uses hashing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries have a method called **get** that takes a key and a default value. If the\n",
    "key appears in the dictionary, **get** returns the corresponding value; otherwise it returns the default\n",
    "value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'u': 1, 'y': 1, 'n': 2, ' ': 2, 'a': 3}\n"
     ]
    }
   ],
   "source": [
    "def histogram(text):\n",
    "    d = {}\n",
    "    for ch in text:\n",
    "        d[ch] = d.get(ch, 0) + 1\n",
    "    \n",
    "    return d\n",
    "\n",
    "print(histogram('anunaya  '))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v 2\n",
      "s 2\n",
      "n 2\n",
      "  1\n",
      "y 1\n",
      "a 6\n",
      "t 1\n",
      "u 1\n",
      "i 1\n",
      "r 1\n"
     ]
    }
   ],
   "source": [
    "# using 'for' loop in dict\n",
    "h = histogram('anunaya')\n",
    "\n",
    "for item in h:\n",
    "    print(item, h[item])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 3\n",
      "i 1\n",
      "n 2\n",
      "r 1\n",
      "s 1\n",
      "u 1\n",
      "y 1\n"
     ]
    }
   ],
   "source": [
    "def print_hist_inorder(h):\n",
    "    keys = list(h.keys())\n",
    "    keys.sort()\n",
    "    for key in keys:\n",
    "        print(key, h[key])\n",
    "        \n",
    "h = histogram('anunayasri')\n",
    "print_hist_inorder(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Raising an Exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Error Text !!",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-286-4821b6e4ecb9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Error Text !!'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: Error Text !!"
     ]
    }
   ],
   "source": [
    "raise ValueError('Error Text !!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can be values in a dictionary, as this example shows, but they cannot be keys.  \n",
    "The keys must be **hashable**.  \n",
    "The keys must be immutable. List are mutable, hence can't be used as keys.\n",
    "\n",
    "\\* Java: keys in HashMap can belong to any class. Even lists are allowed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-287-eae9e547115a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mt\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0md\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0md\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'oops'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "t = [1,2]\n",
    "d = {}\n",
    "d[t] = 'oops'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Global variables and function __main__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.global_func>"
      ]
     },
     "execution_count": 294,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "global_x = 100  # global_x belongs to __main__\n",
    "                # can be accessed from any function within __main__\n",
    "\n",
    "def global_func():\n",
    "    print(global_x)\n",
    "\n",
    "global_func"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<function __main__.global_func> : global_func is a part of __main__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function global_func at 0x0000000005A7BBF8>\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "print(global_func)\n",
    "global_func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x= 9 y= 100\n"
     ]
    }
   ],
   "source": [
    "# visibility of global variables and lobal variables with same name\n",
    "\n",
    "x = 1\n",
    "y = 10\n",
    "def global_func1(x):\n",
    "    y = 100\n",
    "    print('x=',x,'y=',y)\n",
    "    \n",
    "global_func1(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To **reassign a global variable inside a function** you have to declare the global variable before you use it:  \n",
    "  \n",
    "Global variables can be declared inside a function as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "101 global\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "\n",
    "def global_func2():\n",
    "    global x, y  # declaring a global variable\n",
    "    x += 100\n",
    "    y = 'global'\n",
    "    \n",
    "global_func2()\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the global value is mutable, you can modify it without declaring it.  \n",
    "So you can add, remove and replace elements of a global list or dictionary, but if you want\n",
    "to reassign the variable, you have to declare it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python 3, data type **_long_** is gone; all integers, even really big ones, are type **_int_**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 12: Tuples\n",
    "\n",
    "**Tuples are immutable.**  \n",
    "A tuple is a sequence of values. The values can be any type, and they are indexed by\n",
    "integers, so in that respect tuples are a lot like lists. The important difference is that tuples\n",
    "are immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 's', 'd', 'f', 'g')\n",
      "(1, 2, 3)\n",
      "t1: <class 'tuple'>\n",
      "t3: <class 'str'>\n",
      "t4: <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "# tuples are comma-separated list of values\n",
    "\n",
    "t1 = 'a', 's', 'd', 'f', 'g'\n",
    "print(t1)\n",
    "\n",
    "t2 = (1,2,3)\n",
    "print(t2)\n",
    "\n",
    "print('t1:', type(t1))\n",
    "\n",
    "t3 = ('a')  # this is a str\n",
    "print('t3:', type(t3))\n",
    "\n",
    "t4 = ('a',)  # this is a tuple\n",
    "print('t4:', type(t4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t = ()   # empty tuple OR t = tuple()\n",
    "print(type(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'n', 'u', 'n', 'a', 'y', 'a')\n"
     ]
    }
   ],
   "source": [
    "t = tuple('anunaya')  # seq of char in str is converted to tuple\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "('a', 'n', 'u')\n",
      "('A', 'n', 'u', 'n', 'a', 'y', 'a')\n"
     ]
    }
   ],
   "source": [
    "# [] for indexing\n",
    "print(t[0])\n",
    "\n",
    "# slice\n",
    "print(t[:3])\n",
    "\n",
    "# + operator\n",
    "t0 = ('A',) + t[1:]\n",
    "print(t0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple assignment*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 10\n",
      "11 100\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 100\n",
    "\n",
    "# The left side is a tuple of variables; the right side is a seq(string, list or tuple) of expressions\n",
    "\n",
    "a, b = b, a  # tuple assignment\n",
    "print(a,b)\n",
    "\n",
    "a, b = b+1, a   # right-hand side exp are calculated first\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'> <class 'str'>\n",
      "<class 'list'> <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "addr = 'monty@python.org'\n",
    "l = addr.split('@')\n",
    "(uname, domain) = l\n",
    "uname1, domain1 = l\n",
    "\n",
    "print(type(l), type(uname))\n",
    "print(type(l), type(uname1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1|2\n"
     ]
    }
   ],
   "source": [
    "a, b = '12'  # right side can be a seq of char also\n",
    "print(a,b,sep='|')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples as resturn values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 1) <class 'tuple'>\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-330-f6c7b973b6d6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mt\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdivmod\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m7\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# return a tuple: x/y, x%y\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t = divmod(7,3)  # return a tuple: x/y, x%y\n",
    "print(t, type(t))\n",
    "t[0] = 1  # can't reassign"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 's') <class 'tuple'>\n",
      "('a', 's') <class 'tuple'>\n",
      "('a', 's') <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "# return statement with more than one arguments returns a tuple\n",
    "\n",
    "def min_max(t):\n",
    "    return min(t), max(t)\n",
    "\n",
    "t = tuple('asdfghj')\n",
    "r = min_max(t)\n",
    "print(r, type(r))\n",
    "\n",
    "l = list('asdfghj')\n",
    "r = min_max(l)\n",
    "print(r, type(r))\n",
    "\n",
    "s = 'asdfghj'\n",
    "r = min_max(s)\n",
    "print(r, type(r))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can take a variable number of arguments. A parameter name that begins with **\\*** _gathers_ **arguments into a tuple**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "txt: anunaya\n",
      "(1, 2.0, '3')\n"
     ]
    }
   ],
   "source": [
    "def print_all(txt, *args):\n",
    "    print('txt:', txt)\n",
    "    print(args)\n",
    "    \n",
    "print_all('anunaya', 1, 2., '3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scatter the elements of tuple using - \\*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "divmod expected 2 arguments, got 1",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-337-eb90f174114e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mt\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m7\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdivmod\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# gives error\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: divmod expected 2 arguments, got 1"
     ]
    }
   ],
   "source": [
    "t = (7,3)\n",
    "print(divmod(t))  # gives error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 1)\n"
     ]
    }
   ],
   "source": [
    "print(divmod(*t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "**********\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "sum expected at most 2 arguments, got 4",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-340-a31f0b40892b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'*'\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: sum expected at most 2 arguments, got 4"
     ]
    }
   ],
   "source": [
    "l = [1,2,3,4]\n",
    "print(sum(l))\n",
    "print('*'*10)\n",
    "print(sum(1,2,3,4))  # doesn't work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "def sum_all(*args):\n",
    "    s = 0\n",
    "    for arg in args:\n",
    "        s += int(arg)\n",
    "    return s\n",
    "\n",
    "print(sum_all(1,2,3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<zip object at 0x00000000048D3BC8>\n",
      "('a', 0)\n",
      "('b', 1)\n",
      "('c', ['a', 'b'])\n"
     ]
    }
   ],
   "source": [
    "# zip function\n",
    "# takes 2 inputs, zips them into a list of tuples and return the iterator\n",
    "# inputs can be seq of diff length. min length is taken\n",
    "\n",
    "s = 'abcd'\n",
    "t = [0,1,['a','b']]\n",
    "it = zip(s,t)\n",
    "print(it)\n",
    "for i in it:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a|1\n",
      "b|2\n",
      "c|3\n"
     ]
    }
   ],
   "source": [
    "# tuple assignment can also be used as\n",
    "\n",
    "t = tuple(zip('abc', '123'))\n",
    "for first, second in t:\n",
    "    print(first, second, sep='|')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a\n",
      "1 b\n",
      "2 c\n"
     ]
    }
   ],
   "source": [
    "# enumerate function\n",
    "\n",
    "for index, element in enumerate('abc'):\n",
    "    print(index, element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries have a method called _items_ that returns a list of tuples, where each tuple is a key-value pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict_items'> dict_items([('b', 2), ('a', 1), ('c', 3)])\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'dict_items' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-155-c95fc7110f3a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mt\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m '''\n",
      "\u001b[1;31mTypeError\u001b[0m: 'dict_items' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "d = {'a':1, 'b':2, 'c':3}\n",
    "t = d.items()\n",
    "print(type(t), t)\n",
    "n = 1\n",
    "del t[0]\n",
    "'''\n",
    "for e in t:\n",
    "    print \n",
    "    if n==1 :\n",
    "        print('deleting e')\n",
    "        del e\n",
    "    n += 1\n",
    "'''\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# We can use a list of tuples to initialize a new dictionary.\n",
    "t = [('a', 1), ('b',2)]\n",
    "d = dict(t)\n",
    "print(type(d), d)\n",
    "\n",
    "d = dict(zip('abc', range(1,4)))\n",
    "for key, val in d.items():\n",
    "    print(key, val)\n",
    "\n",
    "# In python3, range() returns an iterator. It can be converted to a list.\n",
    "print(list(range(10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is common to use **tuples as keys in dictionaries** (primarily because you can’t use lists). For\n",
    "example, a telephone directory might map from last-name, first-name pairs to telephone\n",
    "numbers. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing tuples  \n",
    "The relational operators work with tuples and other sequences; Python starts by comparing\n",
    "the first element from each sequence. If they are equal, it goes on to the next elements, and\n",
    "so on, until it finds elements that differ. Subsequent elements are not considered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(0,1,1000) < (0,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The _sort_ function works the same way. It sorts primarily by first element, but in the case\n",
    "of a tie, it sorts by second element, and so on.  \n",
    "It follows the principle of **Decorate, Search and Undecorate**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['dafdsf', 'abd', 'abc']\n"
     ]
    }
   ],
   "source": [
    "# to sort a list in reverse order of their length\n",
    "\n",
    "def sort_by_length(words):\n",
    "    t = []\n",
    "    for word in words:\n",
    "        t.append((len(word), word))\n",
    "        \n",
    "    t.sort(reverse = True)\n",
    "    res = []\n",
    "    for length, word in t:\n",
    "        res.append(word)\n",
    "    return res\n",
    "\n",
    "res = sort_by_length(['abc', 'dafdsf', 'abd'])\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([100, 2], [3, 4])\n"
     ]
    }
   ],
   "source": [
    "# list of tuples\n",
    "# can modify the elements of the list\n",
    "\n",
    "t = ([1,2], [3,4])\n",
    "t[0][0] = 100\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 32, 98] [4, 32, 98, 3]\n"
     ]
    }
   ],
   "source": [
    "# built-in functions: sorted and reversed\n",
    "\n",
    "t = [1,23, -1, 11, 3]\n",
    "t = (3,98, 32,4)\n",
    "print(sorted(t), list(reversed(t)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In many contexts, the different kinds of sequences (strings, lists and tuples) can be used\n",
    "interchangeably. So how and why do you choose one over the others?  \n",
    "To start with the obvious, strings are more limited than other sequences because the elements have to be characters. They are also immutable. If you need the ability to change the\n",
    "characters in a string (as opposed to creating a new string), you might want to use a list of\n",
    "characters instead.  \n",
    "Lists are more common than tuples, mostly because they are mutable. But there are a few\n",
    "cases where you might prefer tuples:  \n",
    "1. In some contexts, like a _return_ statement, it is syntactically simpler to create a tuple\n",
    "than a list. In other contexts, you might prefer a list.  \n",
    "2. If you want to use a sequence as a dictionary key, you have to use an immutable type\n",
    "like a tuple or string.\n",
    "3. If you are passing a sequence as an argument to a function, using tuples reduces the\n",
    "potential for unexpected behavior due to aliasing.  \n",
    "Because tuples are immutable, they don’t provide methods like _sort_ and _reverse_, which\n",
    "modify existing lists. But Python provides the built-in functions _sorted_ and _reversed_,\n",
    "which take any sequence as a parameter and return a new list with the same elements in a\n",
    "different order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Exercise 13.1. Write a program that reads a file, breaks each line into words, strips whitespace and\n",
    "punctuation from the words, and converts them to lowercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "print(string.punctuation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python is a widely used generalpurpose highlevel programming language171819 its design philosophy emphasizes code readability and its syntax allows programmers to express concepts in fewer lines of code than would be possible in languages such as c or java2021 the language provides constructs intended to enable clear programs on both a small and large scale22 \n",
      "\n",
      "python supports multiple programming paradigms including objectoriented imperative and functional programming or procedural styles it features a dynamic type system and automatic memory management and has a large and comprehensive standard library23 \n",
      "\n",
      "python interpreters are available for installation on many operating systems allowing python code execution on a wide variety of systems using thirdparty tools such as py2exe or pyinstaller24 python code can be packaged into standalone executable programs for some of the most popular operating systems allowing for the distribution of pythonbased software for use on those environments without requiring the installation of a python interpreter \n",
      "\n",
      "cpython the reference implementation of python is free and opensource software and has a communitybased development model as do nearly all of its alternative implementations cpython is managed by the nonprofit python software foundation \n",
      "\n",
      " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
      "[(8, 'python'), (8, 'and'), (7, 'of'), (7, 'a'), (6, 'the'), (4, 'on'), (4, 'for'), (4, 'code'), (3, 'systems'), (3, 'software')]\n",
      "Total number of words: 186\n",
      "Number of unique words: 121\n",
      "objectoriented implementation the enable of distribution environments of of can "
     ]
    }
   ],
   "source": [
    "# using maketans, translate\n",
    "\n",
    "import string\n",
    "import random\n",
    "\n",
    "def process(line):\n",
    "    punc = string.punctuation\n",
    "    d = dict()\n",
    "    for ch in punc:\n",
    "        d[ch] = ''\n",
    "    transtab = str.maketrans(d)\n",
    "    words = line.split()\n",
    "    out = ''\n",
    "    for word in words:\n",
    "        word = word.strip()  # strip whitespace\n",
    "        word = word.translate(transtab)\n",
    "        word = word.lower()\n",
    "        out += word + ' '\n",
    "        \n",
    "    return out\n",
    "\n",
    "def process_file(filename):\n",
    "    freq_map = dict()\n",
    "    with open(filename) as fin:\n",
    "        for line in fin:\n",
    "            var = process(line)\n",
    "            print(var)\n",
    "            words = var.split()\n",
    "\n",
    "            for word in words:\n",
    "                freq_map[word] = freq_map.get(word, 0) + 1\n",
    "\n",
    "    print('\\n','%'*50)\n",
    "    freq_list = list()\n",
    "    for key in freq_map:\n",
    "        freq_list.append((freq_map[key], key))\n",
    "    # print(freq_list)\n",
    "\n",
    "    freq_list.sort(reverse=True)\n",
    "    print(freq_list[:10])\n",
    "    \n",
    "    print('Total number of words:', sum(freq_map.values()))\n",
    "    print('Number of unique words:', len(freq_map))\n",
    "    \n",
    "    # selecting random words\n",
    "    # selecting random words in proportion of their distribution\n",
    "    t = []\n",
    "    for word, freq in freq_map.items():\n",
    "        t.extend([word]*freq)\n",
    "    \n",
    "    for i in range(10):\n",
    "        print(random.choice(t), end = ' ')\n",
    "\n",
    "process_file('temp/temp.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{97: 49, 111: 52, 117: 53, 101: 50, 105: 51}\n"
     ]
    }
   ],
   "source": [
    "m = str.maketrans('aeiou', '12345')\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Random Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7639399510965551 0.6872707959326897 0.8922426310334651 0.08184739351116155 0.8344207918357434 0.41535422686754153 0.2552585481905645 0.6339983863851049 0.7092734291916271 0.8841899642432356 \n"
     ]
    }
   ],
   "source": [
    "# random numbers in the range [0,1)\n",
    "# generate random numbers with 16-digit precision\n",
    "\n",
    "import random\n",
    "\n",
    "for i in range(0,10):\n",
    "    x = random.random()\n",
    "    print(x, end = ' ')\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "87 24 25 24 4 72 17 37 69 16 \n"
     ]
    }
   ],
   "source": [
    "# random intergers in a range\n",
    "\n",
    "for i in range(0,10):\n",
    "    x = random.randint(1,100)\n",
    "    print(x, end = ' ')\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66 20 58 77 5 23 8 23 15 84 \n",
      "s n d s s f n n n a \n"
     ]
    }
   ],
   "source": [
    "# for choosing a random number \n",
    "\n",
    "t = list(range(100))\n",
    "for i in range(10):\n",
    "    print(random.choice(t), end=' ')\n",
    "print()\n",
    "\n",
    "\n",
    "s = 'anunasdf'\n",
    "for i in range(10):\n",
    "    print(random.choice(s), end=' ')\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "asdf asdf\n"
     ]
    }
   ],
   "source": [
    "# replace function\n",
    "line = 'asdf-asdf'\n",
    "print(line.replace('-', ' '))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \t\n",
      "\r",
      "\u000b",
      "\f",
      "\n",
      "<class 'str'>\n",
      "6\n",
      "32 9 10 13 11 12 "
     ]
    }
   ],
   "source": [
    "import string\n",
    "print(string.whitespace, sep='|')\n",
    "print(type(string.whitespace))\n",
    "print(len(string.whitespace))\n",
    "\n",
    "wl = list(string.whitespace)\n",
    "for i in wl:\n",
    "    print(ord(i), end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Sets\n",
    "\n",
    "Python also includes a data type for sets. A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries. Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.\n",
    "\n",
    "Curly braces or the set() function can be used to create sets. Note: to create an empty set you have to use set(), not {}; the latter creates an empty dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'> {'orange', 'apple', 'pear', 'banana'}\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}   # OR basket = set()\n",
    "print(type(basket), basket)  # duplicates are removed\n",
    "print('orange' in basket)\n",
    "\n",
    "# set object does not support indexing\n",
    "# print(basket[0]) gives error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'b', 's', 'f', 'a', 'c', 'd'} {'s', 'f', 'a', 'c', 'e', 'w'}\n",
      "{'b', 'd'}\n",
      "{'b', 's', 'f', 'a', 'c', 'e', 'w', 'd'}\n",
      "{'f', 'a', 'c', 's'}\n",
      "{'b', 'e', 'w', 'd'}\n"
     ]
    }
   ],
   "source": [
    "a = set('abcdfasdf')\n",
    "b = set('awecfswe')\n",
    "print(a, b)\n",
    "\n",
    "# difference of sets\n",
    "print(a - b)\n",
    "\n",
    "# union of sets : OR of sets\n",
    "print(a | b)\n",
    "\n",
    "# intersection : AND of sets\n",
    "print(a & b)\n",
    "\n",
    "# Exclusive OR : XOR of sets\n",
    "print(a ^ b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 14: Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_write_ function  \n",
    "\n",
    "The argument of write() has to a string.  \n",
    "To convert to a string use **str()** or use **format operator, %**. The first operand is the format string, which contains one or more format sequences, which specify how the second operand is formatted. The result is a string.  \n",
    "If there is more than one format sequence in the string, the second argument has to be a\n",
    "tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23 anunaya\n"
     ]
    }
   ],
   "source": [
    "x = 23\n",
    "s = 'anunaya'\n",
    "print('%d %s' % (x, s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filenames and paths\n",
    "\n",
    "Path related functions are in the module **os.path**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\anunaya\\Google Drive\\workspace_python\\IPython Notebooks\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "cwd = os.getcwd()  #get current working directory\n",
    "print(cwd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\anunaya\\Google Drive\\workspace_python\\IPython Notebooks\\temp\\temp.txt\n"
     ]
    }
   ],
   "source": [
    "print(os.path.abspath('temp/temp.txt'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '_io.TextIOWrapper'>\n",
      "exists: True\n",
      "isdir: False\n",
      "isfile: True\n"
     ]
    }
   ],
   "source": [
    "f = open('temp/temp.txt')\n",
    "print(type(f))\n",
    "\n",
    "f.close()\n",
    "\n",
    "filename = 'temp/temp.txt'\n",
    "print('exists:', os.path.exists(filename))\n",
    "print('isdir:', os.path.isdir(filename))\n",
    "print('isfile:', os.path.isfile(filename))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['dir1', 'temp.txt', 'words.txt']\n",
      "C:\\Users\\anunaya\\Google Drive\\workspace_python\\IPython Notebooks/temp\\dir1\\file1.txt\n",
      "C:\\Users\\anunaya\\Google Drive\\workspace_python\\IPython Notebooks/temp\\temp.txt\n",
      "C:\\Users\\anunaya\\Google Drive\\workspace_python\\IPython Notebooks/temp\\words.txt\n"
     ]
    }
   ],
   "source": [
    "# list files in a dir\n",
    "# non-recursive in nature\n",
    "\n",
    "dirlist = os.listdir(os.getcwd()+'/temp')\n",
    "print(dirlist)\n",
    "\n",
    "# make a recursive function\n",
    "def dirwalk(dirname):\n",
    "    for name in os.listdir(dirname):\n",
    "        path = os.path.join(dirname, name)  \n",
    "        # os.path.jo in takes a directory and a file name and joins them into a complete path.\n",
    "        if os.path.isfile(path):\n",
    "            print(path)\n",
    "        else:\n",
    "            dirwalk(path)\n",
    "            \n",
    "dirwalk(os.getcwd()+'/temp')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Databases\n",
    "\n",
    "A database is a file that is organized for storing data. Most databases are organized like a\n",
    "dictionary in the sense that they map from keys to values. The biggest difference is that the\n",
    "database is on disk (or other permanent storage), so it persists after the program ends."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The module _**anydbm**_(in Python 2) or _**dbm**_(in Python 3) provides an interface for creating and updating database files. As an\n",
    "example, I’ll create a database that contains captions for image files.\n",
    "Opening a database is similar to opening other files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dbm.dumb._Database"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import dbm\n",
    "db = dbm.open('temp/captions.db', 'c')  # mode 'c' is to create a new db\n",
    "type(db)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'Photo of Anunaya'\n"
     ]
    }
   ],
   "source": [
    "db['anunaya.png'] = 'Photo of Anunaya'\n",
    "print(db['anunaya.png'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many dictionary methods, like keys and items, also work with database objects. So does iteration with a for statement.  \n",
    "Close the database after you are done working with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'Photo of Anunaya'\n"
     ]
    }
   ],
   "source": [
    "for key in db:\n",
    "    print(db[key])\n",
    "\n",
    "# close the db file    \n",
    "db.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pickling\n",
    "\n",
    "A limitation of anydbm is that the keys and values have to be strings. If you try to use any\n",
    "other type, you get an error.  \n",
    "\n",
    "The **pickle** module can help. It translates almost any type of object into a string suitable\n",
    "for storage in a database, and then translates strings back into objects.  \n",
    "\n",
    "**pickle.dumps** takes an object as a parameter and returns a string representation (dumps is\n",
    "short for “dump string”).  \n",
    "\n",
    "**pickle.loads(“load string”)** loads an object back to python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'\\x80\\x03]q\\x00(K\\x01K\\x02K\\x03e.'\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "t = [1,2,3]\n",
    "pic_dump = pickle.dumps(t)\n",
    "print(pic_dump)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'> [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "pic_load = pickle.loads(pic_dump)\n",
    "print(type(pic_load), pic_load)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pickling and then unpickling has the same effect as copying the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "t1 = [1,2,3]\n",
    "s = pickle.dumps(t1)\n",
    "t2 = pickle.loads(s)\n",
    "\n",
    "print(t1 == t2)  # each value of list is same\n",
    "print(t1 is t2)  # both the objects are different"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pipes\n",
    "\n",
    "Any program that you can launch from the shell can also be launched from Python using\n",
    "a pipe. A pipe is an object that represents a running program.  \n",
    "\n",
    "The argument is a string that contains a shell command. The return value is an object that\n",
    "behaves just like an open file. You can read the output from the ls process one line at a\n",
    "time with readline or get the whole thing at once with read."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Volume in drive C has no label.\n",
      "\n",
      " Volume Serial Number is 10E5-D8F9\n",
      "\n",
      "\n",
      "\n",
      " Directory of C:\\Users\\anunaya\\Google Drive\\workspace_python\\IPython Notebooks\n",
      "\n",
      "\n",
      "\n",
      "09-04-2015  18:22    <DIR>          .\n",
      "\n",
      "09-04-2015  18:22    <DIR>          ..\n",
      "\n",
      "08-04-2015  11:26    <DIR>          .ipynb_checkpoints\n",
      "\n",
      "09-04-2015  18:22            95,907 NOTES - Think Python.ipynb\n",
      "\n",
      "09-04-2015  18:04    <DIR>          temp\n",
      "\n",
      "               1 File(s)         95,907 bytes\n",
      "\n",
      "               4 Dir(s)  374,050,639,872 bytes free\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "cmd = 'dir /a'\n",
    "fp = os.popen(cmd)\n",
    "\n",
    "for line in fp:\n",
    "    print(line)\n",
    "    \n",
    "stat = fp.close()\n",
    "print(stat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The return value is the final status of the process run using _popen()_; None means that it ended normally\n",
    "(with no errors)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing modules\n",
    "\n",
    "Any file that contains Python code can be imported as a module. \n",
    "\n",
    "The only problem with this example is that when you import the module it executes the\n",
    "test code at the bottom. Normally when you import a module, it defines new functions but\n",
    "it doesn’t execute them.\n",
    "\n",
    "Programs that will be imported as modules often use the following idiom:  \n",
    "    if \\_\\_name\\_\\_ == '\\_\\_main\\_\\_':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inside main\n"
     ]
    }
   ],
   "source": [
    "def test_name():\n",
    "    if __name__ == '__main__':\n",
    "        print('inside main')\n",
    "    else:\n",
    "        print('inside', __name__)\n",
    "        \n",
    "test_name()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\_\\_name\\_\\_ is a built-in variable that is set when the program starts. If the program is running as a script, __name__ has the value __main__; in that case, the test code is executed.\n",
    "Otherwise, if the module is being imported, the test code is skipped.\n",
    "\n",
    "Warning: If you import a module that has already been imported, Python does nothing. It does not\n",
    "re-read the file, even if it has changed.\n",
    "If you want to reload a module, you can use the built-in function reload, but it can be tricky, so\n",
    "the safest thing to do is restart the interpreter and then import the module again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Debugging**  \n",
    "When you are reading and writing files, you might run into problems with whitespace.\n",
    "These errors can be hard to debug because spaces, tabs and newlines are normally invisible.  \n",
    "\n",
    "The built-in function repr can help. It takes any object as an argument and returns a string\n",
    "representation of the object. For strings, it represents whitespace characters with backslash\n",
    "sequences. This can be helpful for debugging."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 3 \n",
      "4 \t5\n"
     ]
    }
   ],
   "source": [
    "s = '12 3 \\n4 \\t5'\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'12 3 \\n4 \\t5'\n"
     ]
    }
   ],
   "source": [
    "print(repr(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, '1234\\t34']\n",
      "[1, 2, '1234\\t34']\n"
     ]
    }
   ],
   "source": [
    "l = [1,2, '1234\\t34']\n",
    "print(l)\n",
    "print(repr(l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One other problem you might run into is that different systems use different characters to\n",
    "indicate the end of a line. Some systems use a newline, represented \\\\n. Others use a return\n",
    "character, represented \\\\r. Some use both. If you move files between different systems,\n",
    "these inconsistencies might cause problems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 15: Classes and Objects\n",
    "\n",
    "Compared with other programming languages, Python’s class mechanism adds classes with a minimum of new syntax and semantics. It is a mixture of the class mechanisms found in C++ and Modula-3. Python classes provide all the standard features of Object Oriented Programming: the class inheritance built-in types can be used as base classes for extension by the user. Also, like in C++, most built-in operators with special syntax (arithmetic operators, subscripting etc.) can be redefined for class instances. allows multiple base classes, a derived class can override any methods of its base class or classes, and a method can call the method of a base class with the same name. Objects can contain arbitrary amounts and kinds of data. As is true for modules, classes partake of the dynamic nature of Python: they are created at runtime, and can be modified further after creation.  \n",
    "\n",
    "Built-in types can be used as base classes for extension by the user. Also, like in C++, most built-in operators with special syntax (arithmetic operators, subscripting etc.) can be redefined for class instances(**Operator Overloading if allowed.**)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Point'>\n",
      "Point type\n"
     ]
    }
   ],
   "source": [
    "class Point(object):\n",
    "    \"\"\" Represents point in 2-D space. \"\"\"\n",
    "    #attributes: x, y\n",
    "    \n",
    "    kind = 'Point type'  # shared by all instances of Point class(static in Java)\n",
    "    \n",
    "    def __init__(self, x = None, y = None):\n",
    "        self.x = x  # unique to each instance of Point\n",
    "        self.y = y\n",
    "        \n",
    "print(Point)\n",
    "print(Point.kind)  # kind is a static variable\n",
    "# print(Point.x)  # generates an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Point'>\n"
     ]
    }
   ],
   "source": [
    "class Point(object):\n",
    "    \"\"\" Another with same name. \"\"\"\n",
    "    attributes: x_tmp, y_tmp\n",
    "print(Point)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python **doesn't do function overloading**. This is a consequence of it being a loosely-typed language. Instead you can specify an unknown number of arguments and deal with their interpretation in the function logic. There are a couple ways you can do this:  \n",
    "\n",
    "1. You can specify specific optional arguments.(as shown in the constructor of example below)\n",
    "2. Or you can specify an unknown number of unnamed arguments.(as shown below)  \n",
    "\n",
    "```python\n",
    "def func2(arg1, *args):  \n",
    "    if args:  \n",
    "        for item in args:  \n",
    "            print item  \n",
    "    else:  \n",
    "        print arg1  \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w: 100 h: 50 corner: (0,0)\n",
      "w: 99 h: 98 corner: (5,8)\n",
      "w: 99 h: 98 corner: (50,8)\n",
      "p= 5.0 8.0\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "class Rectangle(object):\n",
    "    kind = 'Rectangle'\n",
    "    def __init__(self, w = None, h = None, corner = None):\n",
    "        self.width = w\n",
    "        self.height = h\n",
    "        self.corner = copy.copy(corner)\n",
    "    \n",
    "def print_rectangle(rect):\n",
    "    print('w: %d h: %d corner: (%d,%d)' % (rect.width, rect.height, rect.corner.x, rect.corner.y))\n",
    "    \n",
    "box = Rectangle()\n",
    "box.width = 100.0\n",
    "box.height = 50.0\n",
    "box.corner = Point()\n",
    "\n",
    "box.corner.x = 0.0\n",
    "box.corner.y = 0.0\n",
    "\n",
    "print_rectangle(box)\n",
    "p = Point()\n",
    "p.x = 5.\n",
    "p.y = 8.\n",
    "\n",
    "box2 = Rectangle(99.0, 98.0, p)\n",
    "print_rectangle(box2)\n",
    "box2.corner.x = 50.0    # changring corner in box2 doesn't change instance p\n",
    "                        # because copy.copy() to make a copy of Point object passed in the constructor\n",
    "print_rectangle(box2)\n",
    "print('p=',p.x, p.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "p1 = Point(4,5)\n",
    "p2 = copy.copy(p1)\n",
    "\n",
    "# is operator and == operator both behave in same manner\n",
    "# == checks object identity, not object equivalence\n",
    "print(p1 is p2)\n",
    "print(p1 == p2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "box1 = Rectangle(3,4, Point(33,44))\n",
    "box2 = copy.copy(box1)  # shallow copy\n",
    "\n",
    "print(box1 is box2)\n",
    "print(box1.corner is box2.corner)  # shallow copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is **shallow copy** because it copies the object and any references it contains, but not the embedded\n",
    "objects. For most applications, this is not what we want.  \n",
    "\n",
    "**Deep copy** the copy module contains a method named deepcopy that copies not only the\n",
    "object but also the objects it refers to, and the objects they refer to, and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "box1 = Rectangle(5,6, Point(33,44))\n",
    "box2 = copy.deepcopy(box1)\n",
    "\n",
    "print(box1 is box2)\n",
    "print(box1.corner is box2.corner)  # deep copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# If you are not sure whether an object has a particular attribute, you can use the built-in\n",
    "# function hasattr\n",
    "\n",
    "p1 = Point()\n",
    "print(hasattr(p1, 'x'))  # (instance, attr) checks for instance specific variables\n",
    "print(hasattr(Point, 'x'))  # (object, attr) checks for static variables. False for instance variables.\n",
    "print(hasattr(Point, 'kind'))  # (object, attr) True for static variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Chapter 16: Classes and functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Time(object):\n",
    "    def __init__(self, h=None, m=None, s=None):\n",
    "        self.hour = h\n",
    "        self.minute = m\n",
    "        self.second = s\n",
    "        \n",
    "\n",
    "def print_time(time):\n",
    "    print('%d:%d:%s' % (time.hour, time.minute, time.second))\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anything that can be done with **modifiers**(functions that modify the parameters) can also be done with **pure functions**(functions that do not modify the arguments and just return a value). In fact, some programming languages only allow pure functions. There is some evidence that programs that use pure functions are faster to develop and less error-prone than programs\n",
    "that use modifiers. But modifiers are convenient at times, and functional programs tend to be less efficient."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">In general, it is recommended that you write pure functions whenever it is reasonable and resort\n",
    "to modifiers only if there is a compelling advantage. This approach might be called a\n",
    "**functional programming style**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Development Plans\n",
    "\n",
    "2 development plans are discussed here:  \n",
    "\n",
    "1. **Prototype and Patch** A development plan that involves writing a rough draft of a program, testing, and correcting errors as they are found.\n",
    "This approach can be effective, especially if you don’t yet have a deep understanding\n",
    "of the problem. But incremental corrections can generate code that is unnecessarily\n",
    "complicated—since it deals with many special cases—and unreliable—since it is hard to\n",
    "know if you have found all the errors.\n",
    "\n",
    "2. **Planned Development** in which high-level insight into the problem can make the programming much easier.  \n",
    "\n",
    "For eg. while writing a Time object, the insight into the problem is that the Time object can be treated as a three-digit number in base 60. The benefit is that the computer knows how to operate with integers. Hence, adding and subtracting two Time objects will beomce easier.  \n",
    "Ironically, sometimes making a problem harder (or more general) makes it easier (because\n",
    "there are fewer special cases and fewer opportunities for error)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 17: Classes and methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eg. of method: print_time method of object Time\n",
    "```python\n",
    "class Time(object):\n",
    "    def print_time(start):\n",
    "        print(start.hours, start.minutes)\n",
    "```\n",
    "There are 2 ways to call print_time.\n",
    "\n",
    "1. `Time.print_time(start)` (similar to _static_ methods in Java)\n",
    "2. `start.print_time()` where the method is invoked for a specific instance of object.  \n",
    "\n",
    "For option 2, `print_time` is defined as follows-  \n",
    "```python\n",
    "class Time(object):\n",
    "    def print_time(self):\n",
    "        print(self.hours, self.minutes)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Constructor for python class**  \n",
    "In python, the constructor is a method called `__init__` and called as \n",
    "```python\n",
    "class Time(object):\n",
    "    def __init__(self, h=0, m=0, s=0):\n",
    "        ....\n",
    "\n",
    "time()    # default constructor\n",
    "time(4)   # h = 4\n",
    "time(4,30) # h = 4, m = 30\n",
    "```\n",
    "Python doesn't support method overloading, but gives the format of default arguments. This format is more intuitive and hence preferred by Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**__str__** method  \n",
    "\n",
    "`__str__` is a special method, like `__init__` that returns a string represtation of an object.  \n",
    "Similar to `toString()` method in Java.\n",
    "```python\n",
    "def __str__(self):\n",
    "    return 'some string'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Operator Overloading\n",
    "\n",
    "By defining other special methods, you can specify the behavior of operators on userdefined types. For example, if you define a method named **`__add__`** for the Time class, you can use the `+` operator on Time objects.  \n",
    "```python\n",
    "def __add__(self, other):\n",
    "    return <aTimeObject>\n",
    "```\n",
    "\n",
    "Similarly, their are special methods for other other operators and specific functionality such as\n",
    "```python\n",
    "__new__()\n",
    "__del__()\n",
    "__repr__()  # called by repr() function to get the string representation of an object\n",
    "\n",
    "#comparison operators\n",
    "__lt__()  # less than\n",
    "__le__()\n",
    "__eq__()\n",
    "__ne__() # not equal to\n",
    "__gt__()\n",
    "__ge__()\n",
    "\n",
    "# comparison ( like Java's .compare() )\n",
    "# Only for Python2. Python3 doesn't support cmp() or __cmp__()\n",
    "__cmp__(self, other)\n",
    "\"\"\" output sign decided using (self - other)\n",
    "-ve : self < other\n",
    "0 : self == other\n",
    "+ve : self > other\n",
    "\"\"\"\n",
    "\n",
    "# hash\n",
    "__hash__()\n",
    "```\n",
    "\n",
    "The **cmp() function should be treated as gone, and the `__cmp__()` special method is no longer supported.** Use `__lt__()` for sorting, `__eq__()` with `__hash__()`, and other rich comparisons as needed. (If you really need the cmp() functionality, you could use the expression (a > b) - (a < b) as the equivalent for cmp(a, b).)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of using `__add__` to add 2 `Time` objects and increment a `Time` object with an integer.  \n",
    "`Time` + `Time`  \n",
    "`Time` + `int`\n",
    "```python\n",
    "def __add__(self, other):\n",
    "    if isinstance(other, Time):\n",
    "        return self.add_time(other)\n",
    "    else:\n",
    "        return self.increment(other)\n",
    "\n",
    "def add_time(self, other):\n",
    "    seconds = self.time_to_int() + other.time_to_int()\n",
    "    return int_to_time(seconds)\n",
    "\n",
    "def increment(self, seconds):\n",
    "    seconds += self.time_to_int()\n",
    "    return int_to_time(seconds)\n",
    "```\n",
    "\n",
    "Unfortunately, this implementation of addition is not commutative. If the integer is the first operand, you get `unsupported operand type(s)` error.  \n",
    "Python is asking an integer to add a Time object, and it doesn’t know how to do that. But there is a clever\n",
    "solution for this problem: the special method **`__radd__`**, which stands for “right-side add.”\n",
    "This method is invoked when a Time object appears on the right side of the + operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Polymorphism\n",
    "\n",
    "Polymorphism is inherent in the python programming syntax. Since we do not specify a data type of the input variable, the variable can be of any type. This feature inherently supports polymorphism.\n",
    "\n",
    "For eg. function `histogram` works for strings, lists, tuples etc. i.e. any kind of sequence.\n",
    "```python\n",
    "def histogram(s):\n",
    "    d = dict()\n",
    "    for c in s:\n",
    "        if c not in d:\n",
    "            d[c] = 1\n",
    "        else:\n",
    "            d[c] = d[c]+1\n",
    "    return d\n",
    "```\n",
    "\n",
    "In general, if all of the operations inside a function work with a given type, then the function works with that type.  \n",
    "The best kind of polymorphism is the unintentional kind, where you di"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Accessing attributes of an object\n",
    "\n",
    "Their are 2 ways to check for an attribute in an object.  \n",
    "\n",
    "1. Using `hasattr` and `getattr` functions.\n",
    "2. Using the special attribute __dict__, which is a dictionary that maps attribute names (as strings) and values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True 3\n",
      "{'x': 3, 'y': 4}\n"
     ]
    }
   ],
   "source": [
    "p1 = Point(3,4)\n",
    "print(hasattr(p1, 'x'), getattr(p1, 'x'))\n",
    "print(p1.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For purposes of debugging, you might find it useful to keep this function handy:\n",
    "```python\n",
    "def print_attributes(obj):\n",
    "    for attr in obj.__dict__:\n",
    "        print attr, getattr(obj, attr)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Chapter 18: Inheritance\n",
    "\n",
    "Syntax:\n",
    "```python\n",
    "class ChildClass(ParentClass):\n",
    "    ...\n",
    "```\n",
    "We can **override** the methods of the Parent class by defining a new method with the same signature.  \n",
    "\n",
    "To call a function of the Parent class, use super() function. For eg.  \n",
    "```python\n",
    "super().__init__(self,...)\n",
    "```\n",
    "For detailed explanation read the official documentation [here](https://docs.python.org/3/library/functions.html#super). While studying about Inheritance the order of execution of constructors and destructors of Child and Parent classes is important."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<class 'str'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "x = 'asdf'\n",
    "print(type(x).mro())  # method resolution order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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": 0
}