Section_03_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Functions\n",
    "\n",
    "- [Introduction](#Introduction)\n",
    "- [Python Namespace And Scoping](#Python-Namespace-And-Scoping)\n",
    "- [Memory Model](#Memory-Model)\n",
    "- [Recap](#Recap)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Introduction\n",
    "\n",
    "### Example - Constant acceleration motion\n",
    "\n",
    "- Example of an object falling:\n",
    "    - $s_0 \\: [m]$ (initial height)\n",
    "    - $v_0 \\: [m/s]$ (initial velocity)\n",
    "    - $a = -9.81 \\: m/s^2$ (gravitational acceleration)\n",
    "    - $t = 2 \\: s$ (time)\n",
    "\n",
    "$$ \n",
    "\\begin{align}\n",
    "    a(t) &= \\text{const} \\\\\n",
    "    v(t) &= \\int a dt  =  v_0 + at \\\\\n",
    "    s(t) &= \\int v(t) dt = s_0 + v_0t + \\frac{1}{2} at^2\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "- Calculate $s(t)$ for multiple different initial $s_0$ and $v_0$\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "\n",
    "- Using a function to compute the height\n",
    "- Think about the problem in terms of functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext nbtutor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "%%nbtutor -r -f --digits 5\n",
    "t = 2\n",
    "g = -9.81\n",
    "\n",
    "s0 = 100\n",
    "v0 = 10\n",
    "s = s0 + v0 * t + 0.5 * g * t**2\n",
    "print(s)\n",
    "\n",
    "s0 = 200\n",
    "v0 = 20\n",
    "s = s0 + v0 * t + 0.5 * g * t**2\n",
    "print(s)\n",
    "\n",
    "s0 = 300\n",
    "v0 = 30\n",
    "s = s0 + v0 * t + 0.5 * g * t**2\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### All arguments passed to the function (Good practice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f --digits 5\n",
    "def height(s0, v0, t, g):\n",
    "    ans = s0 + v0 * t + 0.5 * g * t**2\n",
    "    return ans\n",
    "\n",
    "\n",
    "print(height(s0=100, v0=10, t=2, g=-9.81))\n",
    "print(height(s0=200, v0=20, t=2, g=-9.81))\n",
    "print(height(s0=300, v0=30, t=2, g=-9.81))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f --digits 5\n",
    "def height(s0, v0, t):\n",
    "    g = -9.81\n",
    "    ans = s0 + v0 * t + 0.5 * g * t**2\n",
    "    return ans\n",
    "\n",
    "\n",
    "print(height(s0=100, v0=10, t=2))\n",
    "print(height(s0=200, v0=20, t=2))\n",
    "print(height(s0=300, v0=30, t=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f --digits 5\n",
    "def height(s0, v0, t):\n",
    "    g = -9.81\n",
    "    ans = s0 + v0 * t + 0.5 * g * t**2\n",
    "    return ans\n",
    "\n",
    "\n",
    "print(height(s0=100, v0=10, t=2))\n",
    "print(height(100, 10, 2))\n",
    "\n",
    "print(height(v0=10,s0=100, t=2))\n",
    "\n",
    "print(height(10, 100, 2))\n",
    "print(height(s0=10,v0=100, t=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- **Used to break a complex problem down into smaller sections / functions** $\\to$ easier to think about the problem in terms of functionality\n",
    "\n",
    "\n",
    "- **Separate the functionality from the data**\n",
    "    - Functionality remains the same\n",
    "    - Data changes\n",
    "\n",
    "\n",
    "- **Used to test smaller sections of code independently**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s, v = 100, 5\n",
    "\n",
    "print(s)\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "st, vt, at = 100, 5, 0\n",
    "\n",
    "s, v = vt, st\n",
    "\n",
    "print(s)\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple Returns\n",
    "\n",
    "- Special case of multiple assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#%%nbtutor -r -f --digits 5\n",
    "def trajectory(s0, v0, t):\n",
    "    g = -9.81\n",
    "    st = s0 + v0 * t + 0.5 * g * t**2\n",
    "    vt = v0 + g*t\n",
    "    return st, vt\n",
    "\n",
    "\n",
    "s, v = trajectory(s0=100, v0=0, t=2)\n",
    "#print(\"s:\", s, \"m\")\n",
    "#print(\"v:\", v, \"m/s\")\n",
    "S_string=\"s: {} m\"\n",
    "V_string=\"v: {} m/s\"\n",
    "print(S_string.format(s))\n",
    "print(V_string.format(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple\n",
    "\n",
    "Output of function `trajectory` in the cell above is an example of a `tuple`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm = trajectory(s0=100, v0=0, t=2)\n",
    "print(type(cm))\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "S_string=\"s: {} m\"\n",
    "V_string=\"v: {} m/s\"\n",
    "print(S_string.format(cm[0]))\n",
    "print(V_string.format(cm[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ct = 100, 5, 0\n",
    "print(ct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ct = (100, 5, 0)\n",
    "print(ct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some global arguments (Bad practice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f --digits 5\n",
    "def height(s0, v0):\n",
    "    ans = s0 + v0 * t + 0.5 * g * t**2\n",
    "    return ans\n",
    "\n",
    "\n",
    "t = 2\n",
    "g = -9.81\n",
    "print(height(s0=100, v0=10))\n",
    "print(height(s0=200, v0=20))\n",
    "print(height(s0=300, v0=30))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python Namespace And Scoping\n",
    "\n",
    "- Functions are 2 things $\\to$ a name and a function object\n",
    "- Every function name $\\to$ added to *global namespace* (piece of paper)\n",
    "- View all names and their objects $\\to$ `%whos`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example - Cell Execution Order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Code Cell One\n",
    "ans = velocity(v0=100, t=2, g=-9.81)\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Code Cell Two\n",
    "def velocity(v0, t, g):\n",
    "    return v0 + g*t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Execution order: `One`, then `Two` $\\to$ Error $\\to$ Name `velocity` not defined\n",
    "- Execution order: `Two`, then `Three` $\\to$ Works !!\n",
    "- Always write code properly in the correct execution order\n",
    "    - To make sure it is correct: Kernel $\\to$ `Restart & Run All`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Scoping\n",
    "\n",
    "- Every function $\\to$ has its own *local namespace* (piece of paper)\n",
    "- Names created in a function $\\to$ added to the function *local namespace* (piece of paper)\n",
    "- *local namespace* can look into the *global namespace*\n",
    "- *global namespace* **can not** look into the *local namespace*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def velocity(v0):\n",
    "    gt = g * t  # get g and t from global namespace\n",
    "    return v0 + gt\n",
    "\n",
    "\n",
    "t = 2\n",
    "g = -9.81\n",
    "ans = velocity(v0=100)\n",
    "print(ans)\n",
    "print(gt)  # no name gt in global namespace --> error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What will be the value of `t` in line 2?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def velocity(v0, t, g):\n",
    "    print(\"t:\", t)\n",
    "    return v0 + g*t\n",
    "\n",
    "\n",
    "t = 10\n",
    "print(velocity(v0=100, t=2, g=-9.81))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example - Potential Confusion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = 10\n",
    "g = 9.81\n",
    "\n",
    "def velocity(v0):\n",
    "    return v0 + g*t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(velocity(v0=100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = 2\n",
    "print(velocity(v0=100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Can lead to unexpected output or results\n",
    "- 3 cells of code $\\to$ easy to spot the change of global data\n",
    "- Imagine 100+ codes cells\n",
    "- Rather follow the practice of sending all required data as inputs to the function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Memory Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f --digits 5\n",
    "def velocity(v0):\n",
    "    gt = g * t\n",
    "    ans = v0 + gt\n",
    "    return ans\n",
    "\n",
    "t = 2\n",
    "g = -9.81\n",
    "v1 = velocity(v0=100)\n",
    "v2 = velocity(v0=200)\n",
    "print(v1, v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passing a function object to another function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f --digits 5\n",
    "def components(r,theta,cs,sn):\n",
    "    return r*cs(theta), r*sn(theta)\n",
    "\n",
    "import numpy as np\n",
    "angl = np.arccos(3.0/5.0)\n",
    "xx,yy = components(5.0,angl,np.cos,np.sin)\n",
    "print(xx,yy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reset -f\n",
    "%who"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f --digits 5\n",
    "def components(r,theta):\n",
    "    from numpy import sin, cos\n",
    "    return r*cos(theta), r*sin(theta)\n",
    "\n",
    "from numpy import arccos\n",
    "angl = arccos(3.0/5.0)\n",
    "xx,yy = components(5.0,angl)\n",
    "print(xx,yy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reset -f\n",
    "%who"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preferably not to be used in autograded assignments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f --digits 5\n",
    "def components(r,theta):\n",
    "    return r*cos(theta), r*sin(theta)\n",
    "\n",
    "from numpy import arccos, sin, cos\n",
    "angl = arccos(3.0/5.0)\n",
    "xx,yy = components(5.0,angl)\n",
    "print(xx,yy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recap\n",
    "\n",
    "- Functions\n",
    "    - Split functionality from data\n",
    "    - Name pointing to a function object\n",
    "    - Need to create function object and name before using it\n",
    "\n",
    "\n",
    "### Recap Quiz\n",
    "\n",
    "- What will get printed to the screen and why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reset -f\n",
    "def blarg(foo, bar):\n",
    "    spam = 5\n",
    "    eggs = spam * foo / bar\n",
    "    return eggs\n",
    "\n",
    "\n",
    "spam = 500\n",
    "print(blarg(bar=10, foo=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What is wrong with the following code? (5 mistakes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reset -f\n",
    "def blarg(foo):\n",
    "    bar = pi * np.sin(foo)\n",
    "\n",
    "\n",
    "print(blarg(foo=\"0.2\", pi=3.15))\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Visualize",
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}