2-1_Functions_in_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 2-1\n",
    "\n",
    "# Functions in Python\n",
    "\n",
    "## Week 2 Monday\n",
    "\n",
    "## Miles Chen, PhD\n",
    "\n",
    "### Adapted from *Think Python* by Allen B. Downey and *A Whirlwind Tour of Python* by Jake VanderPlas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## All Programs can reduced to the following instructions\n",
    "\n",
    "- *input*  - get input from keyboard, a file, network, or some device\n",
    "- *output* - display data to the screen, save to a file, send over network, etc.\n",
    "- *math* - perform a mathematical operation\n",
    "- *conditional execution* - check for certain conditions and run the appropriate code\n",
    "- *repetition* - perform some action repeatedly, usually with some variation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions\n",
    "\n",
    "**Functions calls** are how functions are executed.\n",
    "\n",
    "Function calls consist of the **name** of the function and **parenthesis** with any **arguments** inside the parenthesis.\n",
    "\n",
    "Some functions produce a **return value**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "the name is `type`, the argument is `42`, the return value is `int`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Function calls\n",
    "We call functions by writing the function name and parenthesis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function print>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print  # does not call the function. This is the object of the function itself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print('hello')  # calls the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "print(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1-2-3\n"
     ]
    }
   ],
   "source": [
    "print(1, 2, 3, sep = '-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Getting Help\n",
    "You can view the reference by using `help(functionname)` \n",
    "\n",
    "In Jupyter Lab, you can also hit **Ctrl + I** or choose \"Show Contextual Help\" from the Help Menu. This will open another tab in Jupyter that displays help. Like any other Jupyter tab, it can be dragged to a more convenient location for viewing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Side note about single and double quotes.\n",
    "\n",
    "Both single and double quotes can be used to denote a string. Use double quotes if there will be an apostrophe `'`. Or if you want to use single quotes with an apostrophe, the apostrophe must be escaped with a backslash `\\`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I can't believe it!\n"
     ]
    }
   ],
   "source": [
    "print(\"I can't believe it!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (446527993.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[8], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m    print('I can't believe it!')\u001b[0m\n\u001b[1;37m                 ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "print('I can't believe it!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I can't believe it!\n"
     ]
    }
   ],
   "source": [
    "print('I can\\'t believe it!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I can\"t believe it!\n"
     ]
    }
   ],
   "source": [
    "print('I can\"t believe it!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Defining a function\n",
    "\n",
    "To define a new function, use the statement \n",
    "\n",
    "`def functionname(arguments):`\n",
    "\n",
    "If you want the function to return an object, you must use the `return` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def shouting(phrase):\n",
    "    shout = phrase.upper() + '!!!'\n",
    "    return shout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HI MY NAME IS MILES!!!'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shouting('hi my name is miles')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'int' object has no attribute 'upper'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[13], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mshouting\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[1;32mIn[11], line 2\u001b[0m, in \u001b[0;36mshouting\u001b[1;34m(phrase)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mshouting\u001b[39m(phrase):\n\u001b[1;32m----> 2\u001b[0m     shout \u001b[38;5;241m=\u001b[39m \u001b[43mphrase\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupper\u001b[49m() \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m!!!\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m      3\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m shout\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'int' object has no attribute 'upper'"
     ]
    }
   ],
   "source": [
    "shouting(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def shouting(phrase):\n",
    "    # attempt to convert the input object to a string\n",
    "    shout = str(phrase).upper() + '!!!'\n",
    "    return shout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5!!!'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shouting(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Returning a value\n",
    "If a function returns a value, the result of the function can be assigned to an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def shouting(phrase):\n",
    "    # attempt to convert the input object to a string\n",
    "    shout = str(phrase).upper() + '!!!'\n",
    "    return shout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "greeting = shouting(\"hi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HI!!!'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "If a function does not use `return` to return a value, the result of the function will be `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def quiet(phrase):\n",
    "    shh = str(phrase).lower()\n",
    "    shh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "whisper = quiet(\"HELLO\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "whisper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(whisper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(whisper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Returning multiple values\n",
    "A function can return multiple values as a tuple. We will explore tuples in a future lecture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def powersof(number):\n",
    "    square = number ** 2\n",
    "    cube = number ** 3\n",
    "    return number, square, cube"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 9, 27)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "powersof(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## tuple unpacking\n",
    "\n",
    "If the function returns a tuple, it can be unpacked into separate elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x, y, z = powersof(3) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "print(y)  # all of the values are stored separately\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Conversely, you can just capture the tuple as a single object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "j = powersof(4)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 16, 64)\n"
     ]
    }
   ],
   "source": [
    "print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Python uses 0-indexing, so you can access the first element of a tuple by using square brackets with a 0 inside: `[0]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "To perform tuple unpacking, the number of elements to be unpacked must match the number of values being assigned.\n",
    "\n",
    "The following is not allowed because `powerof()` returns a tuple with three elements and we are trying to assign it to two names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "too many values to unpack (expected 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[33], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m g, h \u001b[38;5;241m=\u001b[39m powersof(\u001b[38;5;241m5\u001b[39m)\n",
      "\u001b[1;31mValueError\u001b[0m: too many values to unpack (expected 2)"
     ]
    }
   ],
   "source": [
    "g, h = powersof(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Flow of Execution\n",
    "\n",
    "Execution always begins at the first statement of the program. Statements are run one at a time, in order from top to bottom.\n",
    "\n",
    "Function **definitions** do not alter the flow of execution of the program. Keep in mind that *statements inside the function don't run until the function is called.*\n",
    "\n",
    "A function call is like a detour in the flow of execution. Instead of going to the next statement, the flow jumps to the body of the function, runs the statements there, and then comes back to pick up where it left off."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Parameters and Arguments\n",
    "\n",
    "Inside a function, the arguments of a function are assigned to variables called parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# a silly function\n",
    "def print_twice(bruce):\n",
    "    print(bruce)\n",
    "    print(bruce)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The function assigns the argument to a parameter named `bruce`. When the function is called, it prints the value of the parameter (whatever it is)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spam\n",
      "spam\n"
     ]
    }
   ],
   "source": [
    "print_twice(\"spam\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print_twice(math.sin(math.pi / 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spam Spam \n",
      "Spam Spam \n"
     ]
    }
   ],
   "source": [
    "print_twice(\"Spam \" * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spam\n",
      "Spam\n",
      "None\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print_twice(print_twice(\"Spam\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "What happened here?\n",
    "\n",
    "The inner `print_twice()` ran first. It printed \"Spam\" on one line and printed \"Spam\" again on the next line.\n",
    "\n",
    "However, the function `print_twice()` has no return value. It returns `None`. So the outer call of `print_twice()` prints `None` two times."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Default arguments\n",
    "\n",
    "you can also specify default arguments that will be used if they are not explicitly provided"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# example without defaults\n",
    "def stuff(a, b, c):\n",
    "    print(a, b, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "stuff(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "stuff() missing 1 required positional argument: 'c'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[41], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mstuff\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: stuff() missing 1 required positional argument: 'c'"
     ]
    }
   ],
   "source": [
    "stuff(1, 2) # if you do not provide the correct arguments, you get an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# example with defaults\n",
    "def junk(a = 1, b = 2, c = 3):\n",
    "    print(a, b, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "junk()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 2 3\n"
     ]
    }
   ],
   "source": [
    "junk(4) # specifying only one will put it in the first argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4 3\n"
     ]
    }
   ],
   "source": [
    "junk(b = 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 10 0\n"
     ]
    }
   ],
   "source": [
    "junk(5, 10, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "junk() got multiple values for argument 'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[47], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mjunk\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43ma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mb\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: junk() got multiple values for argument 'a'"
     ]
    }
   ],
   "source": [
    "junk(5, a = 10, b = 0) # python will get confused if you name only some of the arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 0 5\n"
     ]
    }
   ],
   "source": [
    "junk(c = 5, a = 10, b = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Function Variables and Parameters are Local\n",
    "When you create a variable inside a function, it is local, which means that it only exists inside the scope of the function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def print_twice(bruce):\n",
    "    print(bruce)\n",
    "    print(bruce)\n",
    "\n",
    "def cat_twice(part1, part2):\n",
    "    cat = part1 + \" \" + part2\n",
    "    print_twice(cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bidi bidi bom bom\n",
      "bidi bidi bom bom\n"
     ]
    }
   ],
   "source": [
    "line1 = 'bidi bidi'\n",
    "line2 = 'bom bom'\n",
    "cat_twice(line1, line2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "When cat_twice terminates, the variable cat is destroyed. If we try to refer to `cat` in the global environment, we get an error. Parameters are also local. For example, outside print_twice, there is no such thing as bruce."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'cat' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[51], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mcat\u001b[49m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'cat' is not defined"
     ]
    }
   ],
   "source": [
    "cat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'bruce' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[52], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mbruce\u001b[49m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'bruce' is not defined"
     ]
    }
   ],
   "source": [
    "bruce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Error Tracebacks\n",
    "\n",
    "If an error occurs during a function call, Python prints the offending line. If the offending line is a function, it prints out the contents of that function and the offending line there. It continues this until it reaches the top-most *frame*.\n",
    "\n",
    "Values that are not defined inside a function are defined in the frame `__main__`. `__main__` is the top-level script environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "For example, I modified the function `print_twice()`. It tries to access the variable `cat` which is not defined inside `print_twice()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def print_twice(bruce):\n",
    "    print(cat)\n",
    "    print(cat)\n",
    "\n",
    "def cat_twice(part1, part2):\n",
    "    cat = part1 + \" \" + part2\n",
    "    print_twice(cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'cat' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[54], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m line1 \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbidi bidi\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m      2\u001b[0m line2 \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbom bom\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m----> 3\u001b[0m \u001b[43mcat_twice\u001b[49m\u001b[43m(\u001b[49m\u001b[43mline1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mline2\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[1;32mIn[53], line 7\u001b[0m, in \u001b[0;36mcat_twice\u001b[1;34m(part1, part2)\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcat_twice\u001b[39m(part1, part2):\n\u001b[0;32m      6\u001b[0m     cat \u001b[38;5;241m=\u001b[39m part1 \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m part2\n\u001b[1;32m----> 7\u001b[0m     \u001b[43mprint_twice\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcat\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[1;32mIn[53], line 2\u001b[0m, in \u001b[0;36mprint_twice\u001b[1;34m(bruce)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mprint_twice\u001b[39m(bruce):\n\u001b[1;32m----> 2\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[43mcat\u001b[49m)\n\u001b[0;32m      3\u001b[0m     \u001b[38;5;28mprint\u001b[39m(cat)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'cat' is not defined"
     ]
    }
   ],
   "source": [
    "line1 = 'bidi bidi'\n",
    "line2 = 'bom bom'\n",
    "cat_twice(line1, line2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "```\n",
    "<ipython-input-53-fdce103e5d5e> in <module>\n",
    "      1 line1 = 'bidi bidi'\n",
    "      2 line2 = 'bom bom'\n",
    "----> 3 cat_twice(line1, line2)\n",
    "```\n",
    "\n",
    "The traceback starts with the lines we just exectued. There are no problems with lines 1 and 2 where we simply assign some lyrics to variable names. Python tell us the offending line is line 3 when we called `cat_twice()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "<ipython-input-52-fd2c2f843dda> in cat_twice(part1, part2)\n",
    "      5 def cat_twice(part1, part2):\n",
    "      6     cat = part1 + \" \" + part2\n",
    "----> 7     print_twice(cat)\n",
    "```\n",
    "\n",
    "The next part of the traceback enters the function `cat_twice()`\n",
    "It tells us that the offending line is line 7: when we made a call to `print_twice()`\n",
    "\n",
    "```\n",
    "<ipython-input-52-fd2c2f843dda> in print_twice(bruce)\n",
    "      1 def print_twice(bruce):\n",
    "----> 2     print(cat)\n",
    "      3     print(cat)\n",
    "      4 \n",
    "      5 def cat_twice(part1, part2):\n",
    "```\n",
    "\n",
    "Finally, the traceback shows us the contents of `print_twice()` and says the offending line is line 2: when we try to print the variable `cat`.\n",
    "\n",
    "`NameError: name 'cat' is not defined`\n",
    "\n",
    "It gives us a NameError and states that the name `cat` is not defined."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Global Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following cell, I run the same code but define `cat` in the global scope. Even though `cat` is not found inside the local scope of the function `print_twice()`, it is defined in the global scope. When `print_twice()` is called from within `cat_twice()`, the variable `cat` is found in the global environment and printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "something else entirely\n",
      "something else entirely\n"
     ]
    }
   ],
   "source": [
    "def print_twice(bruce):\n",
    "    print(cat)\n",
    "    print(cat)\n",
    "\n",
    "def cat_twice(part1, part2):\n",
    "    cat = part1 + \" \" + part2\n",
    "    print_twice(cat)\n",
    "    \n",
    "line1 = 'bidi bidi'\n",
    "line2 = 'bom bom'\n",
    "\n",
    "cat = \"something else entirely\"\n",
    "\n",
    "cat_twice(line1, line2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# `%who`, `%whos`, and `%who_ls`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "iPython has a few magic commands that list the objects defined in the global environment `%who` prints the names, `%whos` prints the names and details of each object, and `%who_ls` returns a list with object names as strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat\t cat_twice\t greeting\t j\t junk\t line1\t line2\t math\t powersof\t \n",
      "print_twice\t quiet\t shouting\t stuff\t whisper\t x\t y\t z\t \n"
     ]
    }
   ],
   "source": [
    "%who"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable      Type        Data/Info\n",
      "-----------------------------------\n",
      "cat           str         something else entirely\n",
      "cat_twice     function    <function cat_twice at 0x00000238B46EC310>\n",
      "greeting      str         HI!!!\n",
      "j             tuple       n=3\n",
      "junk          function    <function junk at 0x00000238B46BF5E0>\n",
      "line1         str         bidi bidi\n",
      "line2         str         bom bom\n",
      "math          module      <module 'math' (built-in)>\n",
      "powersof      function    <function powersof at 0x00000238B4685040>\n",
      "print_twice   function    <function print_twice at 0x00000238B47324C0>\n",
      "quiet         function    <function quiet at 0x00000238B4655A60>\n",
      "shouting      function    <function shouting at 0x00000238B46553A0>\n",
      "stuff         function    <function stuff at 0x00000238B46AE8B0>\n",
      "whisper       NoneType    None\n",
      "x             int         3\n",
      "y             int         9\n",
      "z             int         27\n"
     ]
    }
   ],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cat',\n",
       " 'cat_twice',\n",
       " 'greeting',\n",
       " 'j',\n",
       " 'junk',\n",
       " 'line1',\n",
       " 'line2',\n",
       " 'math',\n",
       " 'powersof',\n",
       " 'print_twice',\n",
       " 'quiet',\n",
       " 'shouting',\n",
       " 'stuff',\n",
       " 'whisper',\n",
       " 'x',\n",
       " 'y',\n",
       " 'z']"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%who_ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Scoping rules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Assignment operations only affect values inside the function and do not interact with values outside the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def alter_x(x):\n",
    "    x = x + 1\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alter_x(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Global variables\n",
    "\n",
    "If you want your function to alter variables outside of its own scope, you can use the keyword `global`\n",
    "\n",
    "Be careful with this keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def alter_global_x():\n",
    "    global x\n",
    "    x = x + 1\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alter_global_x()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "If a function calls for a value that is not provided in the arguments or is not defined inside the function, the Python will search for the value in the higher scopes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# in this function, we ask Python to print the value of x\n",
    "# even though we do not define its value. Python finds x\n",
    "# in the global environment\n",
    "\n",
    "def search_for_x():\n",
    "    print(x)\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "search_for_x()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Scope Order in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taken from: https://realpython.com/python-scope-legb-rule/\n",
    "\n",
    "Python will search scopes in the following order:\n",
    "\n",
    "- Local (or function) scope is the code block or body of any Python function. This Python scope contains the names that you define inside the function. These names will only be visible from the code of the function.\n",
    "\n",
    "- Enclosing (or nonlocal) scope is a special scope that only exists for functions nested inside other functions. If the local scope is an inner or nested function, then the enclosing scope is the scope of the outer or enclosing function. This scope contains the names that you define in the enclosing function. The names in the enclosing scope are visible from the code of the inner and enclosing functions.\n",
    "\n",
    "- Global scope is the top-most scope in a Python program, script, or module. This Python scope contains all of the names that you define at the top level of a program or a module. Names in this Python scope are visible from everywhere in your code.\n",
    "\n",
    "- Built-in scope is a special Python scope that's created whenever you run a script or open an interactive session. This scope contains names such as keywords, functions, exceptions, and other attributes that are built into Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 1)\n",
      "1 1 1\n"
     ]
    }
   ],
   "source": [
    "x, y, z = 1, 1, 1\n",
    "\n",
    "def f():\n",
    "    y = 2  # changing y to 2, only affects the value inside the function\n",
    "    return x, y, z   # it does not find x or z in the local environment, so it searches the higher scope\n",
    "\n",
    "print(f())\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "1 1 1\n"
     ]
    }
   ],
   "source": [
    "x, y, z = 1, 1, 1\n",
    "\n",
    "def f():\n",
    "    y = 2\n",
    "    def g():\n",
    "        z = 3\n",
    "        return x, y, z \n",
    "    return g()\n",
    "\n",
    "print(f())\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "`g()` is defined inside `f()`\n",
    "\n",
    "When we call the function `f()`, the final line of `f()` calls `g()` and returns the value of `g()`.\n",
    "\n",
    "When `g()` runs, it sets `z = 3`. Inside `g()`, `x` and `y` are not defined. To find those values, it searches the higher scope `f()` for x and y. It finds the value of `y = 2` defined inside `f()`. It finds `x = 1` in the top level scope.\n",
    "\n",
    "When `f()` runs, it returns `x = 1`, `y = 2`, `z = 3` while x, y, z are all equal to 1 in the top-level environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 3)\n",
      "1 1 1\n"
     ]
    }
   ],
   "source": [
    "x, y, z = 1, 1, 1\n",
    "\n",
    "def g():\n",
    "    z = 3\n",
    "    return x, y, z\n",
    "\n",
    "def f():\n",
    "    y = 2\n",
    "    return g()\n",
    "\n",
    "print(f())\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`g()` and `f()` are both defined in the global environment.\n",
    "\n",
    "The function `f()` returns the value of `g()`\n",
    "\n",
    "When `g()` runs, it sets `z = 3`. Inside `g()`, `x` and `y` are not defined. To find those values, it searches the higher scope which is the global environment because `g()` is defined inside the global environment. It uses the values in the global environment `x = 1` and `y = 1`.\n",
    "\n",
    "It does not matter that `g()` was called from inside `f()`. When `g()` needs to search a higher scope, it searches the environment in which the function is defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "1 1 3\n"
     ]
    }
   ],
   "source": [
    "# keyword global gives the function access to the value in the global environment\n",
    "x, y, z = 1, 1, 1\n",
    "\n",
    "def f():\n",
    "    y = 2\n",
    "    def g():\n",
    "        global z  # calling global, gives g access to the global value of z\n",
    "        z = 3     # will assign 3 to the global variable z\n",
    "        return x, y, z\n",
    "    return g()\n",
    "\n",
    "print(f())\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "`g()` is defined inside `f()`\n",
    "\n",
    "When we call the function `f()`, the final line of `f()` calls `g()` and returns the value of `g()`.\n",
    "\n",
    "When `g()` runs, it accesses the global variable `z`. It sets `z = 3` in the global environment. Inside `g()`, `x` and `y` are not defined. To find those values, it searches the higher scope `f()` for x and y. It finds the value of `y = 2` defined inside `f()`. It finds `x = 1` in the top level scope.\n",
    "\n",
    "When `f()` runs, it returns `x = 1`, `y = 2`, `z = 3`.\n",
    "\n",
    "Because `g()` has access to `z` in the global environment, the value of z is now 3 after the function runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 3)\n",
      "1 1 1\n"
     ]
    }
   ],
   "source": [
    "x, y, z = 1, 1, 1\n",
    "\n",
    "def g():\n",
    "    z = 3\n",
    "    return x, y, z\n",
    "\n",
    "def f():\n",
    "    global y\n",
    "    y = 2\n",
    "    return g()\n",
    "\n",
    "print(g()) # when we first run g(), it uses the global values of x and y, but the local value of z. Local value of z does not change global value z.\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "`g()` and `f()` are both defined in the global environment.\n",
    "\n",
    "When `g()` runs, it sets `z = 3`. Inside `g()`, `x` and `y` are not defined. To find those values, it searches the higher scope which is the global environment because `g()` is defined inside the global environment. It uses the values in the global environment `x = 1` and `y = 1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "1 2 1\n"
     ]
    }
   ],
   "source": [
    "print(f())  # when we run f(), the global value of y is changed.\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "When we call the function `f()`, it modifies the value of `y` in the global environment. The final line of `f()` calls and returns the value of `g()`. This time, when `g()` looks for a value of `y`, it finds the value of `y` in the global environment which is now 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1, 2)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p, q = 1, 1\n",
    "\n",
    "def f():\n",
    "    global s   # will create s in the global\n",
    "    s = 2\n",
    "    return p, q, s\n",
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you use the keyword `global` inside a function it will create the variable in the global environment if necessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current value of y is 1\n",
      "current value of y is now 4\n",
      "current value of y is finally 10\n",
      "(1, 10, 3)\n",
      "1 10 3\n"
     ]
    }
   ],
   "source": [
    "x, y, z = 1, 1, 1\n",
    "\n",
    "def f():\n",
    "    global y\n",
    "    print(\"current value of y is \" + str(y))\n",
    "    y = 4\n",
    "    def g():\n",
    "        global y\n",
    "        print(\"current value of y is now \" + str(y))\n",
    "        y = 10 \n",
    "        print(\"current value of y is finally \" + str(y))\n",
    "        global z  \n",
    "        z = 3\n",
    "        return x, y, z\n",
    "    return g() \n",
    "\n",
    "print(f())\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both the function `g()` and `f()` access the global variable `y`. Each time we assign a new value to `y`, it updates the value in the global environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4 1\n",
      "(1, 10, 3)\n",
      "1 1 3\n"
     ]
    }
   ],
   "source": [
    "x, y, z = 1, 1, 1\n",
    "\n",
    "def f():\n",
    "    y = 4\n",
    "    def g():\n",
    "        nonlocal y  \n",
    "        y = 10  # affects the y defined inside f\n",
    "        global z  \n",
    "        z = 3\n",
    "        return x, y, z\n",
    "    print(x, y, z)  # this line is run before g() is called\n",
    "    return g()  # when g() is called, y will be modified\n",
    "\n",
    "print(f())\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "When we call the function `f()`, it sets a local variable `y = 4`. It defines a function `g()` inside `f()`. It prints the values `x, y, z`. At this time, `y = 4`.\n",
    "\n",
    "The final line of `f()` calls `g()` and returns the value of `g()`. When `g()` is called, it accesses the nonlocal variable `y`. The nonlocal keyword tells the function to search the higher scope, in this case, the scope of `f()`. It sets nonlocal `y = 10` and global `z = 3`. It returns `x = 1` global, `y = 10` nonlocal, `z = 3` global.\n",
    "\n",
    "Because `g()` has access to `z` in the global environment, the value of z is now 3 after the function runs. However, the value `y` in the global environment remains 1 because it only modified the nonlocal variable `y`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "no binding for nonlocal 'r' found (3454248193.py, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[80], line 4\u001b[1;36m\u001b[0m\n\u001b[1;33m    nonlocal r   # will return an error because r does not exist in the nonlocal environment\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m no binding for nonlocal 'r' found\n"
     ]
    }
   ],
   "source": [
    "p, q = 1, 1\n",
    "\n",
    "def f():\n",
    "    nonlocal r   # will return an error because r does not exist in the nonlocal environment\n",
    "    r = 2\n",
    "    return p, q, r\n",
    "\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you ask for a nonlocal variable but there is no higher scope (other than the global environment), Python will return an error."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}