Ch03-3-Functions-UserDefined.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.3 User-defined Functions\n",
    "<a href=\"https://colab.research.google.com/github/rambasnet/FDSPython-Notebooks/blob/master/Ch03-3-Functions-UserDefined.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
    "- http://openbookproject.net/thinkcs/python/english3e/functions.html\n",
    "\n",
    "## Topics\n",
    "- how to define and use your own functions\n",
    "- variables scopes\n",
    "- how to pass data to functions (by value and reference)\n",
    "- how to return data from functions\n",
    "- unit or functional testing with assert\n",
    "\n",
    "## 3.3.1 Functions\n",
    "- named sequence of statements that execute together to solve some task \n",
    "- primary purpose is to help us break the problem into smaller sub-problems or tasks\n",
    "- two types: fruitful and void/fruitless functions\n",
    "- must be defined before it can be used or called (two step process)\n",
    "\n",
    "- concept of function is burrowed from Algebra\n",
    "- e.g.\n",
    "\n",
    "    Let's say: $y = f(x) = x^2+x+1$\n",
    "    \n",
    "    $y = f(1) = 1+1+1 = 3$\n",
    "    \n",
    "    $y = f(-2) = 4-2+1 = 3$\n",
    "\n",
    "### Two-step process\n",
    "1. Define a function\n",
    "2. Call or use function\n",
    "\n",
    "### syntax to define function\n",
    "```python\n",
    "def functionName( PARAMETER1, PARAMETER2, ... ):\n",
    "    # STATEMENTS\n",
    "    return VALUE\n",
    "```\n",
    "- PARAMETERS and return statements are OPTIONAL\n",
    "- function NAME follows the same rules as a variable/identifier name\n",
    "- recall some built-in functions and object methods have been used in previous chapters...\n",
    "\n",
    "\n",
    "### syntax to call function\n",
    "- call function by its name\n",
    "- use return values if any\n",
    "\n",
    "```python\n",
    "VARIABLE = functionName( ARGUMENT1, ARGUMENT2, ...)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.2 Why functions?\n",
    "**dividing a program into functions or sub-programs have several advantages:**\n",
    "- give you an opportunity to name a group of statements, which makes your program easier to read and debug\n",
    "- can make a program smaller by eliminating repetitive code. Later, if you make a change, you only have to make it in one place\n",
    "- allow you to debug the parts one at a time (in a team) and then assemble them into a working whole\n",
    "- write once, test, share, and reuse many times (libraries, e.g.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.3 Types of functions\n",
    "- two types: fruitful and fruitless functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fruitless functions\n",
    "- also called void functions\n",
    "- they do not return a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Function definition\n",
    "# function prints the result but doesn't explictly return anything\n",
    "def greet():\n",
    "    print('Hello World!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "# Function call\n",
    "greet()\n",
    "greet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "a = None\n"
     ]
    }
   ],
   "source": [
    "# void/fruitless function; returns None by default\n",
    "a = greet() # returned value by greet() assigned to a\n",
    "print('a =', a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(greet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# function can be assigned to another identifier\n",
    "myfunc = greet\n",
    "type(myfunc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "myfunc()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fruitful functions\n",
    "- functions that explictly return some value(s) using **return** statement\n",
    "- more useful functions\n",
    "- answer returned can be used as intermediate values to solve bigger problems\n",
    "- can be used and tested independently\n",
    "- fruitful functions usually take some arguments and return value(s) as answer\n",
    "- most built-in and library functions are fruitful\n",
    "- typically return is the last statement to execute; but not necessarily\n",
    "- function returns back to the caller immidiately after return statement is executed\n",
    "    - will skip code if any exists after return statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fuitful function\n",
    "def getName():\n",
    "    name = input(\"Hi there, enter your full name: \")\n",
    "    return name\n",
    "    print(f'Hi {name}, nice meeting you!') # will not be executed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi there, enter your full name: John Smith\n"
     ]
    }
   ],
   "source": [
    "userName = getName()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.4 Passing data as arguments to functions\n",
    "- functions are subprograms that may need external data to work with\n",
    "- you can pass data to functions via parameters/arguments\n",
    "- can provide 1 or more parameters to pass 1 or more data\n",
    "- can provide default values to parameters\n",
    "    - makes the parameter optional when the function is called\n",
    "- if a function has a required parameter, data must be provided for each required parameter!\n",
    "    - otherwise, you'll get error!\n",
    "    \n",
    "### [Visualize with PythonTutor.com](http://pythontutor.com/visualize.html#code=def%20greet%28name%29%3A%0A%20%20%20%20print%28'Hello%20%7B%7D'.format%28name%29%29%0A%20%20%20%20%0Aprint%28'start'%29%0Agreet%28'John'%29%0Aprint%28'end'%29%0A&cumulative=false&curInstr=0&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# function takes one required argument\n",
    "def greet(name):\n",
    "    print(f'Hello {name}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello John Smith\n"
     ]
    }
   ],
   "source": [
    "# pass 'John Smith' literal value as an argument for name parameter\n",
    "greet('John Smith')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Jane\n"
     ]
    }
   ],
   "source": [
    "greet('Jane')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Michael Smith\n"
     ]
    }
   ],
   "source": [
    "# argument can be variables as well\n",
    "n = 'Michael Smith'\n",
    "greet(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: John Doe\n",
      "Hello John Doe\n"
     ]
    }
   ],
   "source": [
    "n1 = input('Enter your name: ')\n",
    "greet(n1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello asdfdasf\n"
     ]
    }
   ],
   "source": [
    "greet('asdfdasf') # How to fix? provide either default value or call it properly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# function takes one optional argument\n",
    "def greet(name=\"Anonymous\"):\n",
    "    print(f'Hello, {name}')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Anonymous\n"
     ]
    }
   ],
   "source": [
    "# calling greet without an argument\n",
    "# default value for name will be used!\n",
    "greet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, adfasd\n"
     ]
    }
   ],
   "source": [
    "greet('adfasd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: Jane Smith\n",
      "Hello, Jane Smith\n"
     ]
    }
   ],
   "source": [
    "user = input('Enter your name: ')\n",
    "greet(user) # calling greet with an argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.5 Scope of variables\n",
    "- variable scope tells Python where the variables are visible and can be used\n",
    "- not all the variables can be used everywhere after they're declared\n",
    "- Python provides two types of variables or scopes: global and local scopes\n",
    "\n",
    "### global scope\n",
    "- global variables\n",
    "- any variables/identifiers defined outside functions\n",
    "- can be readily accessed/used from within the functions\n",
    "- must use **global** keyword to update the global variables\n",
    "\n",
    "### local scope\n",
    "- local variables\n",
    "- the variables defined in a function have local scope\n",
    "- can be used/accessed only from within a function after it has been declared\n",
    "- parameter is also a local variable to the function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### global and local scopes demo\n",
    "#### Visualize it with [PythonTutor.com](http://pythontutor.com/visualize.html#code=%23%20Global%20and%20local%20scope%20demo%0Aname%20%3D%20%22Alice%22%0Adef%20someFunc%28a,%20b%29%3A%0A%20%20%20%20print%28'name%20%3D%20',%20name%29%0A%20%20%20%20name1%20%3D%20%22John%22%0A%20%20%20%20print%28'a%20%3D%20%7B%7D%20and%20b%20%3D%20%7B%7D'.format%28a,%20b%29%29%0A%20%20%20%20print%28'Hello%20%7B%7D'.format%28name1%29%29%0A%0AsomeFunc%281,%20'Apple'%29%0Aprint%28name%29%0Aprint%28name1%29&cumulative=false&curInstr=0&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name =  Alice\n",
      "a = 1 and b = Apple\n",
      "Hello John\n",
      "Alice\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'name1' 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-17-2046a00ee4da>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0msomeFunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Apple'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# access global variable name\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Can you access name1 which is local to someFunc function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'name1' is not defined"
     ]
    }
   ],
   "source": [
    "# Global and local scope demo\n",
    "name = \"Alice\" # global variable\n",
    "def someFunc(a, b):\n",
    "    print('name = ', name) # access global variable, name\n",
    "    name1 = \"John\" # declare local variable\n",
    "    print('a = {} and b = {}'.format(a, b)) # a and b are local variables\n",
    "    print('Hello {}'.format(name1)) # access local variable, name1\n",
    "\n",
    "someFunc(1, 'Apple')\n",
    "print(name) # access global variable name\n",
    "print(name1) # Can you access name1 which is local to someFunc function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### modify global variables from within a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var1 = Bob\n",
      "var2 =  John\n",
      "arg1 =  1\n",
      "arg2 =  Apple\n",
      "Bob\n"
     ]
    }
   ],
   "source": [
    "# how to modify global variable inside function\n",
    "var1 = \"Alice\" #global\n",
    "def myFunc(arg1, arg2):\n",
    "    global var1 # tell myFunc that var1 is global\n",
    "    var1 = \"Bob\" # global or local? How can we access global var1?\n",
    "    var2 = \"John\"\n",
    "    print('var1 = {}'.format(var1))\n",
    "    print('var2 = ', var2)\n",
    "    print('arg1 = ', arg1)\n",
    "    print('arg2 = ', arg2)\n",
    "\n",
    "myFunc(1, 'Apple')\n",
    "print(var1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Visualize in PythonTutor.com](http://pythontutor.com/visualize.html#code=%23%20global%20and%20local%20scope%20demos%0A%23%20how%20to%20modify%20global%20variable%20inside%20function%0Avar1%20%3D%20%22Alice%22%20%23global%0Adef%20myFunc%28arg1,%20arg2%29%3A%0A%20%20%20%20%23global%20var1%0A%20%20%20%20var1%20%3D%20%22Bob%22%20%23%20global%20or%20local%3F%20How%20can%20we%20access%20global%20var1%3F%0A%20%20%20%20var2%20%3D%20%22John%22%0A%20%20%20%20print%28'var1%20%3D%20%7B%7D'.format%28var1%29%29%0A%20%20%20%20print%28'var2%20%3D%20',%20var2%29%0A%20%20%20%20print%28'arg1%20%3D%20',%20arg1%29%0A%20%20%20%20print%28'arg2%20%3D%20',%20arg2%29%0A%0AmyFunc%281,%20'Apple'%29%0Aprint%28var1%29&cumulative=false&curInstr=0&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise \n",
    "- Define a function that takes two numbers as arguments and returns the sum of the two numbers as answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(num1, num2):\n",
    "    \"\"\"\n",
    "    takes two numeric values: num1 and num2\n",
    "    calculates and returns the sum of num1 and num2\n",
    "    \"\"\"\n",
    "    total = num1 + num2\n",
    "    return total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function add in module __main__:\n",
      "\n",
      "add(num1, num2)\n",
      "    takes two numeric values: num1 and num2\n",
      "    calculates and returns the sum of num1 and num2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# displays the function prototype and docstring below it\n",
    "help(add)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sin in module math:\n",
      "\n",
      "sin(x, /)\n",
      "    Return the sine of x (measured in radians).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "help(math.sin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300\n"
     ]
    }
   ],
   "source": [
    "# call to test add function\n",
    "print(add(100, 200))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum =  90.99\n"
     ]
    }
   ],
   "source": [
    "t = add(100.99, -10)\n",
    "print('sum = ', t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15+10.5=25.5\n"
     ]
    }
   ],
   "source": [
    "num1 = 15\n",
    "num2 = 10.5\n",
    "total = add(num1, num2)\n",
    "print('{}+{}={}'.format(num1, num2, total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "- Define a function that takes two numbers and returns the product of the two numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Exercise - complete the following function\n",
    "def multiply(x, y):\n",
    "    \"\"\"\n",
    "    Function takes two numbers, x and y.\n",
    "    Returns the product of x and y.\n",
    "    FIXME\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function multiply in module __main__:\n",
      "\n",
      "multiply(x, y)\n",
      "    Function takes two numbers, x and y.\n",
      "    Returns the product of x and y.\n",
      "    FIXME\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# help can be run for user-defined functions as well\n",
    "help(multiply)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Manually test multiply function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.6 Automatic testing of functions / unit testing\n",
    "- functions can be testing automatically as well as manually\n",
    "- assert statement can be used to automatically test fruitful functions\n",
    "- each assertion must be True or must pass in order to continue to the next\n",
    "- if assertion fails, throws AssertionError exception and program halts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# examples of assert statments\n",
    "# == comparison operator that lets you compare two values\n",
    "# more on comparison operators in later chapter\n",
    "assert True == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 10 != '10'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-30-7ad819d42cdb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0;32mTrue\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'this will not be printed'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "assert True == False\n",
    "print('this will not be printed')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-31-ede1acf3c16e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0;34m'a'\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'A'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "assert 'a' == 'A'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# auto testing add function\n",
    "assert add(2, 3) == 5\n",
    "assert add(10, -5) == 5\n",
    "# assert add(100, 2000.99) == ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# unit test multiply function\n",
    "# write some sample test cases for multiply function using assert statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.7 Ways of passing data to functions\n",
    "- data/values are passed to functions in two ways\n",
    "\n",
    "### pass by value\n",
    "- fundamental types and values (string, int, float) are passed by value by copying the values to the corresponding parameters\n",
    "\n",
    "### pass by reference\n",
    "- advanced container types (tuple, list, dict, etc.) are passed by reference\n",
    "- this topic will be discussed in the corresponding chapter covering those container types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pass by value demo\n",
    "var1 = 'John' # global variable\n",
    "def greetSomeone(para1):\n",
    "    print('hello', para1)\n",
    "    var1 = 'Jake' # local variable\n",
    "    print('hello again', para1)\n",
    "    \n",
    "greetSomeone(var1)\n",
    "print('var1 = ', var1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [visualize pass by value with PythonTutor.com](http://pythontutor.com/visualize.html#code=var1%20%3D%20'John'%20%23%20global%20variable%0Adef%20greetSomeone%28para1%29%3A%0A%20%20%20%20print%28'hello',%20para1%29%0A%20%20%20%20var1%20%3D%20'Jake'%20%23%20local%20variable%0A%20%20%20%20print%28'hello%20again',%20para1%29%0A%20%20%20%20%0AgreetSomeone%28var1%29%0Aprint%28'var1%20%3D%20',%20var1%29&cumulative=false&curInstr=0&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.8 Fruitful functions returning multiple values\n",
    "- functions can return more than 1 values\n",
    "- multiple comma separated values can be returned\n",
    "- the values are return as Tuple type (more on this later)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def findAreaAndPerimeter(length, width):\n",
    "    \"\"\"\n",
    "    Function takes length and width of a rectangle.\n",
    "    Finds and returns area and perimeter of the rectangle.\n",
    "    \"\"\"\n",
    "    area = length*width\n",
    "    perimeter = 2*(length+width)\n",
    "    return area, perimeter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50, 30)\n"
     ]
    }
   ],
   "source": [
    "print(findAreaAndPerimeter(10, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "area = 200 and perimeter = 60\n"
     ]
    }
   ],
   "source": [
    "a, p = findAreaAndPerimeter(20, 10)\n",
    "print(f'area = {a} and perimeter = {p}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test getAreaAndParameter() function\n",
    "assert findAreaAndPerimeter(4, 2) == (8, 12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.9 Function calling a function\n",
    "- a function can be called from within another function\n",
    "- a function can call itself -- called recursion (see Chapter 13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def average(num1, num2):\n",
    "    sum_of_nums = add(num1, num2)\n",
    "    return sum_of_nums/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avg of 10 and 20 = 15.0\n"
     ]
    }
   ],
   "source": [
    "avg = average(10, 20)\n",
    "print(f'avg of 10 and 20 = {avg}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.10 Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### exercise 1\n",
    "Write a function that takes two numbers; subtracts the second from the first and returns the difference.\n",
    "Write two test cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# solution to exercise 1\n",
    "def sub(num1, num2):\n",
    "    return num1-num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_sub():\n",
    "    assert sub(100, 50) == 50\n",
    "    assert sub(80, 45.5) == 34.5\n",
    "    print('all test cases passed for sub()!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all test cases passed for sub()!\n"
     ]
    }
   ],
   "source": [
    "test_sub()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### exercise 2\n",
    "<pre>\n",
    "Write a function that converts seconds to hours, minutes and seconds. Function then returns the values in HH:MM:SS format (e.g., 01:09:10)\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_time(seconds):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Here are some tests that should pass:\n",
    "def test_get_time():\n",
    "    assert get_time(3600) == '1:0:0'\n",
    "    assert get_time(3661) == '1:1:1'\n",
    "    assert get_time(3666) == '1:1:6'\n",
    "    assert get_time(36610) == '10:10:10'\n",
    "    print('all test cases passed for get_time()')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-45-dae45a4e0ae1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_get_time\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-44-0c9bcf598e1c>\u001b[0m in \u001b[0;36mtest_get_time\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#Here are some tests that should pass:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_get_time\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0;32massert\u001b[0m \u001b[0mget_time\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3600\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'1:0:0'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mget_time\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3661\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'1:1:1'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mget_time\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3666\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'1:1:6'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "test_get_time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### exercise 3\n",
    "<pre>\n",
    "Write a function called hypotenuse that returns the length of the hypotenuse of a right triangle given the lengths of the two legs as parameters.\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hypotenuse(leg1, leg2):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_hypotenuse():\n",
    "    assert hypotenuse(3, 4) == 5.0\n",
    "    assert hypotenuse(12, 5) == 13.0\n",
    "    assert hypotenuse(24, 7) == 25.0\n",
    "    assert hypotenuse(9, 12) == 15.0\n",
    "    print('all test cases passed hypotenuse()')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-48-bbecdabdfe81>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_hypotenuse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-47-d9a390da2f14>\u001b[0m in \u001b[0;36mtest_hypotenuse\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_hypotenuse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32massert\u001b[0m \u001b[0mhypotenuse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m5.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mhypotenuse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m12\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m13.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mhypotenuse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m24\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m7\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m25.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mhypotenuse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m9\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m12\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m15.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "test_hypotenuse()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### exercise 4\n",
    "<pre>\n",
    "Write a function slope(x1, y1, x2, y2) that returns the slope of the line through the points (x1, y1) and (x2, y2). Be sure your implementation of slope can pass the test cases provided in test_slope().\n",
    "\n",
    "Then use a call to slope in a new function named intercept(x1, y1, x2, y2) that returns the y-intercept of the line through the points (x1, y1) and (x2, y2)\n",
    "\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def slope(x1, y1, x2, y2):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_slope():\n",
    "    assert slope(5, 3, 4, 2) == 1.0\n",
    "    assert slope(1, 2, 3, 2) == 0.0\n",
    "    assert slope(1, 2, 3, 3) == 0.5\n",
    "    assert slope(2, 4, 1, 2) == 2.0\n",
    "    print('all test cases passed for slope()')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-51-329d174a7258>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_slope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-50-b2c25a2ea8d1>\u001b[0m in \u001b[0;36mtest_slope\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_slope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32massert\u001b[0m \u001b[0mslope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mslope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mslope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0.5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mslope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m2.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "test_slope()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def intercept(x1, y1, x2, y2):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_intercept():\n",
    "    assert intercept(1, 6, 3, 12) == 3.0\n",
    "    assert intercept(6, 1, 1, 6) == 7.0\n",
    "    assert intercept(4, 6, 12, 8) == 5.0\n",
    "    print('all test cases passed for intercept()')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-54-4c3f95bc59e3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_intercept\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-53-4b8e8188161f>\u001b[0m in \u001b[0;36mtest_intercept\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_intercept\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32massert\u001b[0m \u001b[0mintercept\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m12\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m3.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mintercept\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m7.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mintercept\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m12\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m5.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'all test cases passed for intercept()'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "test_intercept()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kattis problems requiring functions\n",
    "- functions are not required to solve problems\n",
    "- you can use function to solve each and every problem\n",
    "- function is required if you must write automated unit tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}