04_Flow_Control.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Flow Control\n",
    "\n",
    "[Python 3 Tutorial](https://docs.python.org/3.6/tutorial/controlflow.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `if` Statements\n",
    "\n",
    "Learning Outcome:\n",
    "* if... elif... else\n",
    "\n",
    "\n",
    "[P5-6 Academic Grading in Singapore](https://en.wikipedia.org/wiki/Academic_grading_in_Singapore)\n",
    "\n",
    "* A*: 91% and above\n",
    "* A: 75% to below 91%\n",
    "* B: 60% to below 75%\n",
    "* C: 50% to below 60%\n",
    "* D: 35% to below 50%\n",
    "* E: 20% to below 35%\n",
    "* U: Below 20%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter raw scores: 55\n",
      "C\n"
     ]
    }
   ],
   "source": [
    "result = int(input(\"Please enter raw scores: \"))\n",
    "\n",
    "if result >= 91:\n",
    "    print(\"A*\")\n",
    "elif result >= 75:    # else if. elif is optional\n",
    "    print(\"A\")\n",
    "elif result >= 60:\n",
    "    print(\"B\")\n",
    "elif result >= 50:\n",
    "    print(\"C\")\n",
    "elif result >= 35:\n",
    "    print(\"D\")\n",
    "elif result >= 20:\n",
    "    print(\"E\")\n",
    "else:                 # else is options\n",
    "    print(\"U\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for` Statements\n",
    "\n",
    "Learning Outcomes:\n",
    "* Python’s for statement iterates over the items of any sequence (a list or a string), in the order that they appear in the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_collection = ['apple', 'orange', 'guava', 'durian', 'rambutan']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple 5 APPLE\n",
      "orange 6 ORANGE\n",
      "guava 5 GUAVA\n",
      "durian 6 DURIAN\n",
      "rambutan 8 RAMBUTAN\n"
     ]
    }
   ],
   "source": [
    "for f in fruit_collection:\n",
    "    print(f, len(f), f.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `range()` Function\n",
    "\n",
    "Learning Outcomes:\n",
    "* Generates arithmetic progressions\n",
    "\n",
    "iterate over a sequence of numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-4\n",
      "-2\n",
      "0\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(-4, 4, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_collection = ['apple', 'orange', 'guava', 'durian', 'rambutan']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 apple\n",
      "1 orange\n",
      "2 guava\n",
      "3 durian\n",
      "4 rambutan\n"
     ]
    }
   ],
   "source": [
    "fruit_collection\n",
    "for i in range(len(fruit_collection)):\n",
    "    print(i, fruit_collection[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Definition](http://book.pythontips.com/en/latest/enumerate.html) Emumnerate allows us to loop over iterable items and generates an automatic counter. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 apple\n",
      "1 orange\n",
      "2 guava\n",
      "3 durian\n",
      "4 rambutan\n"
     ]
    }
   ],
   "source": [
    "for k, v in enumerate(fruit_collection):\n",
    "    print(k, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`range()` is an *iterable* object. \n",
    "\n",
    "`for` statement is an *iterator*\n",
    "\n",
    "`list` is another example of an *iterator*\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 4)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'orange', 'guava', 'durian', 'rambutan']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(fruit_collection)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `break`, and `continue` Statements, and  `else` Clauses on Loops\n",
    "\n",
    "Learning Outcomes:\n",
    "* The break statement, breaks out of the innermost enclosing `for` or `while` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_collection = ['apple', 'orange', 'guava', 'durian', 'rambutan']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "love this fruit --> apple\n",
      "love this fruit --> orange\n",
      "love this fruit --> guava\n",
      "Found the smelly fruit!!! --> durian\n"
     ]
    }
   ],
   "source": [
    "for f in fruit_collection:\n",
    "    if f == 'durian':\n",
    "        print(\"Found the smelly fruit!!! -->\", f)\n",
    "        break\n",
    "    else:\n",
    "        print(\"love this fruit -->\", f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the `break` statement is related to the `for` statement and not `if` statement "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Just another number 2\n",
      "Found a number divisible by 3 --> 3\n",
      "Just another number 4\n",
      "Just another number 5\n",
      "Found a number divisible by 3 --> 6\n",
      "Just another number 7\n",
      "Just another number 8\n",
      "Found a number divisible by 3 --> 9\n"
     ]
    }
   ],
   "source": [
    "for n in range(2, 10):\n",
    "    if n % 3 == 0:\n",
    "        print(\"Found a number divisible by 3 -->\", n)\n",
    "        continue    # continue inform the for loop to continue with the next item.\n",
    "    print(\"Just another number\", n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `pass` Statements\n",
    "\n",
    "Learning Outcomes:\n",
    "* The pass statement does nothing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-1d3815b702a0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32mpass\u001b[0m  \u001b[0;31m# Busy-wait for keyboard interrupt (Ctrl+C)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    pass  # Busy-wait for keyboard interrupt (Ctrl+C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "as place holder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_random(object):\n",
    "    pass    # to implement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "calculate_random(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining Functions\n",
    "\n",
    "[Link](https://docs.python.org/3.6/tutorial/controlflow.html#defining-functions)\n",
    "\n",
    "\n",
    "Learning Outcomes:\n",
    "* conventions about the content and formatting of documentation strings (doc string).\n",
    "* The first line should always be a short, concise summary of the object’s purpose.\n",
    "\n",
    "[Real Life Example](https://github.com/quantopian/zipline/blob/master/zipline/finance/slippage.py)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square_fn(obj):\n",
    "    \"\"\"\n",
    "    This is the doc string\n",
    "    \n",
    "    This function squares the input.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    obj: float\n",
    "        Input number.\n",
    "    \n",
    "    Returns\n",
    "    ----------\n",
    "    square float\n",
    "        Squared number\n",
    "    \"\"\"\n",
    "    return obj * obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keyword `def` introduces a function `definition`. It must be followed by the function name and the parenthesized list of formal parameters. The statements that form the body of the function start at the next line, and must be indented.\n",
    "\n",
    "The `first` statement of the function body can optionally be a string literal; this string literal is the function’s documentation string, or `docstring`. (More about docstrings can be found in the section [Documentation Strings](https://docs.python.org/3.6/tutorial/controlflow.html#tut-docstrings).) There are tools which use docstrings to automatically produce online or printed documentation, or to let the user interactively browse through code; it’s good practice to include docstrings in code that you write, so make a habit of it.\n",
    "\n",
    "The `execution` of a function introduces a new symbol table used for the local variables of the function. More precisely, all variable assignments in a function store the value in the local symbol table; whereas variable references first look in the local symbol table, then in the local symbol tables of enclosing functions, then in the global symbol table, and finally in the table of built-in names. Thus, global variables cannot be directly assigned a value within a function (unless named in a [global](https://docs.python.org/3.6/reference/simple_stmts.html#global) statement), although they may be referenced.\n",
    "\n",
    "The actual parameters (arguments) to a function call are introduced in the local symbol table of the called function when it is called; thus, arguments are passed using `call by value` (where the value is always an object `reference`, not the value of the object). When a function calls another function, a new local symbol table is created for that call.\n",
    "\n",
    "A function definition introduces the function name in the current symbol table. The value of the function name has a type that is recognized by the interpreter as a user-defined function. This value can be assigned to another name which can then also be used as a function. This serves as a general renaming mechanism:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_fn(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.square_fn>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "sf = square_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sf(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "square_fn() takes 1 positional argument but 2 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-27-de2d600c4635>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: square_fn() takes 1 positional argument but 2 were given"
     ]
    }
   ],
   "source": [
    "sf(4, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib2(n):  # return Fibonacci series up to n\n",
    "    \"\"\"Return a list containing the Fibonacci series up to n.\"\"\"\n",
    "    result = []\n",
    "    a, b = 0, 1\n",
    "    while a < n:\n",
    "        result.append(a)    # see below\n",
    "        a, b = b, a + b\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "f100 = fib2(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "f100.append(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 100]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some new Python features:\n",
    "\n",
    "* The `return` statement returns with a value from a function. `return` without an expression argument returns `None`. Falling off the end of a function also returns `None`.\n",
    "\n",
    "* The statement `result.append(a)` calls a `method` of the list object `result`. A method is a function that ‘belongs’ to an object and is named `obj.methodname`, where `obj` is some object (this may be an expression), and `methodname` is the name of a method that is defined by the object’s type. Different types define different methods. Methods of different types may have the same name without causing ambiguity. (It is possible to define your own object types and methods, using classes, see [Classes](https://docs.python.org/3.6/tutorial/classes.html#tut-classes)) The method `append()` shown in the example is defined for list objects; it adds a new element at the end of the list. In this example it is equivalent to `result = result + [a]`, but more efficient."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More on Defining function\n",
    "\n",
    "[Link](https://docs.python.org/3.6/tutorial/controlflow.html#more-on-defining-functions)\n",
    "\n",
    "Define functions with a variable number of arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default Argument Values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most useful form is to specify a default value for one or more arguments. This creates a function that can be called with fewer arguments than it is defined to allow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def car_color(color='red'):\n",
    "    print(color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red\n"
     ]
    }
   ],
   "source": [
    "car_color()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blue\n"
     ]
    }
   ],
   "source": [
    "car_color(color='blue')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: The default values are evaluated at the point of function definition in the defining scope, so that"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_color = 'green'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def water_color(arg = my_color):\n",
    "    print(arg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_color = 'orange'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "green\n"
     ]
    }
   ],
   "source": [
    "water_color()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important warning**: The default value is evaluated only once. This makes a difference when the default is a mutable object such as a list, dictionary, or instances of most classes. For example, the following function accumulates the arguments passed to it on subsequent calls:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[1, 2]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "def f(a, L=[]):\n",
    "    L.append(a)\n",
    "    return L\n",
    "\n",
    "print(f(1))\n",
    "print(f(2))\n",
    "print(f(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you don’t want the default to be shared between subsequent calls, you can write the function like this instead:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[2]\n",
      "[3]\n"
     ]
    }
   ],
   "source": [
    "def f(a, L=None):\n",
    "    if L is None:\n",
    "        L = []\n",
    "    L.append(a)\n",
    "    return L\n",
    "\n",
    "print(f(1))\n",
    "print(f(2))\n",
    "print(f(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyword Arguments\n",
    "\n",
    "Functions can also be called using keyword arguments of the form `kwarg=value`. For instance, the following function:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parrot(a, b = 'plant', c = 'cat', d = 'red'):\n",
    "    print(\"The first argument is \", a)\n",
    "    print(\"animals versus \", b)\n",
    "    print(\"Computer vision comparing dogs versus \", c)\n",
    "    print(\"The sky is \", d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "accepts one required argument (`a`) and three optional arguments (`b`, `c`, and `d`). This function can be called in any of the following ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first argument is  100\n",
      "animals versus  plant\n",
      "Computer vision comparing dogs versus  cat\n",
      "The sky is  red\n"
     ]
    }
   ],
   "source": [
    "parrot(100)    # 1 positional argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first argument is  2\n",
      "animals versus  plant\n",
      "Computer vision comparing dogs versus  cat\n",
      "The sky is  red\n"
     ]
    }
   ],
   "source": [
    "parrot(a = 2)    # 1 keyword argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first argument is  9\n",
      "animals versus  bacteria\n",
      "Computer vision comparing dogs versus  cat\n",
      "The sky is  red\n"
     ]
    }
   ],
   "source": [
    "parrot(a = 9, b = 'bacteria')    # 2 keyword arguments "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first argument is  purple\n",
      "animals versus  plant\n",
      "Computer vision comparing dogs versus  pet\n",
      "The sky is  red\n"
     ]
    }
   ],
   "source": [
    "parrot(c = 'pet', a = 'purple')    # 2 keyword arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first argument is  1\n",
      "animals versus  2\n",
      "Computer vision comparing dogs versus  3\n",
      "The sky is  red\n"
     ]
    }
   ],
   "source": [
    "parrot(1, 2, 3)    # 3 positional arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first argument is  headache\n",
      "animals versus  plant\n",
      "Computer vision comparing dogs versus  cat\n",
      "The sky is  biscuit\n"
     ]
    }
   ],
   "source": [
    "parrot('headache', d = 'biscuit')    # 1 positional, 1 keyword"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "all the following calls would be invalid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "parrot() missing 1 required positional argument: 'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-50-0edccc34e86b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mparrot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m    \u001b[0;31m# required argument missing\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: parrot() missing 1 required positional argument: 'a'"
     ]
    }
   ],
   "source": [
    "parrot()    # required argument missing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (<ipython-input-51-50d8d9f1d080>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-51-50d8d9f1d080>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    parrot(a='6', 'what')   # non-keyword argument after a keyword argument\u001b[0m\n\u001b[0m                 ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "parrot(a='6', 'what')   # non-keyword argument after a keyword argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "parrot() got multiple values for argument 'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-52-3a05b3b386de>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mparrot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m     \u001b[0;31m# duplicate value for the same argument\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: parrot() got multiple values for argument 'a'"
     ]
    }
   ],
   "source": [
    "parrot(6, a=6)     # duplicate value for the same argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "parrot() got multiple values for argument 'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-53-b4b31b13d61b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mparrot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m)\u001b[0m     \u001b[0;31m# duplicate value for the same argument\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: parrot() got multiple values for argument 'a'"
     ]
    }
   ],
   "source": [
    "parrot(6, a=7)     # duplicate value for the same argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "parrot() got an unexpected keyword argument 'movie'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-54-0bac53f578e8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mparrot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmovie\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'LA LA Land'\u001b[0m\u001b[0;34m)\u001b[0m     \u001b[0;31m# unknown keyword argument\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: parrot() got an unexpected keyword argument 'movie'"
     ]
    }
   ],
   "source": [
    "parrot(movie='LA LA Land')     # unknown keyword argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a function call, **keyword arguments must follow positional arguments**. No argument may receive a value more than once. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a final formal parameter of the form `**name` is present, it receives a **dictionary** containing all **keyword arguments** except for those corresponding to a formal parameter. This may be combined with a formal parameter of the form `*name` which receives a **tuple** containing the **positional arguments** beyond the formal parameter list. (`*name` must occur before `**name`.) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def long_list(fruit, *tropic, **temperate):\n",
    "    print(fruit)\n",
    "    print(40 * \"*\")\n",
    "    print(\"[INFO] This is in *tropic \")\n",
    "    for t in tropic:\n",
    "        print(t)\n",
    "    print(40 * \"*\")        \n",
    "    print(\"[INFO] This is in **temperate\")\n",
    "    for kw in temperate:\n",
    "        print(kw, \":\", temperate[kw])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fruits\n",
      "****************************************\n",
      "[INFO] This is in *tropic \n",
      "banana\n",
      "mango\n",
      "****************************************\n",
      "[INFO] This is in **temperate\n",
      "Australia : Orange\n",
      "US : Sunkist\n"
     ]
    }
   ],
   "source": [
    "long_list(\"fruits\", \"banana\", \"mango\", Australia=\"Orange\", US=\"Sunkist\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the order in which the keyword arguments are printed is guaranteed to match the order in which they were provided in the function call."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unpacking Argument Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(3, 6))    # normal call with separate arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "args = [3, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(*args))    # call with arguments unpacked from a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda Expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "sqrt = lambda m, n : m ** (1 / n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(4, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sqrt_func(m, n):\n",
    "    return m ** (1 / n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt_func(4, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Documentation Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The first line should always be a short, concise summary of the object’s purpose. For brevity, it should not explicitly state the object’s name or type, since these are available by other means. This line should begin with a capital letter and end with a period.\n",
    "\n",
    "* The second line should be blank, visually separating the summary from the rest of the description. The following lines should be one or more paragraphs describing the object’s calling conventions, its side effects, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_func():\n",
    "    \"\"\"This function states my love for Singapore.\n",
    "    \n",
    "    That's all it says. Really.\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This function states my love for Singapore.\n",
      "    \n",
      "    That's all it says. Really.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(my_func.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_func():\n",
    "    \"\"\"\n",
    "    This function states my love for Singapore.\n",
    "    \n",
    "    That's all it says. Really.\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    This function states my love for Singapore.\n",
      "    \n",
      "    That's all it says. Really.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(my_func.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the different indentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coding Style"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you are about to write longer, more complex pieces of Python, it is a good time to talk about coding style. Most languages can be written (or more concise, formatted) in different styles; some are more readable than others. Making it easy for others to read your code is always a good idea, and adopting a nice coding style helps tremendously for that.\n",
    "\n",
    "For Python, [PEP 8](https://www.python.org/dev/peps/pep-0008/) has emerged as the style guide that most projects adhere to; it promotes a very readable and eye-pleasing coding style. Every Python developer should read it at some point; here are the most important points extracted for you:\n",
    "\n",
    "* Use 4-space indentation, and no tabs.\n",
    "\n",
    "* 4 spaces are a good compromise between small indentation (allows greater nesting depth) and large indentation (easier to read). Tabs introduce confusion, and are best left out.\n",
    "\n",
    "* Wrap lines so that they don’t exceed 79 characters.\n",
    "\n",
    "* This helps users with small displays and makes it possible to have several code files side-by-side on larger displays.\n",
    "\n",
    "* Use blank lines to separate functions and classes, and larger blocks of code inside functions.\n",
    "\n",
    "* When possible, put comments on a line of their own.\n",
    "\n",
    "* Use docstrings.\n",
    "\n",
    "* Use spaces around operators and after commas, but not directly inside bracketing constructs: `a = f(1, 2) + g(3, 4)`.\n",
    "\n",
    "* Name your classes and functions consistently; the convention is to use `CamelCase` for classes and `lower_case_with_underscores` for functions and methods. Always use `self` as the name for the first method argument (see [A First Look at Classes](https://docs.python.org/3.6/tutorial/classes.html#tut-firstclasses) for more on classes and methods).\n",
    "\n",
    "* Don’t use fancy encodings if your code is meant to be used in international environments. Python’s default, UTF-8, or even plain ASCII work best in any case.\n",
    "\n",
    "* Likewise, don’t use non-ASCII characters in identifiers if there is only the slightest chance people speaking a different language will read or maintain the code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References:\n",
    "\n",
    "* [Python Tutorial](https://docs.python.org/3.6/tutorial/index.html)\n",
    "* [Geeks for Geeks](https://www.geeksforgeeks.org/python/)\n",
    "* [Python for Econometrics](https://www.kevinsheppard.com/Python_for_Econometrics)\n",
    "* [Python Course](https://www.kevinsheppard.com/Python_Course)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6",
   "language": "python",
   "name": "python36"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}