1. Python Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basics\n",
    "***Disclaimer*** *-* *This document is only meant to serve as a reference for the attendees of the workshop. It does not cover all the concepts or implementation details discussed during the actual workshop. The content of this notebook was adapted from [Python Basics Workshop](https://github.com/SuyashLakhotia/IEEENTU-PythonBasics) and [Interactive Python](http://interactivepython.org)*\n",
    "\n",
    "### Python what?!\n",
    "\n",
    "- Python is a general purpose **programming language**. Other examples include Java, C, C++ etc.\n",
    "- It is known for its remarkable power coupled with readable *syntax*.\n",
    "    - The *syntax* of a programming language is the set of rules that defines the combinations of symbols that are considered to be correctly structured pieces of code. Think: Spelling & Grammar.\n",
    "- It is one of the easiest programming languages to learn but is also one of the most powerful languages, used heavily in Machine learning and Data Science.\n",
    "- Python code is executed line-by-line in a sequential fashion.\n",
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Syntax Simplicity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is an example of Python code.\n",
      "\n",
      "Enter a value for a: 10\n",
      "Enter a value for b: 20\n",
      "The sum of a & b is: 30\n"
     ]
    }
   ],
   "source": [
    "print(\"This is an example of Python code.\")\n",
    "print()\n",
    "a = int(input(\"Enter a value for a: \"))\n",
    "b = int(input(\"Enter a value for b: \"))\n",
    "print(\"The sum of a & b is: \" + str(a + b))  # print the sum of a & b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Statement:** Each line of code in a Python program is called a statement. Python interprets statements and runs them one by one.\n",
    "\n",
    "**Comments:** The `#` symbol indicates a comment and anything after `#` is ignored by the computer. Comments provide information to improve code readability.\n",
    "\n",
    "**Built-in Functions:** Python comes with many built-in functions like `print()` & `input()` to help you in writing your code.\n",
    "\n",
    "------\n",
    "\n",
    "## Variables\n",
    "\n",
    "### What are variables?\n",
    "\n",
    "Recall variables from algebra — `x = 5`. In programming, variables are used to store data temporarily to make it easier to refer to them. The value referred to by a variable can be updated as you execute the program using the *assignment operator* i.e. `=`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "a = 3       # simple assignment\n",
    "a = a + 1   # RHS is evaluated first\n",
    "print(a)    # 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are four basic data types in Python:\n",
    "\n",
    "1. **Integer -** Whole numbers. E.g. `1`, `123`, `89`\n",
    "2. **Float -** Floating decimal point numbers. E.g. `1.3`, `82.4`, `3.14159…`\n",
    "3. **String -** Sequence of characters. E.g. `a`, `abc`, `abc def`\n",
    "4. **Boolean -** Two possible values — `True` or `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 5\n",
    "b = 4.3\n",
    "c = \"Hello, world\"\n",
    "d = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to convert a variable from one type to another if the conversion is compatible. For example, converting `\"123\"` (string) to `123` (integer) is possible but `\"hello\"` cannot be converted to an integer.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "strA = \"123\"\n",
    "intA = int(strA)      # 123\n",
    "floatA = float(strA)  # 123.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two main built-in numeric classes that implement the integer and floating point data types.  \n",
    "These Python classes are called `int` and `float`.  \n",
    "   \n",
    "The standard arithmetic operations : `+, -, *, /, and **` (exponentiation), can be used with parentheses forcing the order of operations away from normal operator precedence.Other very useful operations are the remainder *modulo* operator, `%`, and *integer division*, `//`.   \n",
    "   \n",
    "**Note** : when two integers are divided, the result is a floating point. The integer division operator actually rounds down the number to the closest integer.(Note : Even with Negative number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n",
      "20\n",
      "1024\n",
      "2.0\n",
      "2.3333333333333335\n",
      "2\n",
      "-2\n",
      "1\n",
      "0.5\n",
      "0\n",
      "3\n",
      "1267650600228229401496703205376\n"
     ]
    }
   ],
   "source": [
    "print(2+3*4)    #14\n",
    "print((2+3)*4)  #20\n",
    "print(2**10)    #14\n",
    "print(6/3)      #2.0\n",
    "print(7/3)      #2.33333333333335\n",
    "print(7//3)     #2\n",
    "print(-5//4)    #-2\n",
    "print(7%3)      #1\n",
    "print(3/6)      #0.5\n",
    "print(3//6)     #0\n",
    "print(3%6)      #3\n",
    "print(2**100)   #1267650600228229401496703205376"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The boolean data type, implemented as the Python `bool` class, will be quite useful for representing truth values. The possible state values for a boolean object are `True` and `False` with the standard boolean operators, and, or, and not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(True)\n",
    "print(False)\n",
    "print(False or True)\n",
    "print(not (False or True))\n",
    "print(True and True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boolean data objects are also used as results for comparison operators such as equality `==` and greater than `>`. In addition, relational operators and logical operators can be combined together to form complex logical questions.   \n",
    "   \n",
    "|Operation Name|Operator|Explanation|\n",
    "|:-------------|:-------|:----------|\n",
    "|less than|`<`|Less than operator|\n",
    "|greater than|`>`|Greater than operator|\n",
    "|less than or equal|`<=`|Less than or equal to operator|\n",
    "|greater than or equal|`>=`|Greater than or equal to operator|\n",
    "|equal|`==`|Equality operator|\n",
    "|not equal|`!=`|Not equal operator|\n",
    "|logical and|`and`|Both operands True for result to be True|\n",
    "|logical or|`or`|One or the other operand is True for the result to be True|\n",
    "|logical not|`not`|Negates the truth value, False becomes True, True becomes False|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(5==10)\n",
    "print(10 > 5)\n",
    "print((5 >= 1) and (5 <= 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reassignment Operators\n",
    "Because increment and re-assign operation is very common, Python includes special operators for it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1780148\n"
     ]
    }
   ],
   "source": [
    "manila_pop = 1780148\n",
    "print(manila_pop)\n",
    "manila_pop += 1675 # increase the value of manila_pop by 1675\n",
    "manila_pop -= 250  # decrease the value of manila_pop by 250\n",
    "manila_pop *= 0.9  # decimate manila_pop\n",
    "manila_pop /=  2   # approximate the female population of Manila"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multiple assignment\n",
    "It is also possible to assign two variables on a single line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#These two assignments can be abbreviated\n",
    "savings = 514.86\n",
    "salary = 320.51\n",
    "\n",
    "#Using multiple assignment\n",
    "savings, salary = 514.86, 320.51"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "### Printing Variables\n",
    "\n",
    "In Python, we can print text onto the *console* using the `print()` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world\n",
      "5\n",
      "The value of 'a' is: 5\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, world\")\n",
    "\n",
    "a = 5\n",
    "print(a)\n",
    "print(\"The value of 'a' is: \" + str(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "### Getting User Input\n",
    "\n",
    "In Python, we can get input from the user and store this in variables using the `input()` function. The function prints whatever prompt is passed to it and waits for the user input. Once the `Enter` key is pressed, it stores the user input into the variable **as a string**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: Shantanu\n",
      "Shantanu\n",
      "Enter your age: 21\n",
      "21\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Enter your name: \")\n",
    "print(name)\n",
    "\n",
    "age = int(input(\"Enter your age: \"))\n",
    "print(age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "### Formatting Output\n",
    "\n",
    "We have already seen that the print function provides a very simple way to output values from a Python program. print takes zero or more parameters and displays them using a single blank as the default separator. It is possible to change the separator character by setting the `sep` argument. In addition, each print ends with a newline character by default. This behavior can be changed by setting the `end` argument. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hello World\n",
      "Hello***World\n",
      "Hello World***Next character will start after the ***\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello\")\n",
    "\n",
    "print(\"Hello\",\"World\")\n",
    "\n",
    "print(\"Hello\",\"World\", sep=\"***\")\n",
    "\n",
    "print(\"Hello\",\"World\", end=\"***\")\n",
    "print(\"Next character will start after the ***\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is often useful to have more control over the look of your output. Fortunately, Python provides us with an alternative called formatted strings. A formatted string is a template in which words or spaces that will remain constant are combined with placeholders for variables that will be inserted into the string. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shantanu is 21 years old.\n",
      "Shantanu is 21 years old.\n"
     ]
    }
   ],
   "source": [
    "print(name, \"is\", age, \"years old.\")\n",
    "print(\"%s is %d years old.\" % (name, age))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `%` operator is a string operator called the format operator. The left side of the expression holds the template or format string, and the right side holds a collection of values that will be substituted into the format string.   \n",
    "\n",
    "Note : the number of values in the collection on the right side corresponds with the number of `%` characters in the format string. Values are taken—in order, left to right—from the collection and inserted into the format string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Character|Output Format|\n",
    "|:--------|:------------|\n",
    "|d, i|Integer|\n",
    "|u|Unsigned integer|\n",
    "|f|Floating point as m.ddddd|\n",
    "|e|Floating point as m.ddddde+/-xx|\n",
    "|E|Floating point as m.dddddE+/-xx|\n",
    "|g|Use %e for exponents less than −4 or greater than +5, otherwise use %f|\n",
    "|c|Single character|\n",
    "|vs|String, or any Python data object that can be converted to a string by using the str function.|\n",
    "|%|Insert a literal % character|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to the format character, you can also include a format modifier between the % and the format character.   \n",
    "Format modifiers may be used to left-justify or right-justifiy the value with a specified field width.    \n",
    "Modifiers can also be used to specify the field width along with a number of digits after the decimal point."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Modifier|Example|Description|\n",
    "|:-------|:------|:----------|\n",
    "|number|%20d|Put the value in a field width of 20|\n",
    "|-|%-20d|Put the value in a field 20 characters wide, left-justified|\n",
    "|+|%+20d|Put the value in a field 20 characters wide, right-justified|\n",
    "|0|%020d|Put the value in a field 20 characters wide, fill in with leading zeros.|\n",
    "|.|%20.2f|Put the value in a field 20 characters wide with 2 characters to the right of the decimal point.|\n",
    "|(name)|%(name)d|Get the value from the supplied dictionary using name as the key.|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The banana costs 24 cents\n",
      "The     banana costs 24.00 cents\n",
      "The     banana costs      24.00 cents\n",
      "\n",
      "The banana costs    24.0 cents\n"
     ]
    }
   ],
   "source": [
    "price = 24\n",
    "item = \"banana\"\n",
    "print(\"The %s costs %d cents\"%(item,price))\n",
    "print(\"The %+10s costs %5.2f cents\"%(item,price))\n",
    "print(\"The %+10s costs %10.2f cents\"%(item,price))\n",
    "print()\n",
    "itemdict = {\"item\":\"banana\",\"cost\":24}\n",
    "print(\"The %(item)s costs %(cost)7.1f cents\"%itemdict)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python strings also include a `format` method that can be used in conjunction with a new `Formatter` class to implement complex string formatting. More about these features can be found in the Python library reference manual."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "### Arithmetic Operations\n",
    "\n",
    "Variables can be used to perform simple arithmetic operations. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 4\n",
    "b = 5\n",
    "c = a + b\t# addition\n",
    "d = a - b\t# subtraction\n",
    "e = a * b\t# multiplication\n",
    "f = a / b\t# division\n",
    "g = a % b\t# modulus (remainder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "### Strings\n",
    "\n",
    "Strings represent a sequence of one or more characters. Each character can be accessed separately using a zero-based index."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "~~~\n",
    "H  e  l  l  o  \n",
    "0  1  2  3  4\n",
    "~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e\n",
      "5\n",
      "Hello, world\n"
     ]
    }
   ],
   "source": [
    "s = \"Hello\"\n",
    "print(s[1])\n",
    "print(len(s))\n",
    "print(s + \", world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python comes with a lot of useful built-in *methods* for strings.**\n",
    "Some commons ones are listed below. You can find more at [String Methods](https://docs.python.org/3/library/stdtypes.html#string-methods)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Method Name|Use|Explanation|\n",
    "|:----------|:--|:----------|\n",
    "|center\t|astring.center(w)\t|Returns a string centered in a field of size w|\n",
    "|count\t|astring.count(item)|Returns the number of occurrences of item in the string|\n",
    "|ljust\t|astring.ljust(w)\t|Returns a string left-justified in a field of size w|\n",
    "|lower\t|astring.lower()\t|Returns a string in all lowercase|\n",
    "|rjust\t|astring.rjust(w)\t|Returns a string right-justified in a field of size w|\n",
    "|find\t|astring.find(item)\t|Returns the index of the first occurrence of item|\n",
    "|split\t|astring.split(schar)|Splits a string into substrings at schar|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "HELLO\n",
      "-1\n",
      "Hello\n",
      "  Hello   \n",
      "['H', 'llo']\n",
      "False\n",
      "Hello\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(s.lower())                   # returns lowercase version of string\n",
    "print(s.upper())                   # returns uppercase version of string\n",
    "print(s.find(\"abc\"))               # searches the string for \"abc\" and returns the first index where it begins or -1\n",
    "print(s.replace(\"old\", \"new\"))     # returns a string with all occurrences of \"old\" replaced with \"new\"\n",
    "print(s.center(10))                # returns the string centered in a 10 character space\n",
    "print(s.split('e'))                # returns the an array with the string characters split on the occurences of e\n",
    "print(s.islower())\n",
    "print(s.title())\n",
    "print(s.count(\"l\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to access a part of a string, Python allows you to *slice* the string using the start and end indices.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ell\n",
      "ello\n",
      "hel\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "s = \"hello\"\n",
    "print(s[1:4])   # \"ell\"\n",
    "print(s[1:])    # \"ello\"\n",
    "print(s[:3])    # \"hel\"\n",
    "print(s[:])     # \"hello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A major difference between lists and strings is that lists can be modified while strings cannot. This is referred to as mutability. Lists are mutable; strings are immutable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String formatting\n",
    "One particularly useful string method is format. The format method is used to construct strings by inserting values into template strings. Consider this example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Shantanu, Welome to coding with Python v3.6\n"
     ]
    }
   ],
   "source": [
    "name = \"Shantanu\"\n",
    "lang = \"Python\"\n",
    "ver = 3.6\n",
    "message = \"Hi {}, Welome to coding with {} v{}\".format(name, lang, ver)\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "### Lists\n",
    "\n",
    "Instead of variables holding individual values, it is also possible to create a list of values in Python. Each item in the list is called an *element* and can be accessed individually using a zero-based index.\n",
    "( For more information look into *Python Advanced* notebook. )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "2\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "listOfNums = [1, 2, 3, 4, 5]\n",
    "print(listOfNums)\n",
    "print(listOfNums[1])\n",
    "print(len(listOfNums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "### Tuples\n",
    "Tuples are very similar to lists in that they are heterogeneous sequences of data. The difference is that a tuple is immutable, like a string. A tuple cannot be changed. Tuples are written as comma-delimited values enclosed in parentheses. As sequences, they can use any operation described above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, True, 4.96)\n",
      "2\n",
      "(2, True, 4.96, 2, True, 4.96, 2, True, 4.96)\n",
      "(2, True)\n"
     ]
    }
   ],
   "source": [
    "myTuple = (2,True,4.96)\n",
    "print(myTuple)\n",
    "\n",
    "len(myTuple)\n",
    "print(myTuple[0])\n",
    "print(myTuple * 3)\n",
    "print(myTuple[0:2])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However if you try to change an element in a tuple you will get an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (Uncomment to see error. ) \n",
    "# myTuple[1]=False "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "### Sets\n",
    "A set is an unordered collection of zero or more immutable Python data objects. Sets do not allow duplicates and are written as comma-delimited values enclosed in curly braces. The empty set is represented by set(). Sets are heterogeneous, and the collection can be assigned to a variable as below. They are always unordered.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{False, 3, 'cat', 4.5, 6}\n",
      "{False, 3, 'cat', 4.5, 6}\n"
     ]
    }
   ],
   "source": [
    "# empty_set = set()\n",
    "mySet = {3,6,\"cat\",4.5,False}\n",
    "print(mySet)\n",
    "mySet = {\"cat\",3,3,False,3,3,6,6,6,6,\"cat\",\"cat\",4.5,False}\n",
    "print(mySet)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though sets are not considered to be sequential, they do support a few of the familiar operations presented earlier. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Operation Name|Operator|Explanation|\n",
    "|:-------------|--------|-----------|\n",
    "|membership|in|Set membership|\n",
    "|length|len|Returns the cardinality of the set|\n",
    "|&#124;|aset &#124; otherset|Returns a new set with all elements from both sets|\n",
    "|`&`|`aset & otherset`|Returns a new set with only those elements common to both sets|\n",
    "|`-`|`aset - otherset`|Returns a new set with all items from the first set not in second|\n",
    "|`<=`|`aset <= otherset`|Asks whether all elements of the first set are in the second|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets support a number of methods that should be familiar to those who have worked with them in a mathematics setting. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Method Name|Use|Explanation|\n",
    "|:----------|:--|:----------|\n",
    "|union|aset.union(otherset)|Returns a new set with all elements from both sets|\n",
    "|intersection|aset.intersection(otherset)|Returns a new set with only those elements common to both sets|\n",
    "|difference|aset.difference(otherset)|Returns a new set with all items from first set not in second|\n",
    "|issubset|aset.issubset(otherset)|Asks whether all elements of one set are in the other|\n",
    "|add|aset.add(item)|Adds item to the set|\n",
    "|remove|aset.remove(item)|Removes item from the set|\n",
    "|pop|aset.pop()|Removes an arbitrary element from the set|\n",
    "|clear|aset.clear()|Removes all elements from the set|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "### Dictionaries\n",
    "\n",
    "Dictionaries in Python allow you to store key-value pairs. Keys are unique within a dictionary while values may be repeated. For example, a dictionary of names (keys) and ages (values). Because the keys are unique, they are used as the index of the dictionary to access the values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "24\n",
      "{'Bob': 21, 'Jake': 24, 'John': 23, 'Jane': 23}\n",
      "{'Bob': 24, 'Jake': 24, 'John': 23, 'Jane': 23}\n",
      "dict_keys(['Bob', 'Jake', 'John', 'Jane'])\n",
      "dict_values([24, 24, 23, 23])\n"
     ]
    }
   ],
   "source": [
    "ages = {\"Bob\" : 21, \"Jake\" : 24, \"John\" : 23}\n",
    "print(ages[\"Bob\"])   # 21\n",
    "print(ages[\"Jake\"])  # 24\n",
    "\n",
    "ages[\"Jane\"] = 23\n",
    "print(ages)          # {\"Bob\" : 21, \"Jake\" : 24, \"John\" : 23, \"Jane\" : 23}\n",
    "\n",
    "ages[\"Bob\"] = 24\n",
    "print(ages)          # {\"Bob\" : 24, \"Jake\" : 24, \"John\" : 23, \"Jane\" : 23}\n",
    "\n",
    "print(ages.keys())   # dict_keys([\"Bob\", \"Jake\", \"John\", \"Jane\"])\n",
    "print(ages.values()) # dict_values([24, 24, 23, 23])\n",
    "\n",
    "# Accessing element that doesn't exist gives KeyError\n",
    "# print(ages[\"Rob\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### Handling the KeyError \n",
    "There are two ways to avoid the `KeyError` problem. Examples below:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob is already in dictionary.\n"
     ]
    }
   ],
   "source": [
    "if \"Bob\" in ages :\n",
    "    print(\"Bob is already in dictionary.\")\n",
    "else :\n",
    "    print(\"Bob is not in dictionary.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rob is not in dictionary.\n"
     ]
    }
   ],
   "source": [
    "if ages.get(\"Rob\") is None:\n",
    "    print(\"Rob is not in dictionary.\")\n",
    "else :\n",
    "    print(\"Rob is already in dictionary.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "## Control Flow\n",
    "\n",
    "While sequentially executing code can perform a lot of tasks for us, many tasks require some subtask to be repeated or selectively executed. For example, if we want to calculate the average age in a classroom:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What's your age? 12\n",
      "What's your age? 11\n",
      "What's your age? 10\n",
      "11.0\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "numOfStudents = 0\n",
    "\n",
    "studentAge = int(input(\"What's your age? \"))\n",
    "total = total + studentAge\n",
    "numOfStudents = numOfStudents + 1\n",
    "\n",
    "studentAge = int(input(\"What's your age? \"))\n",
    "total = total + studentAge\n",
    "numOfStudents = numOfStudents + 1\n",
    "\n",
    "studentAge = int(input(\"What's your age? \"))\n",
    "total = total + studentAge\n",
    "numOfStudents = numOfStudents + 1\n",
    "\n",
    "average = total / numOfStudents\n",
    "print(average)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repeating the same lines of code is tedious and limits the reusability & maintainability of the code. For example, in the above code, if we just wanted to change the user prompt to `Enter your age:` instead, we would have to change many lines of code.\n",
    "\n",
    "------\n",
    "### if Statements\n",
    "\n",
    "`if` statements are one of the most important control flow tools available in programming. They allow the program to dynamically choose which lines of code to execute depending on a particular condition.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "```python\n",
    "if <condition>:\n",
    "    # Statements here are executed if condition is True\n",
    "else:\n",
    "    # Statements here are executed if condition is False\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "if <conditionA>:\n",
    "    # Statements here are executed if conditionA is True\n",
    "elif <conditionB>:\n",
    "    # Statements here are executed if conditionA is False and conditionB is True\n",
    "else:\n",
    "    # Statements here are executed if conditionA and conditionB are False\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A colon marks the beginning of a *block* and statements within each *block* are indented so that they can be distinguished from each other.\n",
    "\n",
    "#### Condition\n",
    "\n",
    "Conditions are *boolean expressions* that return either `True` or `False`. They are made up of *relational operators* and *logical operators*.\n",
    "\n",
    "##### Relational Operators\n",
    "\n",
    "1. `==`: equals to\n",
    "2. `!=`: not equals to\n",
    "3. `<` : smaller than\n",
    "4. `>` : greater than\n",
    "5. `<=`: smaller than or equals to\n",
    "6. `>=`: greater than or equals to\n",
    "\n",
    "```python\n",
    "if x == y:\n",
    "    print(\"x & y are equal.\")\n",
    "else:\n",
    "    print(\"x & y are not equal.\")\n",
    "```\n",
    "\n",
    "##### Logical Operators\n",
    "\n",
    "1. `boolExpr1 and boolExpr2`: Both expressions have to be `True` for the entire expression to be `True`\n",
    "2. `boolExpr1 or boolExpr2`: Either one expression has to be `True` for the entire expression to be `True`\n",
    "3. `not boolExpr`: Inverts the return value of the expression\n",
    "\n",
    "```python\n",
    "if (x == y) and (y == z):\n",
    "    print(\"x, y & z are equal.\")\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "### Loops\n",
    "\n",
    "Loops in programming allow the same task to be executed repeatedly for a definite or indefinite number of times. They are made up of four main sections:\n",
    "\n",
    "1. **Initialize:** Initialize the loop control variable.\n",
    "2. **Test:** Continue the loop?\n",
    "3. **Loop Body:** Task being repeated.\n",
    "4. **Update:** Modify the loop control variable so that the next time we test, we *may* exit the loop.\n",
    "\n",
    "There are two main kinds of loops:\n",
    "\n",
    "1. **Counter Controlled:** The number of repetitions of the loop is known before the loop body starts executing.\n",
    "2. **Sentinel Controlled:** The number of repetitions of the loop is unknown before the loop body starts executing.\n",
    "\n",
    "#### while Loop\n",
    "\n",
    "A `while` loop executes while the given condition is `True` (i.e. until the given condition is `False`).\n",
    "\n",
    "```python\n",
    "while <condition>:\n",
    "    # Loop Body\n",
    "```\n",
    "\n",
    "For example, to print all the integers from 1 - 10:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "num = 1                 # Initialize\n",
    "while num <= 10:        # Test\n",
    "    print(num)          # Loop Body\n",
    "    num = num + 1       # Update"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of a sentinel controlled loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess a number from 1 - 10: 2\n",
      "Wrong! Guess a number from 1 - 10: 3\n",
      "Wrong! Guess a number from 1 - 10: 4\n",
      "Wrong! Guess a number from 1 - 10: 5\n",
      "Correct!\n"
     ]
    }
   ],
   "source": [
    "answer = 5\n",
    "guess = int(input(\"Guess a number from 1 - 10: \"))\n",
    "while guess != answer:\n",
    "    guess = int(input(\"Wrong! Guess a number from 1 - 10: \"))\n",
    "print(\"Correct!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### for Loop\n",
    "\n",
    "A `for` loop can be used to iterate through a list and perform tasks accordingly.\n",
    "\n",
    "```python\n",
    "for var in someList:\n",
    "    # Loop Body\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In every iteration of the loop, the `var` variable will be assigned the next value in the list. For example, the code below will print all the elements in the list in separate lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n",
      "4\n",
      "5\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "numList = [2, 1, 4, 5, 3]\n",
    "for num in numList:\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `for` loop can also be used to iterate through a dictionary:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob : 555-555\n",
      "Jake : 555-556\n",
      "John : 555-565\n",
      "Jane : 555-655\n"
     ]
    }
   ],
   "source": [
    "phoneBook = {\"Bob\" : \"555-555\", \"Jake\" : \"555-556\", \"John\" : \"555-565\", \"Jane\" : \"555-655\"}\n",
    "for name in phoneBook.keys():\n",
    "    print(name + \" : \" + phoneBook[name])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, a `for` loop can be used like a `while` loop with a definite number of repetitions using the `range()` function. The `range()` function returns a list of integers from 0 up till but not including the passed argument.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):  # range(5) returns [0, 1, 2, 3, 4]\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "## Functions\n",
    "\n",
    "Functions allow you to divide your code into chunks that do specific subtasks, which make your code more readable and reusable.\n",
    "\n",
    "```python\n",
    "# Define the function\n",
    "def functionName():\n",
    "    # Function Body\n",
    "\n",
    "functionName()  # Call the function\n",
    "```\n",
    "------\n",
    "### Parameters & Arguments\n",
    "\n",
    "Functions can be defined with *parameters*, which are essentially variables that are set when the function is called using *arguments*. This allows functions to be reused with different data values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "97\n"
     ]
    }
   ],
   "source": [
    "def sum(a, b):  # a & b are parameters\n",
    "    c = a + b\n",
    "    print(c)\n",
    "\n",
    "sum(3, 2)       # 3 & 2 are arguments\n",
    "sum(32, 65)     # 32 & 65 are arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "### Return Values\n",
    "\n",
    "Functions can also return values back to where the function was called so that the result can be further used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## def sum(a, b):\n",
    "    c = a + b\n",
    "    return c\n",
    "\n",
    "s = sum(1, 2)     # s is set to the value of c from sum()   \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Documenting functions\n",
    "One of the key advantages of functions is that they can help to break a program down into smaller chunks. This makes code easier to write, and also easier to read because they're reusable.\n",
    "Functions make code easier to read because they give human-readable names to processes. While the population density formula isn't that complicated, it is still harder to recognize than a precisely named function.\n",
    "There is one further technique for making functions more readable, documentation strings (also called \"docstrings\"). Docstrings are a type of comment used to explain the purpose of a function, and how it should be used. Here's the population_density function, with a docstring.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "non-default argument follows default argument (<ipython-input-1-f79ab7be92bc>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-f79ab7be92bc>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    def population_density(population=False, land_area):\u001b[0m\n\u001b[0m                          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m non-default argument follows default argument\n"
     ]
    }
   ],
   "source": [
    "def population_density(population=False, land_area):\n",
    "    \"\"\"Calculate the population density of an area.\n",
    "\n",
    "    population: int. The population of the area\n",
    "    land_area: int or float. This function is unit-agnostic, if you pass\n",
    "               in values in terms of square km or square miles the\n",
    "               function will return a density in those units.\n",
    "    \"\"\"\n",
    "    return population / land_area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Docstrings are surrounded by triple quotes, \"\"\". The first line of the docstring is a brief explanation of the function's purpose. If you feel that this is sufficient documentation you can end the docstring at this point, single line docstrings are perfectly acceptable. If you think that the function is complicated enough to warrant a longer description, you can add a more thorough paragraph after the one line summary.\n",
    "\n",
    "The next element of a docstring is an explanation of the function's arguments. Here you list the arguments, state their purpose, and what types the arguments should be.\n",
    "\n",
    "Each of these pieces of the docstring is optional, as is the docstring itself. Remember though, it's always easier to write code than to read it! If you can make things easier for your collaborators (which includes future you!) to read your code, then you should.\n",
    "\n",
    "You can read a more thorough explanation of docstring conventions at https://www.python.org/dev/peps/pep-0257/."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "### Default Arguments\n",
    "\n",
    "We can specify default values for arguments of a function. However, these arguments must be placed at the end of the argument list. To understand this useful flexibility that python provides lets look at the famous star box problem and modify it.   \n",
    "Starbox problem:  The function takes two arguments, width and height, that specify how many characters wide the box is and how many lines tall it is. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*****\n",
      "*   *\n",
      "*   *\n",
      "*   *\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "def box(width, height):\n",
    "    \"\"\"print a box made up of asterisks.\n",
    "\n",
    "    width: width of box in characters, must be at least 2\n",
    "    height: height of box in lines, must be at least 2\n",
    "    \"\"\"\n",
    "    print('*' * width) # print top edge of box\n",
    "\n",
    "    # print sides of box\n",
    "    for _ in range(height-2):\n",
    "        print('*' + \" \" * (width-2) + '*') \n",
    "\n",
    "    print('*' * width) # print bottom edge of box\n",
    "    \n",
    "box(5,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets now modify the problem to allow the box to be constructed by any symbol and if not specified use the asterisks. Do note the function definition now has a some new code in it. This signifies that if this argument is not provided use the default value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*****\n",
      "*   *\n",
      "*   *\n",
      "*   *\n",
      "*****\n",
      "!!!!!\n",
      "!   !\n",
      "!   !\n",
      "!   !\n",
      "!!!!!\n"
     ]
    }
   ],
   "source": [
    "def box(width, height, symbol='*'):\n",
    "    \"\"\"print a box made up of asterisks, or some other character.\n",
    "\n",
    "    width: width of box in characters, must be at least 2\n",
    "    height: height of box in lines, must be at least 2\n",
    "    symbol: a single character string used to draw the box edges\n",
    "    \"\"\"\n",
    "    print(symbol * width) # print top edge of box\n",
    "\n",
    "    # print sides of box\n",
    "    for _ in range(height-2):\n",
    "        print(symbol + \" \" * (width-2) + symbol) \n",
    "\n",
    "    print(symbol * width) # print bottom edge of box\n",
    "\n",
    "box(5,5)\n",
    "box(5,5,'!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "------\n",
    "### Mutable Default Arguments\n",
    "Default arguments are a helpful feature, but there is one situation where they can be surprisingly unhelpful. Using a mutable type (like a list or dictionary) as a default argument and then modifying that argument can lead to strange results. It's usually best to avoid using mutable default arguments: to see why, understand the example below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider this function which adds items to a todo list. Users can provide their own todo list, or add items to a default list:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Wake up', 'Brush teeth']\n",
      "['Wake up', 'Brush teeth', 'Snooze alarm and go back to sleep']\n"
     ]
    }
   ],
   "source": [
    "def todo_list(new_task, base_list=['Wake up']):\n",
    "    base_list.append(new_task)\n",
    "    return base_list\n",
    "print(todo_list('Brush teeth'))\n",
    "\n",
    "print(todo_list('Snooze alarm and go back to sleep'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above case you can see that the list is not re-initialised to hold the original value. This can prove troublesom in most cases.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}