mynotes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LEARN Python in one day and LEARN IT WELL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Disclaimer: This note is based on the same book by [Jamie Chan](http://learncodingfast.com/python/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 1: Python, what Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before diving into the nuts and bolts of Python programming, Jamie answered a few questions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a widely used high-level programming language that places strong emphasis on _code readability_ and _simplicity_.\n",
    "\n",
    "Python code resembles the English language."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why Learn Python?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Key features of Python:\n",
    "\n",
    "* Simplicity: considerably fewer lines of code, fewer programming errors and reduced development time.\n",
    "* An extensive collection of third party resources.\n",
    "* Cross-platform language."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 2: Getting ready for Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 3: The World of Variables and Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What are variables?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables are _names_ given to _data_ that we need to store and manipulate in our programs.\n",
    "\n",
    "_Every time_ we declare a _new_ variable, we need to give it an _initial_ value.\n",
    "\n",
    "In Python, we can also define _multiple_ variables at one go - neat. To do that simply write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 Rocks\n"
     ]
    }
   ],
   "source": [
    "user_age, user_name = 30, \"Rocks\"\n",
    "print(user_age, user_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Naming a Variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A variable in Python should only contain letters (a - z, A - B), numbers or underscores (\\_). However, the _first_ character _cannot_ be a number.\n",
    "\n",
    "In addition and not surprisingly, there are some _reserved words_ that we cannot use as a variable name because they already have been pre-assigned meanings in Python.\n",
    "\n",
    "Finally, variable names are case _sensitive_.\n",
    "\n",
    "There are two conventions when naming a variable in Python:\n",
    "\n",
    "* Underscore: this is the convention I have adopted in both Python and `R` - a manifestation of \"simpler is better.\"\n",
    "* Camel-case notation: the practice of writing compound words with mixed casing. The convention Jamie adopted in this book."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Assignment Sign"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the `=` sign in a programming language has different meaning as in Maths. In programming, the `=` sign is known as an assignment sign. \n",
    "\n",
    "A good way to understand the statement `user_age = 0` is to think of it as `user_age <- 0` as in `R`. So `R` is more intuitive in this sense.\n",
    "\n",
    "The statements `x = y` and `y = x` have very different meanings in programming. Mathematically, they mean the same thing. However, this is not the case in programming."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  10\n",
      "y =  10\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = 10\n",
    "x = y\n",
    "print(\"x = \", x)\n",
    "print(\"y = \", y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  5\n",
      "y =  5\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = 10\n",
    "y = x\n",
    "print(\"x = \", x)\n",
    "print(\"y = \", y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides assigning a variable an initial value, we can also perform the usual mathematical operations on variables. Basic operators in Python include `+`, `-`, `*`, `/`, `//`, `%` and `**`:\n",
    "\n",
    "* `//`: Floor Division - rounds down the answer to the nearest whole number.\n",
    "* `%`: Modulus - gives the remainder.\n",
    "* `**`: Exponent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "x = 5; y = 2\n",
    "print(x // y)\n",
    "print(x % y)\n",
    "print(x ** y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More Assignment Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 10\n",
    "x += 2\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `+=` sign is actually a _shorthand_ that combines the assignment sign with the addition operator. The same works for all the other 6 operators mentioned above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 4: Data Types in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic data types in Python:\n",
    "\n",
    "* Integer\n",
    "* Float\n",
    "* String\n",
    "\n",
    "Explore the concept of type casting. \n",
    "\n",
    "Three more advanced data types in Python:\n",
    "\n",
    "* List\n",
    "* Tuple\n",
    "* Dictionary\n",
    "\n",
    "Note: Variables in Python are simply _declared_ by being assigned to a desired initial value, e.g. an integer or float."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String refers to text.\n",
    "\n",
    "Both single and double quotes can be used to form strings.\n",
    "\n",
    "Multiple substrings can be combined by using the concatenate sign (`+`). Apparently, the plus sign (`+`) has been _overloaded_ by Python to make our lives easier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PeterLee'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Peter\" + \"Lee\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Built-In String Functions\n",
    "\n",
    "Python has a number of built-in functions to manipulate strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PETER'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Peter\".upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fomatting Strings using the `%` Operator\n",
    "\n",
    "Strings can be formatted using the `%` operator, which gives us greater control over how we want our string to be displayed and stored. The syntax for using `%` operator is\n",
    "\n",
    "`\"string to be formatted\" % (values or variables to be inserted into string, separated by commas)`\n",
    "\n",
    "There are three parts to this syntax:\n",
    "\n",
    "1. Write the string to be formatted in quotes.\n",
    "2. Write the `%` symbol.\n",
    "3. Write a pair of round brackets `()` within which we write the values or variables to be inserted into the string. This round brackets with values inside are actually known as a tuple, a data type to be covered later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The price of this Apple laptop is 1299 USD and the exchange rate is 1.24 USD to 1 EUR\n"
     ]
    }
   ],
   "source": [
    "brand = \"Apple\"\n",
    "exchange_rate = 1.235235245\n",
    "\n",
    "message = \"The price of this %s laptop is %d USD and the exchange rate is %4.2f USD to 1 EUR\" % (brand, 1299, exchange_rate)\n",
    "\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, the string `\"The price of this %s laptop is %d USD and the exchange rate is %4.2f USD to 1 EUR\"` is the string that we'd like to format. We use the `%s`, `%d` and `%4.2f` _formatters_ as **placeholders** in the string.\n",
    "\n",
    "These placeholders will be replaced with the variable `brand`, the value `1299` and the variable `exchange_rate` respectively, as indicated in the round brackets.\n",
    "\n",
    "The `%s` formatter is used to represent a string (\"Apple\" in this case) whilst the `%d` formatter represents an integer (1299).\n",
    "\n",
    "If we want to add spaces _before_ an integer, we can add a number between `%` and `d` to indicate the desired (total) length of the string. For instance,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|  123|\n"
     ]
    }
   ],
   "source": [
    "print(\"|%5d|\" % 123)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `%f` formatter is used to format floats (numbers with decimals). Here `%4.2f` refers to the total length of 4 with 2 decimal places. If we want to add spaces before the number,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|   1.24|\n"
     ]
    }
   ],
   "source": [
    "print(\"|%7.2f|\" % exchange_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formatting String using the `format()` method\n",
    "\n",
    "In addition to using the `%` operator to format strings, Python also provides us with the `format()` method whose syntax is\n",
    "\n",
    "`\"string to be formatted\".format(values or variables to be inserted into string, separated by commas)`\n",
    "\n",
    "Instead of using `%s`, `%f` and `%d` as placeholders, we use curly brackets like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "message = \"The price of this {0:s} laptop is {1:d} USD and the exchange rate is {2:4.2f} USD to 1 EUR\".format(\"Apple\", 1299, 1.23523545)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inside the curly brackets, we first write the position of the parameter to use, followed by a colon then by the formatter. There should not be any spaces within the curly brackets.\n",
    "\n",
    "Positions _always_ starts from ZERO."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The price of this Apple laptop is 1299 USD and the exchange rate is 1.24 USD to 1 EUR\n"
     ]
    }
   ],
   "source": [
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: If we do not want to format the string, we can simply write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "message = \"The price of this {} laptop is {} USD and the exchange rate is {} USD to 1 EUR\".format(\"Apple\", 1299, 1.23523545)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we do not have to specify the position of the parameters and the interpreter will replace the curly brackets based on the order of the parameters provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The price of this Apple laptop is 1299 USD and the exchange rate is 1.23523545 USD to 1 EUR\n"
     ]
    }
   ],
   "source": [
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To better understand the `format()` method, try the following program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python is easier than Java\n",
      "Java is easier than Python\n",
      "      1.23 and 12\n",
      "1.234234234\n"
     ]
    }
   ],
   "source": [
    "message1 = \"{0} is easier than {1}\".format(\"Python\", \"Java\")\n",
    "message2 = \"{1} is easier than {0}\".format(\"Python\", \"Java\")\n",
    "message3 = \"{:10.2f} and {:d}\".format(1.234234234, 12)\n",
    "message4 = \"{}\".format(1.234234234)\n",
    "\n",
    "print(message1)\n",
    "\n",
    "print(message2)\n",
    "\n",
    "print(message3) # notice the spaces in front of the output string.\n",
    "\n",
    "print(message4) # no formatting is done."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Type Casting In Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Type casting: converting from one data type to another.\n",
    "\n",
    "There are three built-in Python that allow us to do type casting:\n",
    "\n",
    "1. `int()`: this function takes in a float or an appropriate string and converts it to an _integer_.\n",
    "2. `float()`: takes in an integer or an appropriate string and changes it to a _float_.\n",
    "3. `str()`: converts an integer or a float to a _string_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.712987 <class 'float'>\n",
      "5 <class 'int'>\n",
      "4 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "a = 5.712987\n",
    "print(a, type(a))\n",
    "print(int(a), type(int(a)))\n",
    "print(int(\"4\"), type(int(\"4\")))\n",
    "\n",
    "## ValueError: invalid literal for int()\n",
    "# print(int(\"Hello\"))\n",
    "# print(int(\"4.22321\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0 <class 'float'>\n",
      "2.0 <class 'float'>\n",
      "2.09109 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(float(2), type(float(2)))\n",
    "print(float(\"2\"), type(float(\"2\")))\n",
    "print(float(\"2.09109\"), type(float(\"2.09190\"))) # not a string: quotation marks removed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.1 <class 'float'>\n",
      "2.1 <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(2.1, type(2.1))\n",
    "print(str(2.1), type(str(2.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we've coved the three basic data types in Python and their casting, let's move on to the more advanced data types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List refers to a _collection_ of data which are normally related. Instead of storing these data as separate variables, we can store them as a list.\n",
    "\n",
    "#### Declare a List\n",
    "\n",
    "To declare a list, we write `list_name = [initial values]`. Note that we use **square brackets** `[]` when declaring a list and multiple values are separated by commas.\n",
    "\n",
    "We can also declare a list without assigning any initial values to it: an empty list with no items in it. Simply write `list_name = []`. We have to use the `append()` method to add items to the list.\n",
    "\n",
    "#### Access Individual Values in a List\n",
    "\n",
    "Individual values in the list are acccessible by their _indexes_, and indexes always start from ZERO, not 1, which is a common practice in almost all programming languages such as C and Java.\n",
    "\n",
    "Alternatively, we can access the values of a list from the _back_. The **last** item in a list has an index of `-1`, the second last has index of `-2` and so forth.\n",
    "\n",
    "#### Slice and Assign a List\n",
    "\n",
    "We can assign a list, or part of it, to a variable.\n",
    "\n",
    "The notation `2:4` is known as a _slice_. Whenever we use the slice notation in Python, the item at the __start__ index is _always_ __included__, but the item at the __end__ is _always_ __excluded__. Hence the notation `2:4` refers to items from index `2` to index `4 - 1` (i.e. index `3`).\n",
    "\n",
    "The slice notation includes a third number known as the _**stepper**_. If we write `user_age4 = user_age[1:5:2]`, we will get a _sub-list_ consisting of _every second_ number from index `1` to index `5 - 1` (i.e. index `4`) because the stepper is 2.\n",
    "\n",
    "In addition, the slice notation has useful **defaults**. The default for the first number is _zero_, and the default for the second number is the _size_ of the list being sliced. For instance, `user_age[:4]` gives the values from index `0` to index `4 - 1` whilst `user_age[1:]` yields values from index `1` to index `5 - 1` (since the size of `user_age` is `5`, i.e. it has `5` items).\n",
    "\n",
    "#### Modify, Add and Remove Items in a List\n",
    "\n",
    "To modify items in a list, we write `list_name[index of item to be modified] = new value`.\n",
    "\n",
    "To add items, we use the `append()` function that adds the value to the **end** of a list.\n",
    "\n",
    "To remove items, we write `del list_name[index of item to be deleted]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "user_age:  [21, 22, 23, 24, 25]\n",
      "empty_list:  []\n",
      "user_age[0]:  21\n",
      "user_age[1]:  22\n",
      "user_age[-1]:  25\n",
      "user_age[-2]:  24\n",
      "user_age2:  [21, 22, 23, 24, 25]\n",
      "user_age3:  [23, 24]\n",
      "user_age4:  [22, 24]\n",
      "user_age5:  [21, 22, 23, 24]\n",
      "user_age6:  [22, 23, 24, 25]\n",
      "user_age after modification:  [21, 5, 23, 24, 25]\n",
      "user_age after addition:  [21, 5, 23, 24, 25, 99]\n",
      "user_age after removal:  [21, 5, 24, 25, 99]\n"
     ]
    }
   ],
   "source": [
    "user_age = [21, 22, 23, 24, 25]\n",
    "empty_list = []\n",
    "\n",
    "print(\"user_age: \", user_age)\n",
    "print(\"empty_list: \", empty_list)\n",
    "\n",
    "print(\"user_age[0]: \", user_age[0])\n",
    "print(\"user_age[1]: \", user_age[1])\n",
    "print(\"user_age[-1]: \", user_age[-1])\n",
    "print(\"user_age[-2]: \", user_age[-2])\n",
    "\n",
    "user_age2 = user_age\n",
    "print(\"user_age2: \", user_age2)\n",
    "\n",
    "user_age3 = user_age[2:4]\n",
    "print(\"user_age3: \", user_age3)\n",
    "\n",
    "## stepper\n",
    "user_age4 = user_age[1:5:2]\n",
    "print(\"user_age4: \", user_age4)\n",
    "\n",
    "## defaults\n",
    "user_age5 = user_age[:4]\n",
    "user_age6 = user_age[1:]\n",
    "\n",
    "print(\"user_age5: \", user_age5)\n",
    "print(\"user_age6: \", user_age6)\n",
    "\n",
    "## modify list items\n",
    "user_age[1] = 5\n",
    "\n",
    "print(\"user_age after modification: \", user_age)\n",
    "\n",
    "## add items\n",
    "user_age.append(99)\n",
    "\n",
    "print(\"user_age after addition: \", user_age)\n",
    "\n",
    "## remove items\n",
    "del user_age[2]\n",
    "\n",
    "print(\"user_age after removal: \", user_age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To fully appreciate the workings of a list, try running the following prgram:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List my_list is of length:  6\n",
      "[1, 2, 3, 4, 5, 'Hello']\n",
      "The 3rd element in my_list:  3\n",
      "The last element in my_list:  Hello\n",
      "The last element is also:  Hello\n",
      "Slicing my_list yields my_list2:  [2, 3, 4, 5]\n",
      "Updated my_list after modification on the 2nd element:  [1, 20, 3, 4, 5, 'Hello']\n",
      "Appended my_list:  [1, 20, 3, 4, 5, 'Hello', 'How are you']\n",
      "my_list after removing the 6th element:  [1, 20, 3, 4, 5, 'How are you']\n"
     ]
    }
   ],
   "source": [
    "# declaring the list, list elements can be of different data types\n",
    "my_list = [1, 2, 3, 4, 5, \"Hello\"]\n",
    "\n",
    "# print the length of the list\n",
    "print(\"List my_list is of length: \", len(my_list))\n",
    "\n",
    "# print the entire list\n",
    "print(my_list)\n",
    "\n",
    "# print the third element (recall: Index starts from ZERO).\n",
    "print(\"The 3rd element in my_list: \", my_list[2])\n",
    "\n",
    "# print the last item\n",
    "print(\"The last element in my_list: \", my_list[-1])\n",
    "print(\"The last element is also: \", my_list[len(my_list) - 1])\n",
    "\n",
    "# assign my_list (from index 1 to 4) to my_list2 and print my_list2\n",
    "my_list2 = my_list[1:5]\n",
    "print(\"Slicing my_list yields my_list2: \", my_list2)\n",
    "\n",
    "# modify the second item in my_list and print the updated list\n",
    "my_list[1] = 20\n",
    "print(\"Updated my_list after modification on the 2nd element: \", my_list)\n",
    "\n",
    "# append a new item to my_list and print the appended list\n",
    "my_list.append(\"How are you\")\n",
    "print(\"Appended my_list: \", my_list)\n",
    "\n",
    "# remove the 6th item from my_list and print the updated list\n",
    "del my_list[5]\n",
    "print(\"my_list after removing the 6th element: \", my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are just like _lists_, but we _cannot_ modify their values once created. The initial values are the values that will _stay_ for the rest of the program. An example where tuples are useful is when our program needs to store the names of the months of a year.\n",
    "\n",
    "To declare a tuple, we write `tuple_name = (initial values)`. Notice that we use _**round brackets**_ `()` when _declaring_ a tuple and multiple values are separated by _commas_.\n",
    "\n",
    "We access the individual values of a tuple using their indexes, just like with a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First month of the year:  Jan\n",
      "Last month of the year:  Dec\n"
     ]
    }
   ],
   "source": [
    "months_of_year = (\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\")\n",
    "\n",
    "print(\"First month of the year: \", months_of_year[0])\n",
    "print(\"Last month of the year: \", months_of_year[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionary is a _**collection**_ of _related_ data PAIRS. \n",
    "\n",
    "To declare a dictionary, we write `dictionary_name = {dictionary key: data}`, with the requirement that dictionary keys must be unique (within one dictionary). That is, we cannot declare a dictionary with duplicate key values.\n",
    "\n",
    "Note that we use _**curly**_ brackets `{}` when declaring a dictionary and mutiple pairs are separated by commas.\n",
    "\n",
    "We can also declare a dictionary using the `dict()` method. However, when using this method to declare a dictionary, we use round brackets `()` instead of curly brackets `{}` and we do not put quotation marks for the dictionary keys.\n",
    "\n",
    "To access individual items in a dictionary, we use the dictionary key, which is the first value in the `{dictionary key: data}` pair.\n",
    "\n",
    "To modify items in a dictionary, we write `dictionary_name[dictionary key of of item to be modified] = new data`.\n",
    "\n",
    "Like in a list, we can also declare a dictionary without assigning any initial values to it by simply writing `dictionary_name = {}`. This gives us an empty dictionary with no items in it.\n",
    "\n",
    "To add items to a dictionary, we write `dictionary_name[dictionary key] = data`. On the flip side, to remove items from a dictionary, we write `del dictionary_name[dictionary key]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'John': 51, 'Peter': 13}\n"
     ]
    }
   ],
   "source": [
    "## No error reported by Python 3 with duplicate key values except for overwriting Peter's age \n",
    "my_dictionary = {\"Peter\": 38, \"John\": 51, \"Peter\": 13}\n",
    "print(my_dictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'> {'Alex': 13, 'John': 51, 'Peter': 38, 'Alvin': 'Not Available'}\n",
      "<class 'dict'> {'Alvin': 'Not Available', 'John': 51, 'Peter': 38, 'Alex': 13}\n",
      "John's age:  51\n",
      "John's new age:  21\n",
      "Modified dictionary:  {'Alex': 13, 'John': 21, 'Peter': 38, 'Alvin': 'Not Available'}\n",
      "Empty dictionary:  <class 'dict'> {}\n",
      "Another empty dictionary:  <class 'dict'> {}\n",
      "Joe's age:  40\n",
      "Updated dictionary:  {'Alex': 13, 'Joe': 40, 'John': 21, 'Peter': 38, 'Alvin': 'Not Available'}\n",
      "Updated dictionary after removal:  {'Joe': 40, 'John': 21, 'Peter': 38, 'Alvin': 'Not Available'}\n"
     ]
    }
   ],
   "source": [
    "user_name_n_age = {\"Peter\": 38, \"John\": 51, \"Alex\": 13, \"Alvin\": \"Not Available\"}\n",
    "user_name_n_age2 = dict(Peter = 38, John = 51, Alex = 13, Alvin = \"Not Available\")\n",
    "\n",
    "print(type(user_name_n_age), user_name_n_age)\n",
    "print(type(user_name_n_age2), user_name_n_age2)\n",
    "\n",
    "print(\"John's age: \", user_name_n_age[\"John\"])\n",
    "\n",
    "## modify dictionary\n",
    "user_name_n_age[\"John\"] = 21\n",
    "print(\"John's new age: \", user_name_n_age[\"John\"])\n",
    "print(\"Modified dictionary: \", user_name_n_age)\n",
    "\n",
    "empty_dict = {}\n",
    "empty_dict2 = dict()\n",
    "\n",
    "print(\"Empty dictionary: \", type(empty_dict), empty_dict)\n",
    "print(\"Another empty dictionary: \", type(empty_dict2), empty_dict2)\n",
    "\n",
    "## add a new entry to dictionary\n",
    "user_name_n_age[\"Joe\"] = 40\n",
    "print(\"Joe's age: \", user_name_n_age[\"Joe\"])\n",
    "print(\"Updated dictionary: \", user_name_n_age)\n",
    "\n",
    "## remove an item (pair) from dictionary\n",
    "del user_name_n_age[\"Alex\"]\n",
    "print(\"Updated dictionary after removal: \", user_name_n_age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following program to see dictionaries in action."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'> with length of  4 {2.5: 'Tow Point Five', 3: '+', 'One': 1.35, 7.9: 2}\n",
      "key = 'One':  1.35\n",
      "Key = 7.9:  2\n",
      "Modified my_dict (key = 2.5):  {2.5: 'Two and a Half', 3: '+', 'One': 1.35, 7.9: 2}\n",
      "Adding a new item to my_dict (key = 'New item'):  {2.5: 'Two and a Half', 3: '+', 'One': 1.35, 'New item': \"I'm new\", 7.9: 2}\n",
      "Removing the item from my_dict (key = 'One'):  {2.5: 'Two and a Half', 3: '+', 'New item': \"I'm new\", 7.9: 2}\n"
     ]
    }
   ],
   "source": [
    "## declaring the dictionary\n",
    "## remember that dictionary keys and data can be of DIFFERENT data types\n",
    "my_dict = {\"One\": 1.35, 2.5: \"Tow Point Five\", 3: \"+\", 7.9: 2}\n",
    "\n",
    "## print the entire dictionary\n",
    "## note that the items in a dictionary are not stored in the same order as they were declared.\n",
    "print(type(my_dict), \"with length of \", len(my_dict), my_dict)\n",
    "\n",
    "## print the item with key = \"One\"\n",
    "print(\"key = 'One': \", my_dict[\"One\"])\n",
    "\n",
    "## print the item with key = 7.9\n",
    "print(\"Key = 7.9: \", my_dict[7.9])\n",
    "\n",
    "## modify the item with key = 2.5 and print the updated dictionary\n",
    "my_dict[2.5] = \"Two and a Half\"\n",
    "print(\"Modified my_dict (key = 2.5): \", my_dict)\n",
    "\n",
    "## add a new item and print the updated dictionary\n",
    "my_dict[\"New item\"] = \"I'm new\"\n",
    "print(\"Adding a new item to my_dict (key = 'New item'): \", my_dict)\n",
    "\n",
    "## remove the item with key = \"One\" and print the updated dictionary\n",
    "del my_dict[\"One\"]\n",
    "print(\"Removing the item from my_dict (key = 'One'): \", my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 5: Making Your Program Interactive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter your name: James\n",
      "What about your age: 20\n"
     ]
    }
   ],
   "source": [
    "my_name = input(\"Please enter your name: \")\n",
    "my_age = input(\"What about your age: \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World, my name is James and I am 20 years old.\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World, my name is\", my_name, \"and I am\", my_age, \"years old.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `input()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The information prompted by `input()` is stored as a **string**. This function differs slightly in Python 2 and Python 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `print()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `print()` function is used to display information to users. It accepts _zero_ or more expressions as parameters, separated by _commas_.\n",
    "\n",
    "Another way to print a statement with variables is to use the `%` formatter we learned in Chapter 4. To achieve the same output as above, we write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World, my name is James and I am 20 years old.\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World, my name is %s and I am %s years old.\" % (my_name, my_age))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, to print the same statement using the `format()` method, we write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World, my name is James and I am 20 years old.\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World, my name is {} and I am {} years old.\".format(my_name, my_age))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `print()` function is another function that differs in Python 2 and Python 3. In Python 2, we'll have to write it without brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World, my name is James and I am 20 years old.\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World, my name is \" + my_name + \" and I am \" + my_age + \" years old.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Triple Quotes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we need to display a long message, we can use the triple-quotes symbol (''' or \"\"\") to _span_ our message over multple lines. For instance,"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "## note that the code below does not work in Jupyter Notebook but it works in Python terminal\n",
    "\n",
    "msg = \"\"\"Hellow World.\n",
    "My name is James and\n",
    "I am 20 years old.\"\"\"\n",
    "\n",
    "print(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This helps to increase the readability of the message."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Escape Characters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes we may need to print some special \"unprintable\" characters such as a tab or a newline. In this case, we need to use the `\\` (backslash) character to escape those characters that otherwise have a different meaning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\tWorld\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello\\tWorld\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "World\n",
      "\\\n",
      "I am 5'9\" tall.\n",
      "I am 5'9\" tall.\n"
     ]
    }
   ],
   "source": [
    "## \\n: prints a newline\n",
    "print(\"Hello\\nWorld\")\n",
    "\n",
    "## \\\\: print the backslash character itself\n",
    "print(\"\\\\\")\n",
    "\n",
    "## \\\": prints a double quote, so that it does not signal the end of a string\n",
    "print(\"I am 5'9\\\" tall.\")\n",
    "\n",
    "## \\\": prints a single quote, so that it does not signal the end of a string\n",
    "print('I am 5\\'9\" tall.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we do not want characters preceded by the `\\` character to be interpreted as special character, we can use _raw_ strings by adding an `r` before the first quote. For instance, if we do not want `\\t` to be interpreted as a tab, we should type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\\tWorld\n"
     ]
    }
   ],
   "source": [
    "print(r'Hello\\tWorld')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 6: Making Choices and Decisions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "According to the author, this is supposed to be the most interesting chapter. In this chapter, we will look at how to make our programs smarter, capable of making choices and decision. Specifically, we'll be looking at the `if` statement, `for` loop and `while` loop. These are known as control flow tools: they control the flow of the program. In addition, we'll also look at the `try`, `except` statement that determines what the program should do when an error occurs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Condition Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "_All_ control flow tools involve evaluating a _condition_ statement. The program will proceed differently depending on whether the condition is met.\n",
    "\n",
    "The most common condition statement is the comparison statement. If we want to compare whether two variables are the same, we use the `==` sign (double `=`).\n",
    "\n",
    "Other comparison signs include `!=` (not equals), `<`, `>`, `<=` and `>=`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(5 != 2)\n",
    "print(5 > 2)\n",
    "print(2 < 5)\n",
    "print(5 >= 2)\n",
    "print(2 <= 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also have three logical operators: `not`, `and` and `or` that are useful if we'd like to combine multiple conditions.\n",
    "\n",
    "Remember:\n",
    "\n",
    "* The `and` operator returns `True` if _all_ conditions are met.\n",
    "* The `or` operator returns `False` if _none_ of the conditions is met."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `if` statement is one of the most commonly used control flow statements. It allows the program to evaludate if a certain condtion is met, and to perform the appropriate action based on the result of evaluation. The structure of an `if` statement is as follows\n",
    "\n",
    "`if condtion 1 is met:\n",
    "    do A\n",
    "elif condition 2 is met:\n",
    "    do B\n",
    "elif condition 3 is met:\n",
    "    do C\n",
    "elif condition 4 is met:\n",
    "    do D\n",
    "else:\n",
    "    do E`\n",
    "\n",
    "`elif` stands for \"else if\" and we can have as many `elif` statements as we like.\n",
    "\n",
    "People coming from other languages like C or Java may be suprised to notice that no parentheses `()` are needed in Python after the `if`, `elif` and `else` keywords. In addition, Python does not use curly brackets `{}` to define the scope of an `if` statement. Rather, Python uses **_indentation_**. Anything _indented_ is treated as a **block** of code that will be executed if the condition evaluates to `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter 1 or 2: 2\n",
      "Python rocks!\n",
      "I love Python\n"
     ]
    }
   ],
   "source": [
    "user_input = input(\"Enter 1 or 2: \")\n",
    "\n",
    "if user_input == \"1\":\n",
    "    print(\"Hello World\")\n",
    "    print(\"How are you?\")\n",
    "elif user_input == \"2\":\n",
    "    print(\"Python rocks!\")\n",
    "    print(\"I love Python\")\n",
    "else:\n",
    "    print(\"You did not enter a valid number.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inline If"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An inline `if` statement is a simpler form of an `if` statement and is more convenient if we only need to perform a simple task. The syntax is:\n",
    "\n",
    "do Task A `if` condition is `True` `else` do Task B."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is Task A\n"
     ]
    }
   ],
   "source": [
    "my_int = 10\n",
    "\n",
    "print(\"This is Task A\" if my_int == 10 else \"This is Task B\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `for` loop executes a block of code _repeatedly_ until the condition in the `for` statement is no longer met.\n",
    "\n",
    "_Looping through an iterable_\n",
    "\n",
    "In Python, an **iterable** refers to anything that can be _looped over_, such as a string, list or tuple. The syntax for looping through an iterable is as follows:\n",
    "\n",
    "`for a in iterable:\n",
    "    print(a)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cats\n",
      "dogs\n",
      "rabbits\n",
      "hamsters\n"
     ]
    }
   ],
   "source": [
    "pets = [\"cats\", \"dogs\", \"rabbits\", \"hamsters\"]\n",
    "\n",
    "for mypets in pets:\n",
    "    print(mypets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also display the _index_ of the members in a list. To do this, we use the `enumerate()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 cats\n",
      "1 dogs\n",
      "2 rabbits\n",
      "3 hamsters\n"
     ]
    }
   ],
   "source": [
    "for index, mypets in enumerate(pets):\n",
    "    print(index, mypets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "## Looping through a string\n",
    "message = \"Hello\"\n",
    "\n",
    "for i in message:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Looping through a sequence of numbers\n",
    "\n",
    "The built-in `range()` function comes in handy for this purpose. It generates a **_list_** of numbers and has the syntax `range(start, end, step)`.\n",
    "\n",
    "If `start` is not given, the numbers generated will start from _zero_. Note: A useful tip to remember is that in Python (and most programming languages), unless otherwise stated, we always start from zero.\n",
    "\n",
    "For instance, the index of a list and a tuple starts from zero. When using the `format()` method for strings, the positions of parameters start from zero. When using the `range()` function, if `start` is not specified, the numbers generated start from zero.\n",
    "\n",
    "If `step` is not given, a list of _consecutive_ numbers will be generated (i.e. `step = 1`), which makes sense. \n",
    "\n",
    "The `end ` value must be provided. However, one weird thing about `range()` function is that the given `end` value is never part of the generated list.\n",
    "\n",
    "To see how `range()` function works in a `for` statement, try running the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "***************\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "***************\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)\n",
    "\n",
    "print(\"*\" * 15) \n",
    "    \n",
    "for i in range(3, 10):\n",
    "    print(i)\n",
    "\n",
    "print(\"*\" * 15)\n",
    "    \n",
    "for i in range(4, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like the name suggests, a `while` loop repeatedly executes instructions inside the loop while a certain condition remains valid. The structure of a `while` statement is as follows:\n",
    "\n",
    "`while condition is true:\n",
    "    do A`\n",
    "\n",
    "Most of the time when using a `while` loop, we need to first declare a variable to function as a _loop counter_. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter =  5\n",
      "Counter =  4\n",
      "Counter =  3\n",
      "Counter =  2\n",
      "Counter =  1\n"
     ]
    }
   ],
   "source": [
    "counter = 5\n",
    "\n",
    "while counter > 0:\n",
    "    print(\"Counter = \", counter)\n",
    "    counter -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At first look, a `while` statement seems to have the simplest syntax and should be the easiest to use. However, one has to be careful when using `while` loops due to the danger of infinite loops. The line `counter -= 1` is crucial. It decreases the value of `counter` by 1 and assigns this new value back to `counter`, overwriting the original value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When working with loops, sometimes we may want to **exit** the _entire_ loop when a certain condition is met. To do this, we use the `break` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i =  0 , j =  2\n",
      "i =  1 , j =  4\n",
      "i =  2 , j =  6\n"
     ]
    }
   ],
   "source": [
    "j = 0\n",
    "for i in range(5):\n",
    "    j = j + 2\n",
    "    print(\"i = \", i, \", j = \", j)\n",
    "    if j == 6:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without the `break` keyword, the program should loop from `i = 0` to `i = 4` because we used the function `range(5)`. With the `break` keyword, however, the program ends _prematurely_ at `i = 2`.\n",
    "\n",
    "In the example above, notice that we used an `if` statement within a `for` loop. It is very common to \"mix-and-match\" various control tools in programming, such as using a `while` loop inside an `if` statement or using a `for` loop inside a `while` loop. This is known as a _nested_ control statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful keyword for loops is the `continue` keyword. When we use `continue`, the _rest_ of the loop _after_ the keyword is skipped for _one iteration_. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "i =  0 , j =  2\n",
      "I will be skipped over if j = 6\n",
      "\n",
      "i =  1 , j =  4\n",
      "I will be skipped over if j = 6\n",
      "\n",
      "i =  2 , j =  6\n",
      "\n",
      "i =  3 , j =  8\n",
      "I will be skipped over if j = 6\n",
      "\n",
      "i =  4 , j =  10\n",
      "I will be skipped over if j = 6\n"
     ]
    }
   ],
   "source": [
    "j = 0\n",
    "for i in range(5):\n",
    "    j += 2\n",
    "    print(\"\\ni = \", i, \", j = \", j)\n",
    "    if j == 6:\n",
    "        continue\n",
    "    print(\"I will be skipped over if j = 6\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When `j = 6`, the line after the `continue` keyword is skipped (i.e. not printed). Other than that, everything runs as per normal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try, Except"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This statement controls how the program proceeds when an error occurs. The syntax is as follows:\n",
    "\n",
    "`try:\n",
    "    do something\n",
    "except:\n",
    "    do something else when an error occurs`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An error occurred\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    answer = 12 / 0\n",
    "    print(answer)\n",
    "except:\n",
    "    print(\"An error occurred\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the program tries to excute the statement `answer = 12 / 0` in the `try` block, a divide-by-zero error occurs. The remaining of the `try` block is ignored and the statement in the `except` block is executed instead.\n",
    "\n",
    "If we want to display more specific error messages to users depending on the error, we can specify the error type after the `except` kewyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number: 12\n",
      "Please enter another number: 3\n",
      "The answer is  4.0\n",
      "Unknown error:  [Errno 2] No such file or directory: 'missing.txt'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    user_input1 = int(input(\"Please enter a number: \"))\n",
    "    user_input2 = int(input(\"Please enter another number: \"))\n",
    "    answer = user_input1 / user_input2\n",
    "    print(\"The answer is \", answer)\n",
    "    my_file = open(\"missing.txt\", \"r\")\n",
    "except ValueError:\n",
    "    print(\"Error: You did not enter a number\")\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: Cannot divide by zero\")\n",
    "except Exception as e:\n",
    "    print(\"Unknown error: \", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ValueError` and `ZeroDivisionError` are two of the many pre-defined error types in Python. `ValueError` is raised when a built-in operation or function receives a parameter that has the right type but an inappropriate value.\n",
    "\n",
    "Other common errors in Python include\n",
    "\n",
    "* `IndexError`: Raised when a sequence (e.g. string, list, tuple) index is out of range.\n",
    "* `KeyError`: Raised when a dictionary key is not found.\n",
    "* `TypeError`: Raised when an operation or function is applied to an object of inappropriate type.\n",
    "\n",
    "Python also comes with pre-defined error messages for each of the different types of errors. If we want to display the message, we use the `as` keyword after the error type. It is common practice to user `e` as the variable assigned to the error. The last `except` statement above is an example of using the pre-defined error message. It serves as a _final_ attempt to catch any unanticipated errors. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 7: Functions and Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To reiterate, all programming languages come with _built-in_ codes that we can use to make our lives easier as programmers. These codes consist of pre-written classes, variables and functions for performing certain common tasks and are saved in _files_ known as _modules_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What are Functions?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are simply **pre-written** codes that perform a certain task.\n",
    "\n",
    "Depending on how the function is written, whether it is part of a class and how we import it, we can call a function simply by typing the name of the function or _dot notation_. Some functions require us to pass data in for them to perform their tasks, known as parameters. We pass parameters to the function by _enclosing_ their values in parenthesis `()` separated by **commas**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Hellow Universe\n"
     ]
    }
   ],
   "source": [
    "## compare the following\n",
    "print(\"Hello World\")\n",
    "print(\"Hellow World\".replace(\"World\", \"Universe\")) # note that the string \"Hello World\" is affected"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining Your Own Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can define our own functions in Python and _reuse_ them throughout the program. The syntax for defining a function is as follows:\n",
    "\n",
    "`def function_name(parameters):\n",
    "    code detailing what the function should do\n",
    "    return [expression]`\n",
    "\n",
    "There are two keywords here: `def` and `return`.\n",
    "\n",
    "* `def` tells Python that the **_indented_** code from the _next line onwards_ is part of the function.\n",
    "* `return` is the keyword that we use to return an answer from the function. There can be more than one `return` statements in a function. However, once the function executes a `return` statement, the function will **exit**. If our function does not need to return any value, we can omit the `return` statement. Alternatively, we can write `return` or `return None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "def check_if_prime(number_to_check):\n",
    "    for x in range(2, number_to_check):\n",
    "        if number_to_check % x == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "answer = check_if_prime(13)\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An important concept to understand when defining a function is the variable scope. Variables defined inside a function are treated differently from those defined outside. There are two main differences:\n",
    "\n",
    "* Any variable declared _inside_ a function is only accessible _within_ the function, known as local variables.\n",
    "* Any variable declared outside a function is known as a global variable and is accessible anywhere in the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "INSIDE THE FUNCTION\n",
      "Global Variable\n",
      "Local Variable\n",
      "\n",
      "OUTSIDE THE FUNCTION\n",
      "Global Variable\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'message2' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-37-401b45464a43>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0;31m# Local variables are NOT accessible outside a function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmessage2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'message2' is not defined"
     ]
    }
   ],
   "source": [
    "message1 = \"Global Variable\"\n",
    "\n",
    "def my_function():\n",
    "    print(\"\\nINSIDE THE FUNCTION\")\n",
    "    # Global variables are accessible within a function\n",
    "    print(message1)\n",
    "    # Declare a local variable\n",
    "    message2 = \"Local Variable\"\n",
    "    print(message2)\n",
    "\n",
    "# Calling the function\n",
    "my_function()\n",
    "\n",
    "print(\"\\nOUTSIDE THE FUNCTION\")\n",
    "\n",
    "# Global variables are accessible outside a function\n",
    "print(message1)\n",
    "\n",
    "# Local variables are NOT accessible outside a function\n",
    "print(message2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Within the function, both local and global variables are accessible. Outside the function, the local variable `message2` is no longer accessible and we get a `NameError`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second concept to understand about variable scope is that if a local variable shares the same name as a global variable, any code _inside_ the function is accessing the _local_ variable. Any code _outside_ is accessing the _global_ variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "INSIDE THE FUNCTION\n",
      "Local Variable (shares same name as a global variable)\n",
      "\n",
      "OUTSIDE THE FUNCTION\n",
      "Global Variable (shares same name as a local variable)\n"
     ]
    }
   ],
   "source": [
    "message1 = \"Global Variable (shares same name as a local variable)\"\n",
    "\n",
    "def my_function2():\n",
    "    message1 = \"Local Variable (shares same name as a global variable)\"\n",
    "    print(\"\\nINSIDE THE FUNCTION\")\n",
    "    print(message1)\n",
    "    \n",
    "# Calling the function\n",
    "my_function2()\n",
    "\n",
    "# Print message1 OUTSIDE the function\n",
    "print(\"\\nOUTSIDE THE FUNCTION\")\n",
    "print(message1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python comes with a large number of built-in functions. These functions are _saved_ in **_files_** known as _modules_. To use the built-in codes in Python modules, we have to import them into our programs first via the `import` keyword. There are three ways to do this:\n",
    "\n",
    "1. Import the _entire_ module by writing `import module_name`.\n",
    "2. If it is too troublesome to write the entire module name each time we use the function, we can import the module and give it an alias, e.g. `import module_name as m` (where `m` is any name of our choice). \n",
    "3. Import specific functions from a module by writing `from module_name import name1[, name2[, ... nameN]]`. If we want to import more than one functions, we separate them with **commas**. To use the functions, we do not have to use the dot notation anymore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "random.randrange(1, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random as r\n",
    "\n",
    "r.randrange(1, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "from random import randrange, randint\n",
    "\n",
    "# do not have to use the dot notation\n",
    "print(randrange(1, 10))\n",
    "print(randint(1, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating our Own Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides importing built-in modules, we can also create our own modules. This is very useful if we have some functions that we'd like to **reuse** in other projects.\n",
    "\n",
    "Creating a module is simple: simply save the file with a `.py` extension and put it under the same folder as the Python file that references it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "import prime as prm\n",
    "answer = prm.check_if_prime(13)\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the module file (`.py`) is not in the same folder as the target Python file, we need to add the following code to the top of the target."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "if '/home/jerry/Dropbox/Self-study/python/lpodliw/mypymodules' not in sys.path:\n",
    "    sys.path.append('/home/jerry/Dropbox/Self-study/python/lpodliw/mypymodules')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sys.path` refers to Python's system path that is the list of directories that Python goes through to search for modules and files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 8: Working with Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opening and Reading Text Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learn Python in One Day and Learn It Well\n",
      "\n",
      "Python for Beginners with Hands-on Project\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f = open(\"myfile.txt\", \"r\")\n",
    "\n",
    "firstline = f.readline()\n",
    "secondline = f.readline()\n",
    "\n",
    "print(firstline)\n",
    "print(secondline)\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we can read from any file, we have to open it (just like any physical books). The `open()` function does this and requires two parameters:\n",
    "\n",
    "* file path\n",
    "* mode\n",
    "\n",
    "The commonly used modes are\n",
    "\n",
    "* `r`: read only.\n",
    "* `w`: write only. If the specified file does not exist, it will be created. If the file exists, any existing data on the file will be erased.\n",
    "* `a`: append. If the specified file does not exist, it will be created. If the file exists, any data written to the file is automatically added to the end.\n",
    "* `r+`: both reading and writing.\n",
    "\n",
    "_Each_ time the `readline()` function is called, it reads a _new_ line from the file.\n",
    "\n",
    "Notice that a line break is inserted after _each_ line. This is because the `readline()` function adds the `\\n` characters to the end of each line. If we do not want the extra line between each line of the text, we can do `print(firstline, end = '')`. This will remove the `\\n` characters.\n",
    "\n",
    "We should always close the file once we are done with reading it to free up any system resources."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learn Python in One Day and Learn It Well\n",
      "Python for Beginners with Hands-on Project\n"
     ]
    }
   ],
   "source": [
    "print(firstline, end = '')\n",
    "print(secondline,end = '')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using a For Loop to Read Text Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to using the `readline()` method, we can also use a `for` loop. In fact, the `for` loop is more elegant and efficient way to read text files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learn Python in One Day and Learn It Well\n",
      "Python for Beginners with Hands-on Project\n",
      "The only book you need to start coding in Python immediately\n",
      "http://www.learncodingfast.com/python\n"
     ]
    }
   ],
   "source": [
    "f = open(\"myfile.txt\", \"r\")\n",
    "\n",
    "# the for loop loops through the text file line by line.\n",
    "for line in f:\n",
    "    print(line, end = '')\n",
    "    \n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing to a Text File"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To avoid erasing the existing content in the sample file, we'll use the `a` (append) mode below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learn Python in One Day and Learn It Well\n",
      "Python for Beginners with Hands-on Project\n",
      "The only book you need to start coding in Python immediately\n",
      "http://www.learncodingfast.com/python\n",
      "\n",
      "This sentence will be appended.\n",
      "Python is Fun!"
     ]
    }
   ],
   "source": [
    "f = open(\"myfile.txt\", \"a\")\n",
    "\n",
    "f.write(\"\\nThis sentence will be appended.\")\n",
    "f.write(\"\\nPython is Fun!\")\n",
    "\n",
    "f.close()\n",
    "\n",
    "f = open(\"myfile.txt\", \"r\")\n",
    "\n",
    "for line in f:\n",
    "    print(line, end = \"\")\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opening and Reading Text Files by Buffer Size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, we may want to read a file by buffer size so that our program does not use too much memory resources. To do this, we can use the `read()` function (instead of the `readline()` function) that allows us to specify the buffer size to read."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learn Python in One Day and Learn It Well\n",
      "Python for Beginners with Hands-on Project\n",
      "The only book you need to start coding in Python immediately\n",
      "http://www.learncodingfast.com/python\n",
      "\n",
      "This sentence will be appended.\n",
      "Python is Fun!"
     ]
    }
   ],
   "source": [
    "input_file = open(\"myfile.txt\", \"r\")\n",
    "output_file = open(\"myoutputfile.txt\", \"w\")\n",
    "\n",
    "buffer_size = 10 # 10 bytes at a time\n",
    "\n",
    "msg = input_file.read(buffer_size)\n",
    "\n",
    "while len(msg):\n",
    "    output_file.write(msg)\n",
    "    msg = input_file.read(buffer_size)\n",
    "    \n",
    "input_file.close()\n",
    "output_file.close()\n",
    "\n",
    "f = open(\"myoutputfile.txt\", \"r\")\n",
    "for line in f:\n",
    "    print(line, end = \"\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The condition `while len(msg):` checks the length of the variable `msg`. As long as the length is not zero, the loop continues to run.\n",
    "\n",
    "To show that only 10 bytes were read at at time, we modify the above code slightly. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learn Pyth\n",
      "on in One \n",
      "Day and Le\n",
      "arn It Wel\n",
      "l\n",
      "Python f\n",
      "or Beginne\n",
      "rs with Ha\n",
      "nds-on Pro\n",
      "ject\n",
      "The o\n",
      "nly book y\n",
      "ou need to\n",
      " start cod\n",
      "ing in Pyt\n",
      "hon immedi\n",
      "ately\n",
      "http\n",
      "://www.lea\n",
      "rncodingfa\n",
      "st.com/pyt\n",
      "hon\n",
      "\n",
      "This \n",
      "sentence w\n",
      "ill be app\n",
      "ended.\n",
      "Pyt\n",
      "hon is Fun\n",
      "!\n"
     ]
    }
   ],
   "source": [
    "input_file = open(\"myfile.txt\", \"r\")\n",
    "output_file = open(\"myoutputfile2.txt\", \"w\")\n",
    "\n",
    "buffer_size = 10 # 10 bytes at a time\n",
    "\n",
    "msg = input_file.read(buffer_size)\n",
    "\n",
    "while len(msg):\n",
    "    output_file.write(msg + \"\\n\")\n",
    "    msg = input_file.read(buffer_size)\n",
    "    \n",
    "input_file.close()\n",
    "output_file.close()\n",
    "\n",
    "f = open(\"myoutputfile2.txt\", \"r\")\n",
    "for line in f:\n",
    "    print(line, end = \"\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opening, Reading and Writing Binary Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Binary files refer to any files that contain _non-text_ such as images or videos. To work with binary files, we simply use the `rb` or `wb` mode. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "input_file = open(\"myimage.jpg\", \"rb\")\n",
    "output_file = open(\"myoutputimage.jpg\", \"wb\")\n",
    "\n",
    "buffer_size = 10 # 10 bytes at a time\n",
    "\n",
    "msg = input_file.read(buffer_size)\n",
    "\n",
    "while len(msg):\n",
    "    output_file.write(msg)\n",
    "    msg = input_file.read(buffer_size)\n",
    "    \n",
    "input_file.close()\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deleting and Renaming Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two other useful functions when working with files are `remove()` and `rename()` functions. These functions are available in the `os` module and have to be imported before using them:\n",
    "\n",
    "* `remove(filename)`\n",
    "* `rename(old_name, new_name)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "# os.rename(\"myoutputfile2.txt\", \"myrenamedfile.txt\")\n",
    "os.rename(\"myrenamedfile.txt\", \"myoutputfile2.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 280\r\n",
      "-rw-r--r-- 1 jerry jerry 76023 Jan  2 11:47 mynotes.ipynb\r\n",
      "-rw-r--r-- 1 jerry jerry 73611 Jan  2 11:37 myoutputimage.jpg\r\n",
      "-rw-r--r-- 1 jerry jerry 73611 Jan  2 11:34 myimage.jpg\r\n",
      "-rw-r--r-- 1 jerry jerry   255 Jan  2 11:31 myoutputfile2.txt\r\n",
      "-rw-r--r-- 1 jerry jerry   231 Jan  2 11:28 myoutputfile.txt\r\n",
      "-rw-r--r-- 1 jerry jerry   231 Jan  2 11:18 myfile.txt\r\n",
      "drwxr-xr-x 2 jerry jerry  4096 Jan  2 10:51 mypymodules\r\n",
      "drwxr-xr-x 2 jerry jerry  4096 Jan  2 10:46 __pycache__\r\n",
      "-rw-r--r-- 1 jerry jerry   155 Jan  2 10:46 prime.py\r\n"
     ]
    }
   ],
   "source": [
    "# os.system('ls')\n",
    "!ls -lt"
   ]
  }
 ],
 "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.5.2+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}