Ch03-3-Functions-UserDefined.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 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",
    "## 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: $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 value(s) if any\n",
    "\n",
    "```python\n",
    "VARIABLE = functionName( ARGUMENT1, ARGUMENT2, ...)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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": [
    "## 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 **explictly** return a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": 2,
   "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": 3,
   "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": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fruitful function\n",
    "def getName():\n",
    "    name = input(\"Hi there, enter your full name: \")\n",
    "    return name\n",
    "    print(f'Hi {name}, nice meeting you!') # dead code - will not be executed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi there, enter your full name: John Smith\n"
     ]
    }
   ],
   "source": [
    "userName = getName()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'John Smith'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "userName"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi John Smith, nice meeting you!\n"
     ]
    }
   ],
   "source": [
    "print(f'Hi {userName}, nice meeting you!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Function takes one required argument\n",
    "def greet(name):\n",
    "    print(f'Hello {name}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Jane\n"
     ]
    }
   ],
   "source": [
    "greet('Jane')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Michael Smith\n"
     ]
    }
   ],
   "source": [
    "# Arguments can be variables as well\n",
    "n = 'Michael Smith'\n",
    "greet(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: Jake Jones\n",
      "Hello Jake Jones\n"
     ]
    }
   ],
   "source": [
    "n1 = input('Enter your name: ')\n",
    "greet(n1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "greet() missing 1 required positional argument: 'name'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[22], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mgreet\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: greet() missing 1 required positional argument: 'name'"
     ]
    }
   ],
   "source": [
    "greet()\n",
    "# How to fix? provide either default value or call it properly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": 24,
   "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": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, adfasd\n"
     ]
    }
   ],
   "source": [
    "greet('adfasd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: Jackie Chain\n",
      "Hello, Jackie Chain\n"
     ]
    }
   ],
   "source": [
    "user = input('Enter your name: ')\n",
    "greet(user) # calling greet with an argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name =  Alice\n",
      "1 and 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)",
      "Cell \u001b[0;32mIn[27], line 12\u001b[0m\n\u001b[1;32m     10\u001b[0m someFunc(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mApple\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m     11\u001b[0m \u001b[38;5;28mprint\u001b[39m(name) \u001b[38;5;66;03m# Access global variable name\u001b[39;00m\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mname1\u001b[49m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'name1' is not defined"
     ]
    }
   ],
   "source": [
    "# Global and local scope demo\n",
    "name = \"Alice\" # global variable\n",
    "\n",
    "def someFunc(a, b):\n",
    "    print('name = ', name) # Access global variable, name\n",
    "    name1 = \"John\" # Declare local variable\n",
    "    print(f'{a} and {b}') # a and b are local variables\n",
    "    print(f'Hello {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": 28,
   "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",
    "\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(f'{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": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(num1, num2):\n",
    "    \"\"\" add function\n",
    "    \n",
    "    Take two numeric values: num1 and num2.\n",
    "    Calculate and return the sum of num1 and num2.\n",
    "    \"\"\"\n",
    "    total = num1 + num2\n",
    "    return total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function add in module __main__:\n",
      "\n",
      "add(num1, num2)\n",
      "    add function\n",
      "    \n",
      "    Take two numeric values: num1 and num2.\n",
      "    Calculate and return 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": 31,
   "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": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300\n"
     ]
    }
   ],
   "source": [
    "# Test add function\n",
    "print(add(100, 200))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 a+ 10.5 = 25.5\n"
     ]
    }
   ],
   "source": [
    "num1 = 15\n",
    "num2 = 10.5\n",
    "total = add(num1, num2)\n",
    "print(f'{num1} a+ {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": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Exercise - complete the following function\n",
    "def multiply(x, y):\n",
    "    \"\"\"\n",
    "    Function take two numbers: x and y.\n",
    "    Return the product of x and y.\n",
    "    \"\"\"\n",
    "    \n",
    "    # FIXME\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function multiply in module __main__:\n",
      "\n",
      "multiply(x, y)\n",
      "    Function take two numbers: x and y.\n",
      "    Return the product of x and y.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Help can be run for user-defined functions as well\n",
    "help(multiply)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Manually test multiply function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Automatic testing of functions or 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": 38,
   "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": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 10 != '10'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[40], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mthis will not be printed\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "assert True == False\n",
    "print('this will not be printed')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[41], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124ma\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mA\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "assert 'a' == 'A'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Auto testing or asserting 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": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Unit test multiply function\n",
    "# Write some sample test cases for multiply function using assert statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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 literals (string, int, float) are passed by value\n",
    "    - values passed as arguments are copied to the corresponding parameters\n",
    "\n",
    "### pass by reference\n",
    "- advanced container types (tuple, list, dict, etc.) are passed by reference\n",
    "    - parameters and corresponding arguments become alias pointing to the same memory location\n",
    "- this topic will be discussed in the corresponding chapter covering those container types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello John\n",
      "hello again John\n",
      "var1 =  John\n"
     ]
    }
   ],
   "source": [
    "# Pass by value demo\n",
    "var1 = 'John' # Global variable\n",
    "\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": [
    "## 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": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def findAreaAndPerimeter(length, width):\n",
    "    \"\"\"\n",
    "    Take length and width of a rectangle.\n",
    "    Find and return area and perimeter of the rectangle.\n",
    "    \"\"\"\n",
    "    \n",
    "    area = length*width\n",
    "    perimeter = 2*(length+width)\n",
    "    return area, perimeter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50, 30)\n"
     ]
    }
   ],
   "source": [
    "print(findAreaAndPerimeter(10, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "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": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test getAreaAndParameter() function\n",
    "assert findAreaAndPerimeter(4, 2) == (8, 12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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": 49,
   "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": 50,
   "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": [
    "## 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": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution to exercise 1\n",
    "def sub(num1, num2):\n",
    "    return num1 - num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "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": 53,
   "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",
    "\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_time(seconds):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "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": 56,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[56], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtest_get_time\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[55], line 3\u001b[0m, in \u001b[0;36mtest_get_time\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtest_get_time\u001b[39m():\n\u001b[0;32m----> 3\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m get_time(\u001b[38;5;241m3600\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m1:0:0\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m get_time(\u001b[38;5;241m3661\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m1:1:1\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m      5\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m get_time(\u001b[38;5;241m3666\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m1:1:6\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "test_get_time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### exercise 3\n",
    "\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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hypotenuse(leg1, leg2):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "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": 59,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[59], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtest_hypotenuse\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[58], line 2\u001b[0m, in \u001b[0;36mtest_hypotenuse\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtest_hypotenuse\u001b[39m():\n\u001b[0;32m----> 2\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m hypotenuse(\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m5.0\u001b[39m\n\u001b[1;32m      3\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m hypotenuse(\u001b[38;5;241m12\u001b[39m, \u001b[38;5;241m5\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m13.0\u001b[39m\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m hypotenuse(\u001b[38;5;241m24\u001b[39m, \u001b[38;5;241m7\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m25.0\u001b[39m\n",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "test_hypotenuse()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### exercise 4\n",
    "\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def slope(x1, y1, x2, y2):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "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": 62,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[62], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtest_slope\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[61], line 2\u001b[0m, in \u001b[0;36mtest_slope\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtest_slope\u001b[39m():\n\u001b[0;32m----> 2\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m slope(\u001b[38;5;241m5\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m2\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1.0\u001b[39m\n\u001b[1;32m      3\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m slope(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m2\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0.0\u001b[39m\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m slope(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m3\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0.5\u001b[39m\n",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "test_slope()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def intercept(x1, y1, x2, y2):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "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": 65,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[65], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtest_intercept\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[64], line 2\u001b[0m, in \u001b[0;36mtest_intercept\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtest_intercept\u001b[39m():\n\u001b[0;32m----> 2\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m intercept(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m6\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m12\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m3.0\u001b[39m\n\u001b[1;32m      3\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m intercept(\u001b[38;5;241m6\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m6\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m7.0\u001b[39m\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m intercept(\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m6\u001b[39m, \u001b[38;5;241m12\u001b[39m, \u001b[38;5;241m8\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m5.0\u001b[39m\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 or not use one\n",
    "- function is required if you must write automated unit tests\n",
    "- function is recommended for breaking a problem into smaller sub-problems and making the solution modular"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}