1_intro_to_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python\n",
    "\n",
    "## What is Python?\n",
    "\n",
    ">Python is an open-source, general purpose programming language that is dynamic, strongly-typed, object-oriented, functional, memory-managed and above all, fun to use!\n",
    "\n",
    "**Open-source** - Python’s development is done in the open by a large and diverse community of volunteers.\n",
    "\n",
    "**General purpose** - from simple scripts and command-line tools to web applications, network servers, GUIs, scientific applications, etc\n",
    "\n",
    "**Dynamic** - types are checked only at runtime\n",
    "\n",
    "**Strongly-typed** - only execute operations that are supported by the target type\n",
    "\n",
    "**Object oriented** - supports all standard OOP features that Java has, e.g. classes, encapsulation, inheritance, polymorphism. and goes beyond Java and supports multiple inheritance, operator overloading, meta-programming, etc\n",
    "\n",
    "**Functional** - functions are first-class objects that can be created, manipulated and passed around just like any other object\n",
    "\n",
    "**Memory management** - Python runtime takes care of correctly allocating and freeing up memory.\n",
    "\n",
    "References:\n",
    "\n",
    "http://antrix.net/static/pages/python-for-java/online/\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison in Hello World \n",
    "\n",
    "### Java\n",
    "```java\n",
    "public class HelloWorld {\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        // Prints \"Hello, World\" to the terminal window.\n",
    "        System.out.println(\"Hello, World\");\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "### Python\n",
    "```Python\n",
    "print (\"Hello, World\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World\n"
     ]
    }
   ],
   "source": [
    "print (\"Hello, World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A Python Program\n",
    "\n",
    "The script defines a single function, the approximate_size() function, which takes an exact file size in bytes and calculates a “pretty” (but approximate) size.\n",
    "\n",
    "Try to run the code block by selecting the \"Cell\" from the top menu, then click \"Run\". The keyboard shortcut is `Ctrl+Enter`.\n",
    "\n",
    "http://www.diveintopython3.net/your-first-python-program.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 TB\n",
      "931.3 GiB\n"
     ]
    }
   ],
   "source": [
    "SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],\n",
    "            1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']}\n",
    "\n",
    "def approximate_size(size, a_kilobyte_is_1024_bytes=True):\n",
    "    '''Convert a file size to human-readable form.\n",
    "\n",
    "    Keyword arguments:\n",
    "    size -- file size in bytes\n",
    "    a_kilobyte_is_1024_bytes -- if True (default), use multiples of 1024\n",
    "                                if False, use multiples of 1000\n",
    "\n",
    "    Returns: string\n",
    "\n",
    "    '''\n",
    "    if size < 0:\n",
    "        raise ValueError('number must be non-negative')\n",
    "\n",
    "    multiple = 1024 if a_kilobyte_is_1024_bytes else 1000\n",
    "    for suffix in SUFFIXES[multiple]:\n",
    "        size /= multiple\n",
    "        if size < multiple:\n",
    "            return '{0:.1f} {1}'.format(size, suffix)\n",
    "\n",
    "    raise ValueError('number too large')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    print(approximate_size(1000000000000, False))\n",
    "    print(approximate_size(1000000000000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List and Dictionary\n",
    "\n",
    "**List** is the most versatile datatype available in Python which can be written as a list of comma-separated values (items) between square brackets. Important thing about a list is that items in a list need not be of the same type.\n",
    "\n",
    "### Create a list\n",
    "Types can be mixed types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'chemistry'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = ['physics', 'chemistry', 1997, 2000]\n",
    "list2 = [1, 2, 3, 4, 5 ]\n",
    "list3 = [\"a\", \"b\", \"c\", \"d\"]\n",
    "\n",
    "list1[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing Values in Lists\n",
    "\n",
    "To access values in lists, use the square brackets for slicing along with the index or indices to obtain value available at that index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list1[0]:  physics\n",
      "list2[1:5]:  [2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "print (\"list1[0]: \", list1[0])\n",
    "print (\"list2[1:5]: \", list2[1:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Updating Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value available at index 2 : \n",
      "1997\n",
      "New value available at index 2 : \n",
      "2001\n",
      "New list : \n",
      "['physics', 'chemistry', 2001, 2000, 2016]\n",
      "['physics', 'chemistry', 2001, 2000, 2016, [1, 2, 3]]\n",
      "['physics', 'chemistry', 2001, 2000, 2016, [1, 2, 3], 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "list = ['physics', 'chemistry', 1997, 2000];\n",
    "\n",
    "print (\"Value available at index 2 : \")\n",
    "print (list[2])\n",
    "\n",
    "list[2] = 2001;\n",
    "print (\"New value available at index 2 : \")\n",
    "print (list[2])\n",
    "\n",
    "list.append(2016)\n",
    "print (\"New list : \")\n",
    "print (list)\n",
    "\n",
    "list.append([1,2,3])\n",
    "print (list)\n",
    "\n",
    "list.extend([1,2,3])\n",
    "print (list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Delete List Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['physics', 'chemistry', 1997, 2000]\n",
      "After deleting value at index 2 : \n",
      "['physics', 'chemistry', 2000]\n"
     ]
    }
   ],
   "source": [
    "print (list1)\n",
    "del list1[2];\n",
    "print (\"After deleting value at index 2 : \")\n",
    "print (list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic List Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get length of a list\n",
    "len(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['physics', 'chemistry', 2000, 1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Concat 2 lists\n",
    "list1 + list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hi!', 'Hi!', 'Hi!', 'Hi!']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repeat\n",
    "['Hi!'] * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if a value exists in a list\n",
    "3 in [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# iterate a list\n",
    "for x in [1, 2, 3]: \n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 6, 2, 8, 1]\n",
      "[1, 8, 2, 6, 4]\n",
      "[1, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "list2 = [4, 6, 2, 8, 1]\n",
    "print (list2)\n",
    "\n",
    "list2.reverse()\n",
    "print (list2)\n",
    "\n",
    "list2.sort()\n",
    "print (list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionary** is similar to HashMap in Java, used to store key-value pairs.\n",
    "\n",
    "```Python\n",
    "SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],\n",
    "            1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']}\n",
    "```\n",
    "\n",
    "Any type can be used as key and value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']\n"
     ]
    }
   ],
   "source": [
    "SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],\n",
    "            1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']}\n",
    "print (SUFFIXES[1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['big', 'medium', 'small']\n",
      "{1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'], 'size': ['big', 'medium', 'small']}\n"
     ]
    }
   ],
   "source": [
    "# String as key and list as value\n",
    "SUFFIXES[\"size\"] = ['big', 'medium', 'small']\n",
    "print (SUFFIXES[\"size\"])\n",
    "print (SUFFIXES)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'SUFFIXES' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-d35404b89b7a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# A dictionary as value\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mnewDict\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[0mnewDict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'dict'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mSUFFIXES\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[0mnewDict\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'SUFFIXES' is not defined"
     ]
    }
   ],
   "source": [
    "# A dictionary as value\n",
    "newDict = {}\n",
    "newDict['dict'] = SUFFIXES\n",
    "print (newDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Declaring Functions\n",
    "\n",
    "Python has functions like most other languages, but it does not have separate header files like c++ or interface/implementation sections like Pascal. When you need a function, just declare it, like this:\n",
    "\n",
    "```Python\n",
    "def approximate_size(size, a_kilobyte_is_1024_bytes=True):\n",
    "```\n",
    "* The keyword `def` starts the function declaration, followed by the function name, followed by the arguments in parentheses. Multiple arguments are separated with commas.\n",
    "\n",
    "* Python functions do not specify the datatype of their return value; they don’t even specify whether or not they return a value. (a function returns a value or `null`).\n",
    "\n",
    "* Types of arguments are not neccesary either, based on what value you assign, Python keeps track of the datatype internally.\n",
    "\n",
    "* Python allows function arguments to have default values if the values are missing in the function call."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try to execute the following function calls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4.0 KB'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "approximate_size(4000, a_kilobyte_is_1024_bytes=False)\n",
    "\n",
    "approximate_size(size=4000, a_kilobyte_is_1024_bytes=False)\n",
    "\n",
    "approximate_size(a_kilobyte_is_1024_bytes=False, size=4000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**You should expect some errors from the next two statements**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "non-keyword arg after keyword arg (<ipython-input-35-e27de07ba033>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-35-e27de07ba033>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    approximate_size(a_kilobyte_is_1024_bytes=False, 4000)\u001b[0m\n\u001b[1;37m                                                    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m non-keyword arg after keyword arg\n"
     ]
    }
   ],
   "source": [
    "approximate_size(a_kilobyte_is_1024_bytes=False, 4000) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "non-keyword arg after keyword arg (<ipython-input-36-f36052c5a357>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-36-f36052c5a357>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    approximate_size(size=4000, False)\u001b[0m\n\u001b[1;37m                               ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m non-keyword arg after keyword arg\n"
     ]
    }
   ],
   "source": [
    "approximate_size(size=4000, False) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing Readable Code\n",
    "\n",
    "### Documentation Strings\n",
    "\n",
    "You can document a Python function by giving it a documentation string (`docstring` for short). In this program, the `approximate_size()` function has a `docstring`:\n",
    "\n",
    "```Python\n",
    "def approximate_size(size, a_kilobyte_is_1024_bytes=True):\n",
    "\n",
    "    '''Convert a file size to human-readable form.\n",
    "\n",
    "    Keyword arguments:\n",
    "    size -- file size in bytes\n",
    "    a_kilobyte_is_1024_bytes -- if True (default), use multiples of 1024\n",
    "                                if False, use multiples of 1000\n",
    "\n",
    "    Returns: string\n",
    "\n",
    "    '''\n",
    "```\n",
    "\n",
    "* the docstring is available at runtime as an attribute of the function.\n",
    "* Many IDE use the `docstring` to provide context-sensitive documentation, so that when you type a function name, its docstring appears as a tooltip."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Convert a file size to human-readable form.\n",
      "\n",
      "    Keyword arguments:\n",
      "    size -- file size in bytes\n",
      "    a_kilobyte_is_1024_bytes -- if True (default), use multiples of 1024\n",
      "                                if False, use multiples of 1000\n",
      "\n",
      "    Returns: string\n",
      "\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(approximate_size.__doc__) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Everything Is An Object#\n",
    "\n",
    "Everything in Python is an object, and everything can have attributes and methods. All functions have a built-in attribute `__doc__`, which returns the docstring defined in the function’s source code. The `sys` module is an object which has (among other things) an attribute called path. And so forth.\n",
    "\n",
    "Different programming languages define “object” in differently. In some, it means that all objects must have attributes and methods; in others, it means that all objects are subclassable. In Python, the definition is looser. Some objects have neither attributes nor methods, but they could. Not all objects are subclassable. But everything is an object in the sense that it can be assigned to a variable or passed as an argument to a function.\n",
    "\n",
    "In Python, functions are first-class objects. You can pass a function as an argument to another function. Modules are first-class objects. You can pass an entire module as an argument to a function. Classes are first-class objects, and individual instances of a class are also first-class objects.\n",
    "\n",
    "This is important, so I’m going to repeat it in case you missed it the first few times: everything in Python is an object. Strings are objects. Lists are objects. Functions are objects. Classes are objects. Class instances are objects. Even modules are objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"OS routines for NT or Posix depending on what system we're on.\\n\\nThis exports:\\n  - all functions from posix, nt or ce, e.g. unlink, stat, etc.\\n  - os.path is either posixpath or ntpath\\n  - os.name is either 'posix', 'nt' or 'ce'.\\n  - os.curdir is a string representing the current directory ('.' or ':')\\n  - os.pardir is a string representing the parent directory ('..' or '::')\\n  - os.sep is the (or a most common) pathname separator ('/' or ':' or '\\\\\\\\')\\n  - os.extsep is the extension separator (always '.')\\n  - os.altsep is the alternate pathname separator (None or '/')\\n  - os.pathsep is the component separator used in $PATH etc\\n  - os.linesep is the line separator in text files ('\\\\r' or '\\\\n' or '\\\\r\\\\n')\\n  - os.defpath is the default search path for executables\\n  - os.devnull is the file path of the null device ('/dev/null', etc.)\\n\\nPrograms that import and use 'os' stand a better chance of being\\nportable between different platforms.  Of course, they must then\\nonly use functions that are defined by all platforms (e.g., unlink\\nand opendir), and leave all pathname manipulation to os.path\\n(e.g., split and join).\\n\""
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "os.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"str(object='') -> str\\nstr(bytes_or_buffer[, encoding[, errors]]) -> str\\n\\nCreate a new string object from the given object. If encoding or\\nerrors is specified, then the object must expose a data buffer\\nthat will be decoded using the given encoding and error handler.\\nOtherwise, returns the result of object.__str__() (if defined)\\nor repr(object).\\nencoding defaults to sys.getdefaultencoding().\\nerrors defaults to 'strict'.\""
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"String is an object\".__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copy objects\n",
    "\n",
    "To achieve high performance, assignments in Python usually do not copy the underlaying objects. This is important for example when objects are passed between functions, to avoid an excessive amount of memory copying when it is not necessary (**pass by reference**)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = [10, 11, 12, 13, 14]\n",
      "b = [10, 11, 12, 13, 14]\n",
      "After updating b:\n",
      "a = [20, 11, 12, 13, 14]\n",
      "b = [20, 11, 12, 13, 14]\n",
      "After updating a:\n",
      "a = [20, 30, 12, 13, 14]\n",
      "b = [20, 30, 12, 13, 14]\n"
     ]
    }
   ],
   "source": [
    "a = [10, 11, 12, 13, 14]\n",
    "b = a\n",
    "print (\"a =\", a)\n",
    "print (\"b =\", b)\n",
    "b[0] = 20\n",
    "print (\"After updating b:\")\n",
    "print (\"a =\", a)\n",
    "print (\"b =\", b)\n",
    "a[1] = 30\n",
    "print (\"After updating a:\")\n",
    "print (\"a =\", a)\n",
    "print (\"b =\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to avoid this behavior, so that when we get a new completely independent object B copied from A, then we need to do a so-called \"deep copy\" using the function copy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = [10, 11, 12, 13, 14]\n",
      "b = [10, 11, 12, 13, 14]\n",
      "After updating b:\n",
      "a = [10, 11, 12, 13, 14]\n",
      "b = [20, 11, 12, 13, 14]\n",
      "After updating a:\n",
      "a = [10, 30, 12, 13, 14]\n",
      "b = [20, 11, 12, 13, 14]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "a = [10, 11, 12, 13, 14]\n",
    "b = copy.copy(a)\n",
    "print (\"a =\", a)\n",
    "print (\"b =\", b)\n",
    "b[0] = 20\n",
    "print (\"After updating b:\")\n",
    "print (\"a =\", a)\n",
    "print (\"b =\", b)\n",
    "a[1] = 30\n",
    "print (\"After updating a:\")\n",
    "print (\"a =\", a)\n",
    "print (\"b =\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indenting Code\n",
    "\n",
    "Python functions have no explicit `begin` or `end`, and no curly braces to mark where the function code starts and stops. The only delimiter is a colon (:) and the indentation of the code itself.\n",
    "\n",
    "```Python\n",
    "def approximate_size(size, a_kilobyte_is_1024_bytes=True): \n",
    "    if size < 0:                                           \n",
    "        raise ValueError('number must be non-negative')    \n",
    "                                                           \n",
    "    multiple = 1024 if a_kilobyte_is_1024_bytes else 1000\n",
    "    for suffix in SUFFIXES[multiple]:                     \n",
    "        size /= multiple\n",
    "        if size < multiple:\n",
    "            return '{0:.1f} {1}'.format(size, suffix)\n",
    "\n",
    "    raise ValueError('number too large')\n",
    "```\n",
    "\n",
    "Since indentation is a language requirement and not a matter of style. This makes it easier to read and understand other people’s Python code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4.0 KB'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def approximate_size(size, a_kilobyte_is_1024_bytes=True): \n",
    "    if size < 0:                                           \n",
    "        raise ValueError('number must be non-negative')   \n",
    "\n",
    "    multiple = 1024 if a_kilobyte_is_1024_bytes else 1000\n",
    "    for suffix in SUFFIXES[multiple]:                     \n",
    "        size /= multiple\n",
    "        if size < multiple:\n",
    "            return '{0:.1f} {1}'.format(size, suffix)\n",
    "\n",
    "    raise ValueError('number too large')\n",
    "    \n",
    "approximate_size(4000, a_kilobyte_is_1024_bytes=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exceptions\n",
    "\n",
    "An exception doesn’t need to result in a complete program crash, though. Exceptions can be handled. Sometimes an exception is really because you have a bug in your code (like accessing a variable that doesn’t exist), but sometimes an exception is something you can anticipate. If you’re opening a file, it might not exist. If you’re importing a module, it might not be installed. If you’re connecting to a database, it might be unavailable, or you might not have the correct security credentials to access it. If you know a line of code may raise an exception, you should handle the exception using a `try...except` block.\n",
    "\n",
    "* Unlike Java, Python functions don’t declare which exceptions they might raise. It’s up to you to determine what possible exceptions you need to catch.\n",
    "\n",
    "* Python uses `try...except` blocks to handle exceptions, and the `raise` statement to generate them\n",
    "\n",
    "* Java and c++ use `try...catch` blocks to handle exceptions, and the `throw` statement to generate them.\n",
    "\n",
    "* Use the raise statement, followed by the exception name, and an optional human-readable string for debugging purposes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike Java, Python functions don’t declare which exceptions they might raise. It’s up to you to determine what possible exceptions you need to catch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}