diff --git a/s25/Louis_Lecture_Notes/06_Creating_Functions/Lec_06_Creating_Functions.ipynb b/s25/Louis_Lecture_Notes/06_Creating_Functions/Lec_06_Creating_Functions.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..31f67e7ae5f5626986874eddf96d409bf4b3915e
--- /dev/null
+++ b/s25/Louis_Lecture_Notes/06_Creating_Functions/Lec_06_Creating_Functions.ipynb
@@ -0,0 +1,801 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "source": [
+ "## Warmup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# Warmup 1\n",
+ "# Get the user's name using the input function.\n",
+ "# Then, print out 'Hello, NAME'\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# Warmup 2\n",
+ "# Ask the user for a number, then tell them the sqrt of it.\n",
+ "# HINT: sqrt needs to be imported from math!\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# Warmup 3\n",
+ "# Fix the code below. What type of error(s) did you fix?\n",
+ "x = input(\"Tell me a number! \")\n",
+ "is-even = (x % 2 == 0)\n",
+ "print(\"That number is even: \" + is-even)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# Warmup 4\n",
+ "# TODO: For this code to work, on the line below, import the time module\n",
+ "\n",
+ "start_time = time.time()\n",
+ "x = 2**1000000000 # a very long computation\n",
+ "end_time = time.time()\n",
+ "\n",
+ "difference = end_time - start_time\n",
+ "\n",
+ "# Seperate each time with a '\\n'\n",
+ "print(start_time, end_time, difference,sep=\"\\n\") "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# Warmup 5\n",
+ "# TODO: Run help on the time.time function to see what it does\n",
+ "help()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# Warmup 6\n",
+ "# TODO: From the math module, import only the log10 function\n",
+ "\n",
+ "\n",
+ "# Then, print the log base 10 of 1000\n",
+ "\n",
+ "print(log10(1000))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3.141592653589793\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Warmup 7\n",
+ "# This one is done for you as an example!\n",
+ "# Note: importing with 'wildcard' * is generally considered bad practice\n",
+ "from math import * # allows us to use all functions without writing math\n",
+ "print(pi)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# Warmup 8\n",
+ "# TODO: Try importing and printing 'pi' the proper way (only importing that one thing from the module)!\n",
+ "\n",
+ "# Add import statement here\n",
+ "\n",
+ "print(pi)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "source": [
+ "## Reminder\n",
+ "\n",
+ "- Use `sep` and `end` keywords in print() function\n",
+ "- Use correct vocabulary when talking about functions (definition, call/invoke, parameter, argument, keyword argument, return value)\n",
+ "- Use common built-in functions (`input()`, `round()`, `abs()`, `type()`, `len()`, `print()`)\n",
+ "- Get help using both `help()` and `dir()`\n",
+ "- Use type cast functions to convert between types (`int()`, `bool()`, `float()`, `str()`)\n",
+ "- Import modules in 3 different ways (`import <module>`, `from <module> import <function>`, and `from <module> import *`\n",
+ "- Use imported functions properly (either using `.` (dot) notation or calling function directly)\n",
+ "- Be able to change the cell types (Markdown, Cell, and Raw), and important properties (read-only vs. editable) of a cell"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "# Creating Functions\n",
+ "\n",
+ "## Readings\n",
+ "\n",
+ "- [Finish Chapter 3 of Think Python](https://greenteapress.com/thinkpython2/html/thinkpython2004.html),\n",
+ "- [Chapter 5.5 to 5.8 of Python for Everybody](https://runestone.academy/ns/books/published//py4e-int/functions/toctree.html)\n",
+ "- [Creating Fruitful Functions](https://cs220.cs.wisc.edu/f24/materials/lecture_ppts/lec-06-extra.pdf)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "## Learning Objectives\n",
+ "\n",
+ "- Explain the syntax of a function header:\n",
+ " - def, ( ), :, tabbing, return\n",
+ "- Write a function with:\n",
+ " - correct header and indentation\n",
+ " - a return value (fruitful function) or without (void function)\n",
+ " - parameters that have default values\n",
+ "- Write a function knowing the difference in outcomes of print and return statements\n",
+ "- Explain how positional, keyword, and default arguments are copied into parameters\n",
+ "- Make function calls using positional, keyword, and default arguments and determine the result.\n",
+ "- Use the debugger to trace function invocations to determine control flow"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "## Functions\n",
+ "\n",
+ "A function definition has two parts:\n",
+ "\n",
+ "- **head** or **header** - the line that begins a function definition. It must be of the form:\n",
+ "\n",
+ " `def <func_name>(parameters):`\n",
+ "\n",
+ " `parameters` may be empty or it may be a comma-separated list of variables. The values these variables will refer to will be passed in when the function call occurs.\n",
+ "\n",
+ " `<func_name>` must follow the same naming rules as variables. Typically, <u>function names are verbs</u> while <u>variable names are nouns</u>.\n",
+ " \n",
+ "- **body** - the rest of the function definition, consisting of lines of code. These lines must be indented.\n",
+ "\n",
+ "The full function definition has the form:\n",
+ "\n",
+ "```\n",
+ "def <func_name>(parameters):\n",
+ " body_line1\n",
+ " body_line2\n",
+ " ...\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "# TODO: Write a function named cube that takes one number input and cubes and return that value\n",
+ "\n",
+ "\n",
+ "\n",
+ "# The first line is called the function header\n",
+ "# Notice that all the other lines are indented the same amount (4 spaces)\n",
+ "# The best practice in a Jupyter Notebook is to press tab\n",
+ "# If you don't run the cell, Jupyter Notebook won't know about the function\n",
+ "\n",
+ "# Open the debugger and notice what is created in the kernel state when this cell runs\n",
+ "# Look under the \"function variables\" section"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Now we call or invoke the cube function! Run the code below:\n",
+ "print(cube(5))\n",
+ "print(cube(4)+cube(-3))\n",
+ "print(cube(cube(2)))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# In the bad_cube function definition in this cell the parameter is cubed and printed rather than returned\n",
+ "# this is bad practice.\n",
+ "\n",
+ "def bad_cube(num):\n",
+ " print(num ** 3)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Explain what goes wrong in these function calls.\n",
+ "\n",
+ "\n",
+ "x = bad_cube(5) #bad_cube does not return anything (it prints a value, but doesn't return a value)\n",
+ "print(x) #since nothing is returned, x contains the value None and that is what is printed"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## `return` vs `print`\n",
+ "- `return` enables us to send output from a function to the calling place\n",
+ " - default `return` value is `None`\n",
+ " - that means, when you don't have a `return` statement, `None` will be returned\n",
+ "- `print` function simply displays / prints something\n",
+ " - it cannot enable you to produce output from a function"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# TODO: Write a function that determines if one number is strictly between two other numbers\n",
+ "# return a boolean ... True or False\n",
+ "# delete the \"pass\" line of code and put your own code there\n",
+ "def is_between(lower, num, upper):\n",
+ " pass\n",
+ "\n",
+ "# you can call a function in the same cell that you defined it\n",
+ "print(is_between(5,8,13))\n",
+ "print(is_between(5,5,13))\n",
+ "print(is_between(100,cube(5),200))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Example 3: write a function get_grid that works like this:\n",
+ "# get_grid(5, 3, \"@\") returns the string \n",
+ "# @@@@@\n",
+ "# @@@@@\n",
+ "# @@@@@\n",
+ "\n",
+ "# Let's practice Incremental Coding\n",
+ "# first, try to do this with string operators and literals\n",
+ "print(((\"#\" * 5) + '\\n') * 3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# then, try to do this with variables\n",
+ "width = 5\n",
+ "height = 3\n",
+ "symbol = '#'\n",
+ "print(((symbol * width) + '\\n') * height)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# now, try to write a function \n",
+ "# think about what would be good names for the parameters\n",
+ "def get_grid(width, height, symb):\n",
+ " return (((symb * width) + '\\n') * height)\n",
+ "\n",
+ "my_grid = get_grid(5, 3, \"*\");\n",
+ "# do some code\n",
+ "2**1000000000\n",
+ "# ...\n",
+ "print(my_grid)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Finally, add in a parameter for a title that appears above the grid\n",
+ "def get_grid_with_title(width, height, symb, title='My Grid'):\n",
+ " row = (symb * width) + '\\n'\n",
+ " grid = ((row) * height)\n",
+ " return title + '\\n' + grid"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# TODO: now run the function. Try using different input values.\n",
+ "print(get_grid_with_title(7, 7, title='CS220 Grid', symb='&'))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Types of arguments\n",
+ "- positional\n",
+ "- keyword\n",
+ "- default\n",
+ "\n",
+ "Python fills arguments in this order: positional, keyword, "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def add3(x, y = 100, z = 100): \n",
+ " \"\"\"adds three numbers\"\"\" #documentation string\n",
+ " tot = x + y + z\n",
+ " return tot\n",
+ "\n",
+ "#calls function with position arguments\n",
+ "addition_of_3 = add3(100, 10, 5)\n",
+ "print(addition_of_3)\n",
+ "\n",
+ "\n",
+ "help(add3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(add3(x = 1, z = 2, y = 5)) #calls function with keyword arguments"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "add3(5, 6) # calls function using positional arguments and one default value argument"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Positional arguments need to be specified before keyword arguments."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Incorrect function call\n",
+ "add3(z = 5, 2, 7) \n",
+ "# TODO: what category of error is this?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Incorrect function definition\n",
+ "# We must specify non-default arguments first\n",
+ "def add3_bad_version(x = 10, y, z): \n",
+ " \"\"\"adds three numbers\"\"\" #documentation string\n",
+ " return x + y + z"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Incorrect function call\n",
+ "add3(5, 3, 10, x = 4)\n",
+ "# TODO: what category of error is this?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# TODO: will this function call work?\n",
+ "add3(y = 5, z = 10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# TODO: will this function call work?\n",
+ "add3()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## fruitful function versus void function\n",
+ "- fruitful function: returns something\n",
+ " - ex: add3\n",
+ "- void function: doesn't return anything\n",
+ " - ex: bad_add3_v1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Example of void function\n",
+ "def bad_add3_v1(x, y, z):\n",
+ " print(x + y + z)\n",
+ "\n",
+ "print(bad_add3_v1(4, 2, 1))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(bad_add3_v1(4, 2, 1) ** 2) # Cannot apply mathematical operator to None"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### `return` statement is final\n",
+ "- exactly *one* `return` statement gets executed for a function call\n",
+ "- immediately after encountering `return`, function execution terminates"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def bad_add3_v2(x, y, z):\n",
+ " return x\n",
+ " return x + y + z # will never execute\n",
+ "\n",
+ "bad_add3_v2(50, 60, 70)"
+ ]
+ },
+ {
+ "attachments": {
+ "0763ccd8-a625-4ac5-83e6-32f7a5e2dbb5.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAbCAYAAABiFp9rAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjE0OjIzIFBNIENEVLvWxlYAAABMSURBVEiJY/z///9/BjoAJnpYMmrRqEUogIVYhUlJSXjl582bh1d++AXdqEWjFsEB42g1MWrRqEWjFmEAln379tHFIsY3b97QpQgCACOeES1Sk59DAAAAAElFTkSuQmCC"
+ },
+ "2d33f283-d329-4087-96d7-2908f34cd33e.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAbCAYAAABiFp9rAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjExOjUwIFBNIENEVCBvAD4AAAESSURBVEiJ7dM9qoQwFAXgc/WhpT8odi7ANbgPQVdhI3EF4jbsrFyH67CTgKQRLTRTzfCqN+bJyDDMqVIkfLnJvSSllLgg2hXIF/owiHOOPM+R5zk456+BpmlCVVUQQkAIgaqqME2TEkTP5uiObNsG0zRBRJjnGYZhgDEGx3EOQX9WdL/9uq4oyxK2bcOyLDDGsCwL6rqGEOI8RERwXReMMXieByklNE1DEAQoigKO44CIDkFPn+536roGEaEoiqNHHnm/9j6bH5XNcRz/G1L6ozM5XFHf9+i6DqZpIkkSRFGkBB3+o6ZpMI4jhmFA27ZKiBKk6/pjve/766Asy+D7PsIwRJqmytBlzfB5A/uF3h+6AXevaAdMxBhAAAAAAElFTkSuQmCC"
+ },
+ "5cd6164b-a7da-414b-8b42-1ff682e50ace.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAbCAYAAABiFp9rAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjEyOjExIFBNIENEVCjLN60AAAEeSURBVEiJ7ZQxjoJQEIa/t26UC1jiAWyJJQVcgkQtuI3gKQgFiTReAGmouAMUaucVSBiLzZrdbOI+2ZUY41/Ny8s/X2bevFEiIvSgtz4gL9ATg8IwZL1e3x/URY8Hqqrq21kpBYCIUNf1/4D2+z1BEJAkyY+7JElYrVYcDoerOd51QKZpYlkWWZZhGAZKKUSENE3Z7XbMZjNM07yaQ+nuOhEhiiKKomA4HCIiNE2Dbdv4vn9p5Z8qgo838X0fgKIoAHAch+Vy+SsEbqjoq/I8B8B1XW1PJ1AXabfuU2VZst1uGY1GeJ7HdDrV8t38YeM45nQ6cTwe2Ww22r6bQYPB4BK3bXs/0GKxYDweM5lMmM/n2r7ehuHxluoL9PygM2PsY5JoyAZJAAAAAElFTkSuQmCC"
+ },
+ "a3c30096-71b3-4281-95b3-fa0cf967bbc9.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJYAAAAbCAYAAACeL3bkAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjIzOjExIFBNIENEVJ7bOp0AAAMVSURBVGiB7dpdS/JwHMbx7zSmbmYZ2YMUBFZGB+mkh8NeT6+o1xN0EHSwRR2klUlRiRSUDWrLufsgiru7J0undfP7nM0/2/XHXXvQTfF930eIDgv1egLi/yTFEoGQYolASLFEIKRYIhB9vZ7A/6DRaGDbNvF4nL6+YL5Sy7JQFIVcLhfI9t9yf3+PaZoAGIZBNBpteV0pVguazSYXFxecnp7iOA6qqhKPx0kkEkxOTmLbNjs7O+RyOQYHB3s93Y5wHAfTNHFdFwDTNCkUCkQikZbWl2J94urqilKphOu6JJNJRkZGcF0X27apVCpUq1WmpqZ6Pc2OchwHy7IA0DQN3/fxPO/54GmlXN8q1vb2Nuvr6wCsra0BvFheWlr6zmY/tbGx8eH46upqR/Pq9Tp7e3uoqophGCQSiRfjt7e37O7uUiqVOpr7d/6/ma2MtcN1XSzLwvM8CoUCxWIRgNnZWUzTxLIsDMNAVdUPtyM37x8ol8uEQiEWFhZe7cR6vY7neaTTaZrNZsezbdvGsiwODw9fjR0cHGBZFrZtdzwXIBKJkM/niUaj+L6PoijEYrGWz1Ygl8J3OY7Dzc0NExMT6Lr+anx/f5+7u7vnZVVV0TStY/m6rjM8PMzZ2RnhcBhFUQA4Ojri/PycVCr15rzapaoq+Xz+xWdPT/10XX819h4p1jsajQYDAwOkUqk3x+fm5l6cqTRN+/Ty8BWKojA/P0+xWOTk5IRwOIzv+1xfXzM2NkY2m+1YVhCkWO/47OgM4v7mLU8FqlarAKTTaWZmZrqS3Q4p1i+QzWbp7+8HHovVTePj43znBRgp1hdcXl5SLpdRFIVMJsPQ0FDXsrtdqCejo6PfWk+K9QWlUomHhwfg8ZfZyspKV3JrtRrHx8eEw2EymQzJZPLH5yryol/rtra2cBwHgFgsxvLycldyNzc38TwPeLz3W1xc/PG58j/WF0xPTxOLxdB1nUwm07XcUKg3u6mdXDlj/QK1Wo1KpfJ8SerW88h2cqVYIhByKRSBkGKJQEixRCCkWCIQUiwRCCmWCMQf0sgg9cuvoIEAAAAASUVORK5CYII="
+ },
+ "b25aea2c-891f-447e-a405-91fa95ba1b27.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAB0AAAAYCAYAAAAGXva8AAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDExOjU5OjUyIEFNIENEVG9kKZwAAAG3SURBVEiJ7ZU7SyNRFIC/zAwhQiLJBpX4Ykt39Reo4KO3UDSx8Uf4gG00u7JsoWhvb6GJkMpKG8UHNoKCGtwtBN/ohqwZcBIZ5lqEXQnqeAcxq+Apz718H+fce891CSEERQ6l2MJ36bv0/0jF9RWpaBvmcfJfzjxOkoq2IwxdmqM5kaKoAKRGWnF/agbgJrmKVtsALtcLSYVAGDrW1QXZjcRd2tABealLZiLd7Cyhx75h/TnHPNl/cI9WVYfir8DXO4q7vsWW56hS8/QXAEppGVrN53zuaA8rc4l5+hO3v0KKI1Xp3zjryrfQ0xQmMBgDID0ZIbsWByCUkENJSbNrcdKTESlgYCiOp7Hn+VIrc4l5uEsq2gaAu6EVX/grAHp8FCvzG2/nF9RgNVptPUppmS3P2XBQ718BNRAi+H2Z3NYC6fEujKXpJzFy7V2fIz0RfnDN1zeGebiDsXwn8w/MUNLc+yhPqlJPYw+hhKB86gDFFyxYUz9UktucL8jlthdteY7aq5Z/JPhjhZKmCEogBOTP29s9XLDP29Fvy3H0ZOzCWJ0lt72It6M/PxaLIXUSr/9re9PSW+9hoKu52EnDAAAAAElFTkSuQmCC"
+ },
+ "d4c26cbe-f2b6-477f-960b-1758b11853e0.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAbCAYAAABiFp9rAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjEyOjM0IFBNIENEVE7dEU8AAAFlSURBVEiJ7dS/y0FRGMDxr/cyXzZX3Ymibjb5AxSrzcLuD1AGf4JJNtONMihlN0jZDSYZ0C2lkBK3uOqaXov34rzDHeSZzuk553zO0/nhsW3bxoX4cQP5Qo5hmibT6RTTNB3HeN9ZyLIshsMh/X6f3W6H3+9HVVUikQiZTAbDMKhWq5TLZWKx2P+gyWSCruscDgc0TSORSHA8Hlkul/R6PUajEdls9uVmn0KLxYJ6vY4sy1QqFcLh8EO+VqvRbDZfQk/PqNPp4PP5KJVKD8h8Pud8PpNKpbhery8hx4r2+z2z2Yx0Ok0oFHrINxoNNpvNvR8IBFAURRw6nU5Eo1GSyeSf+WKxyOVyufcVRUGWZUfI83Ff0Fvv6DfG4zHdbhdJksjlcsTj8bfnClXUarVYr9esViva7bbIVDFIkqR7W/RohaBCoUAwGERVVfL5vBD0ebfuC30h9yHvYDBwBfJst1tXHuwNToSCN+PeLD4AAAAASUVORK5CYII="
+ },
+ "e535eef7-4136-4ece-a1fd-f4d4f3259ad5.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAbCAYAAABiFp9rAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjEzOjM0IFBNIENEVI9Tzo8AAAC4SURBVEiJ7dUhCoVAFIXh36dtQLC4EaPBTThbcBOzCYvRYHMVgsHoMiwyIAhGGdPrKszAe8zph++kewNjjMFBPi4QD/0R1Pc953nah7ZtQynFPM92IYB1XWmahrZt2ffdHvTNNE0opRjH0S4EcBwHXddR1zXLstiD3iR6UxJCUJYlRVHYg/I8R0pJHMePerehNE2RUpJl2dNt96EkSaiqijAMXyEAgf9HHvLQ70DRMAxOoEBr7eQyXM/+OREmn9GvAAAAAElFTkSuQmCC"
+ },
+ "f3649896-c4f8-4e83-a695-8c629044e611.png": {
+ "image/png": "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"
+ },
+ "fc577085-ab22-4961-ad11-7ef72fca0505.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJYAAAAbCAYAAACeL3bkAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjIyOjU5IFBNIENEVNFcr+QAAAPbSURBVGiB7drNSzJrGAbwa/RURqBNRDnZEJTQF62kNhaRUP0DmUEurEW1CiQw+3DRplFXEbRoUaCQWERuWkVBEC3cVLSSCCOXpQ0GGvbhvIuD8h56T6dsRj3x/Hbjw3Pfj+PlfDGUIAgCCEJkskIvgPiZSLAISZBgEZIgwSIkQYJFSIIESwTJZBKhUAjJZFKyHi6XC263W7L6fxKNRmG1WmG1WhGNRr809y+J1vSjvLy84Pj4GAcHB4jFYqisrATLstBqtRgYGEAkEoHb7YbNZkNLS0uhlysKnufBcRzi8TgAgOM4LC4ugqbpT83P+Yjl9/vx9vaW6/T/jcvLS9hsNvj9fjAMg8HBQbS3t+Ph4QGBQAAOhwOxWKzQyxRVJlQAoFarwTAM0uk0nE4neJ7/VI2cj1g8z2NhYQFGoxE6nS7XMl8yPj7+4fjm5qao/W5ubrC6ugqVSoX5+Xk0NTW9G19ZWYHH4xG1b8b19TW0Wm12m6IoAIAgCAiHw+/WI4Z4PA6O45BKpeBwOLL7dHp6GsvLy3C5XJibm4NKpfqwzreuse7u7rC2toaNjQ08Pj5+p1RR2t7eRklJCWZmZt79iOFwGKlUCgaDAa+vr6L3vr29hdPphM/nezfm8/nAcRwikYjofSmKQlVVFex2O6qrqyEIAmQyGWpra2Gz2UDTdDbgHxHlGuv09BQXFxcYGhpCb2+vGCULjud5XF1dob+/H3V1de/G19fXcX9/n92maRoMw4jWn2VZ6HQ6HB4eQqFQgKIoCIKAnZ0dHB0dobOzEyzLitYvQ6lUwm63/+OzdDoNANBoNJidnf1UHdEu3hOJBDweD87Pz2E0GqHRaMQqXRCJRALNzc3o6ur64/jk5CSen5+z2wzD/Ofp4StkMhmmpqagUCiwv7+P0tJSCIKAUCiEnp4eWCyWTx05CoXcFf6L+vr6D/+djY2Nkq+BoihYLBYAwMnJCQCgr68PZrO5qEMFiBisioqKH3UqLBYURWFsbAwNDQ0AAIPBkNf+3d3dOc0TJVh6vR5GoxFKpVKMckXr7OwMu7u7kMvlGB4eRkdHR9565ztQGXq9Pqd53wpWTU1NXh83FJrX683e/W5tbcHpdOalbzAYRCAQQFlZGUwmE9ra2oq+b87BomkaExMTkMvluZb4MrGfU33V7981n+9Her1ePD09Afj7EcjS0lLR9835OdbIyEheQ1UMzGYz1Go1WJbF6Oho3vr+vp8zt/7F3pciryYXv2AwiL29PZSXl8NkMqG1tbXo+5JgEZIgr80QkiDBIiRBgkVIggSLkAQJFiEJEixCEr8AFZFOmXk+Z0EAAAAASUVORK5CYII="
+ }
+ },
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Tracing Code Execution Using the Debugger\n",
+ "\n",
+ "Tracing code is the process of working through by hand the order that lines of code will be executed. A debugger can be very helpful in this process.\n",
+ "\n",
+ " 1. Turn on the debugger and open the debugger sidepanel.\n",
+ " \n",
+ " \n",
+ " \n",
+ " 2. Add a breakpoint to your code. Do this by clicking on the line number of a line of code within the cell. A red dot should appear next to that line of code. Now, when you run the code in the cell when that line is reached the debugger will stop executing your code.\n",
+ " \n",
+ " \n",
+ " \n",
+ " 3. Click the run button (or press shift-enter) to start running the code in the cell. The code will run up to the line where you added a breakpoint and will then stop.\n",
+ " 4. Use the buttons in the bebugger sidepanel next to the \"callstack\" section in the side panel to control the continued execution of the code:\n",
+ " -  (**next**) - Run the next line of code.\n",
+ " -  (**step-into**) - If a line of code calls a function, go into that function stop on the first line of code within the function.\n",
+ " -  (**step-out**) - Execute all lines of code of the function you are currently in and stop at the first line of code outside of the function.\n",
+ " -  (**continue**) - Run the code until you reach the next breakpoint\n",
+ " -  (**terminate**) - stop running the code.\n",
+ "\n",
+ "Be aware if the buttons are greyed out or not. This is another way you can tell if the kernel is still busy trying to execute the code in the cell. Even after every line of code in the cell has finished executing, you will still need to continue stepping until the kernel is free (or you can click the stop button).\n",
+ "\n",
+ " (kernel is still busy with the code in the cell)\n",
+ "\n",
+ " (kernel has finished executing the code in the cell)\n",
+ "\n",
+ "Follow along as we use the debugger on the code cell below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def func_c():\n",
+ " print(\"C\")\n",
+ "\n",
+ "def func_b():\n",
+ " print(\"B1\")\n",
+ " func_c()\n",
+ " print(\"B2\")\n",
+ "\n",
+ "def func_a():\n",
+ " print(\"A1\")\n",
+ " func_b()\n",
+ " print(\"A2\")\n",
+ "\n",
+ "func_a()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## You Try It\n",
+ "\n",
+ "For the code cells below, can you think through what will be printed, and in what order? Use the debugger to set a breakpoint and step through the lines of code and see if it is executed and the output is printed in the order that you thought."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"A\")\n",
+ "\n",
+ "def foo():\n",
+ " print(\"B\")\n",
+ "print(\"C\")\n",
+ "foo()\n",
+ "print(\"D\")\n",
+ "foo()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Almost the same as the last cell but the print(\"C\") has been indented\n",
+ "print(\"A\")\n",
+ "\n",
+ "def foo():\n",
+ " print(\"B\")\n",
+ " print(\"C\")\n",
+ "foo()\n",
+ "print(\"D\")\n",
+ "foo()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def f():\n",
+ " print(\"A\")\n",
+ " return \"B\" \n",
+ " print(\"C\")\n",
+ "print(\"D\")\n",
+ "x = f()\n",
+ "print(\"E\")\n",
+ "print(x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Summary\n",
+ "\n",
+ "You have learned how to **define a function** and what the different portions of the definition are called (header, body, parameters, default value, return). You know how to **pass values by position, keyword, or use the default value**. You know the difference between and **fruitful function and a void function** and the difference between using a print statement and a return statement. You have practiced **using the debugger to step through execution** of Python code.\n"
+ ]
+ }
+ ],
+ "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.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/s25/Louis_Lecture_Notes/06_Creating_Functions/Lec_06_Creating_Functions_Solution.ipynb b/s25/Louis_Lecture_Notes/06_Creating_Functions/Lec_06_Creating_Functions_Solution.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..c6c94a57fc6e8926698ec1466f00df41637dbb1b
--- /dev/null
+++ b/s25/Louis_Lecture_Notes/06_Creating_Functions/Lec_06_Creating_Functions_Solution.ipynb
@@ -0,0 +1,1162 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "source": [
+ "## Warmup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdin",
+ "output_type": "stream",
+ "text": [
+ "What is your name? Louis\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hello, Louis\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Warmup 1\n",
+ "# Get the user's name using the input function.\n",
+ "# Then, print out 'Hello, NAME'\n",
+ "name = input(\"What is your name? \")\n",
+ "print(\"Hello, \" + name)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdin",
+ "output_type": "stream",
+ "text": [
+ "Tell me a number: 25\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The square root of 25 is 5.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Warmup 2\n",
+ "# Ask the user for a number, then tell them the sqrt of it.\n",
+ "# HINT: sqrt needs to be imported from math!\n",
+ "from math import sqrt\n",
+ "number = int(input(\"Tell me a number: \"))\n",
+ "print(\"The square root of\", number, \"is\",sqrt(number))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdin",
+ "output_type": "stream",
+ "text": [
+ "Tell me a number! 24\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "That number is even: True\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Warmup 3\n",
+ "# Fix the code below. What type of error(s) did you fix?\n",
+ "# x = input(\"Tell me a number! \")\n",
+ "# is-even = (x % 2 == 0)\n",
+ "# print(\"That number is even: \" + is-even)\n",
+ "\n",
+ "# FIXED is-even is not a valid variable name. Changed hyphen to underscore\n",
+ "# FIXED Cast input to str to store in x\n",
+ "# FIXED Can't use + operator between string and boolean. Changed to using a comma between arguments.\n",
+ "\n",
+ "x = int(input(\"Tell me a number! \"))\n",
+ "is_even = (x % 2 == 0)\n",
+ "print(\"That number is even: \" , is_even)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1726423078.8203828\n",
+ "1726423081.8150098\n",
+ "2.994626998901367\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Warmup 4\n",
+ "# TODO: For this code to work, on the line below, import the time module\n",
+ "\n",
+ "import time\n",
+ "\n",
+ "start_time = time.time()\n",
+ "x = 2**1000000000 # a very long computation\n",
+ "end_time = time.time()\n",
+ "\n",
+ "difference = end_time - start_time\n",
+ "\n",
+ "# Seperate each time with a '\\n'\n",
+ "print(start_time, end_time, difference,sep=\"\\n\") "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on built-in function time in module time:\n",
+ "\n",
+ "time(...)\n",
+ " time() -> floating point number\n",
+ " \n",
+ " Return the current time in seconds since the Epoch.\n",
+ " Fractions of a second may be present if the system clock provides them.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Warmup 5\n",
+ "# TODO: Run help on the time.time function to see what it does\n",
+ "help(time.time)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Warmup 6\n",
+ "# TODO: From the math module, import only the log10 function\n",
+ "\n",
+ "from math import log10\n",
+ "\n",
+ "# Then, print the log base 10 of 1000\n",
+ "\n",
+ "print(log10(1000))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3.141592653589793\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Warmup 7\n",
+ "# This one is done for you as an example!\n",
+ "# Note: importing with 'wildcard' * is generally considered bad practice\n",
+ "from math import * # allows us to use all functions without writing math\n",
+ "print(pi)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3.141592653589793\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Warmup 8\n",
+ "# TODO: Try importing and printing 'pi' the proper way (only importing that one thing from the module)!\n",
+ "\n",
+ "# Add import statement here\n",
+ "\n",
+ "from math import pi\n",
+ "\n",
+ "print(pi)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": [
+ "review"
+ ]
+ },
+ "source": [
+ "## Reminder\n",
+ "\n",
+ "- Use `sep` and `end` keywords in print() function\n",
+ "- Use correct vocabulary when talking about functions (definition, call/invoke, parameter, argument, keyword argument, return value)\n",
+ "- Use common built-in functions (`input()`, `round()`, `abs()`, `type()`, `len()`, `print()`)\n",
+ "- Get help using both `help()` and `dir()`\n",
+ "- Use type cast functions to convert between types (`int()`, `bool()`, `float()`, `str()`)\n",
+ "- Import modules in 3 different ways (`import <module>`, `from <module> import <function>`, and `from <module> import *`\n",
+ "- Use imported functions properly (either using `.` (dot) notation or calling function directly)\n",
+ "- Be able to change the cell types (Markdown, Cell, and Raw), and important properties (read-only vs. editable) of a cell"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "# Creating Functions\n",
+ "\n",
+ "## Readings\n",
+ "\n",
+ "- [Finish Chapter 3 of Think Python](https://greenteapress.com/thinkpython2/html/thinkpython2004.html),\n",
+ "- [Chapter 5.5 to 5.8 of Python for Everybody](https://runestone.academy/ns/books/published//py4e-int/functions/toctree.html)\n",
+ "- [Creating Fruitful Functions](https://cs220.cs.wisc.edu/f24/materials/lecture_ppts/lec-06-extra.pdf)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "## Learning Objectives\n",
+ "\n",
+ "- Explain the syntax of a function header:\n",
+ " - def, ( ), :, tabbing, return\n",
+ "- Write a function with:\n",
+ " - correct header and indentation\n",
+ " - a return value (fruitful function) or without (void function)\n",
+ " - parameters that have default values\n",
+ "- Write a function knowing the difference in outcomes of print and return statements\n",
+ "- Explain how positional, keyword, and default arguments are copied into parameters\n",
+ "- Make function calls using positional, keyword, and default arguments and determine the result.\n",
+ "- Use the debugger to trace function invocations to determine control flow"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "source": [
+ "## Functions\n",
+ "\n",
+ "A function definition has two parts:\n",
+ "\n",
+ "- **head** or **header** - the line that begins a function definition. It must be of the form:\n",
+ "\n",
+ " `def <func_name>(parameters):`\n",
+ "\n",
+ " `parameters` may be empty or it may be a comma-separated list of variables. The values these variables will refer to will be passed in when the function call occurs.\n",
+ "\n",
+ " `<func_name>` must follow the same naming rules as variables. Typically <u>function names are verbs</u> while <u>variable names are nouns</u>.\n",
+ " \n",
+ "- **body** - the rest of the function definition, consisting of lines of code. These lines must be indented.\n",
+ "\n",
+ "The full function definition has the form:\n",
+ "\n",
+ "```\n",
+ "def <func_name>(parameters):\n",
+ " body_line1\n",
+ " body_line2\n",
+ " ...\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "editable": true,
+ "slideshow": {
+ "slide_type": ""
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "# TODO: Write a function named cube that takes one number input and cubes and return that value\n",
+ "\n",
+ "def cube(num):\n",
+ " return num ** 3\n",
+ "\n",
+ "\n",
+ "# The first line is called the function header\n",
+ "# Notice that all the other lines are indented the same amount (4 spaces)\n",
+ "# The best practice in a Jupyter Notebook is to press tab\n",
+ "# If you don't run the cell, Jupyter Notebook won't know about the function\n",
+ "\n",
+ "# Open the debugger and notice what is created in the kernel state when this cell runs\n",
+ "# Look under the \"function variables\" section"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "125\n",
+ "37\n",
+ "512\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Now we call or invoke the cube function! Run the code below:\n",
+ "print(cube(5))\n",
+ "print(cube(4)+cube(-3))\n",
+ "print(cube(cube(2)))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# In the bad_cube function definition in this cell the parameter is cubed and printed rather than returned\n",
+ "# this is bad practice.\n",
+ "\n",
+ "def bad_cube(num):\n",
+ " print(num ** 3)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "125\n",
+ "None\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Explain what goes wrong in these function calls.\n",
+ "\n",
+ "\n",
+ "x = bad_cube(5) #bad_cube does not return anything (it prints a value, but doesn't return a value)\n",
+ "print(x) #since nothing is returned, x contains the value None and that is what is printed"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## `return` vs `print`\n",
+ "- `return` enables us to send output from a function to the calling place\n",
+ " - default `return` value is `None`\n",
+ " - that means, when you don't have a `return` statement, `None` will be returned\n",
+ "- `print` function simply displays / prints something\n",
+ " - it cannot enable you to produce output from a function"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n",
+ "False\n",
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "# TODO: Write a function that determines if one number is strictly between two other numbers\n",
+ "# return a boolean ... True or False\n",
+ "# delete the \"pass\" line of code and put your own code there\n",
+ "def is_between(lower, num, upper):\n",
+ " return num > lower and num < upper\n",
+ "\n",
+ "# you can call a function in the same cell that you defined it\n",
+ "print(is_between(5,8,13))\n",
+ "print(is_between(5,5,13))\n",
+ "print(is_between(100,cube(5),200))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "#####\n",
+ "#####\n",
+ "#####\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Example 3: write a function get_grid that works like this:\n",
+ "# get_grid(5, 3, \"@\") returns the string \n",
+ "# @@@@@\n",
+ "# @@@@@\n",
+ "# @@@@@\n",
+ "\n",
+ "# Let's practice Incremental Coding\n",
+ "# first, try to do this with string operators and literals\n",
+ "print(((\"#\" * 5) + '\\n') * 3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "#####\n",
+ "#####\n",
+ "#####\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# then, try to do this with variables\n",
+ "width = 5\n",
+ "height = 3\n",
+ "symbol = '#'\n",
+ "print(((symbol * width) + '\\n') * height)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "*****\n",
+ "*****\n",
+ "*****\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# now, try to write a function \n",
+ "# think about what would be good names for the parameters\n",
+ "def get_grid(width, height, symb):\n",
+ " return (((symb * width) + '\\n') * height)\n",
+ "\n",
+ "my_grid = get_grid(5, 3, \"*\");\n",
+ "# do some code\n",
+ "2**1000000000\n",
+ "# ...\n",
+ "print(my_grid)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Finally, add in a parameter for a title that appears above the grid\n",
+ "def get_grid_with_title(width, height, symb, title='My Grid'):\n",
+ " row = (symb * width) + '\\n'\n",
+ " grid = ((row) * height)\n",
+ " return title + '\\n' + grid"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CS220 Grid\n",
+ "&&&&&&&\n",
+ "&&&&&&&\n",
+ "&&&&&&&\n",
+ "&&&&&&&\n",
+ "&&&&&&&\n",
+ "&&&&&&&\n",
+ "&&&&&&&\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# TODO: now run the function. Try using different input values.\n",
+ "print(get_grid_with_title(7, 7, title='CS220 Grid', symb='&'))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Types of arguments\n",
+ "- positional\n",
+ "- keyword\n",
+ "- default\n",
+ "\n",
+ "Python fills arguments in this order: positional, keyword, "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "115\n",
+ "Help on function add3 in module __main__:\n",
+ "\n",
+ "add3(x, y=100, z=100)\n",
+ " adds three numbers\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "def add3(x, y = 100, z = 100): \n",
+ " \"\"\"adds three numbers\"\"\" #documentation string\n",
+ " tot = x + y + z\n",
+ " return tot\n",
+ "\n",
+ "#calls function with position arguments\n",
+ "addition_of_3 = add3(100, 10, 5)\n",
+ "print(addition_of_3)\n",
+ "\n",
+ "\n",
+ "help(add3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "8\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(add3(x = 1, z = 2, y = 5)) #calls function with keyword arguments"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "111"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "add3(5, 6) # calls function using positional arguments and one default value argument"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Positional arguments need to be specified before keyword arguments."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "positional argument follows keyword argument (1597961864.py, line 2)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m File \u001b[0;32m\"/tmp/ipykernel_98465/1597961864.py\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m add3(z = 5, 2, 7)\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m positional argument follows keyword argument\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Incorrect function call\n",
+ "add3(z = 5, 2, 7) \n",
+ "# TODO: what category of error is this?\n",
+ "## a syntax error"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "non-default argument follows default argument (2956570362.py, line 3)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m File \u001b[0;32m\"/tmp/ipykernel_98465/2956570362.py\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m def add3_bad_version(x = 10, y, z):\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m non-default argument follows default argument\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Incorrect function definition\n",
+ "# We must specify non-default arguments first\n",
+ "def add3_bad_version(x = 10, y, z): \n",
+ " \"\"\"adds three numbers\"\"\" #documentation string\n",
+ " return x + y + z"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "add3() got multiple values for argument 'x'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m/tmp/ipykernel_98465/100225854.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Incorrect function call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0madd3\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0;31m# TODO: what category of error is this?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mTypeError\u001b[0m: add3() got multiple values for argument 'x'"
+ ]
+ }
+ ],
+ "source": [
+ "# Incorrect function call\n",
+ "add3(5, 3, 10, x = 4)\n",
+ "# TODO: what category of error is this?\n",
+ "## runtime error"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "add3() missing 1 required positional argument: 'x'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m/tmp/ipykernel_98465/2441706151.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# TODO: will this function call work?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0madd3\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m: add3() missing 1 required positional argument: 'x'"
+ ]
+ }
+ ],
+ "source": [
+ "# TODO: will this function call work?\n",
+ "add3(y = 5, z = 10)\n",
+ "## no, there is not value for the x argument"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "add3() missing 1 required positional argument: 'x'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m/tmp/ipykernel_98465/2146538074.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# TODO: will this function call work?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0madd3\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m: add3() missing 1 required positional argument: 'x'"
+ ]
+ }
+ ],
+ "source": [
+ "# TODO: will this function call work?\n",
+ "add3()\n",
+ "## no, there is no value for the x argument"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## fruitful function versus void function\n",
+ "- fruitful function: returns something\n",
+ " - ex: add3\n",
+ "- void function: doesn't return anything\n",
+ " - ex: bad_add3_v1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "7\n",
+ "None\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Example of void function\n",
+ "def bad_add3_v1(x, y, z):\n",
+ " print(x + y + z)\n",
+ "\n",
+ "print(bad_add3_v1(4, 2, 1))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "7\n"
+ ]
+ },
+ {
+ "ename": "TypeError",
+ "evalue": "unsupported operand type(s) for ** or pow(): 'NoneType' and 'int'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m/tmp/ipykernel_98465/71664968.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbad_add3_v1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m**\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Cannot apply mathematical operator to None\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'NoneType' and 'int'"
+ ]
+ }
+ ],
+ "source": [
+ "print(bad_add3_v1(4, 2, 1) ** 2) # Cannot apply mathematical operator to None"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### `return` statement is final\n",
+ "- exactly *one* `return` statement gets executed for a function call\n",
+ "- immediately after encountering `return`, function execution terminates"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "50"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "def bad_add3_v2(x, y, z):\n",
+ " return x\n",
+ " return x + y + z # will never execute\n",
+ "\n",
+ "bad_add3_v2(50, 60, 70)"
+ ]
+ },
+ {
+ "attachments": {
+ "0763ccd8-a625-4ac5-83e6-32f7a5e2dbb5.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAbCAYAAABiFp9rAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjE0OjIzIFBNIENEVLvWxlYAAABMSURBVEiJY/z///9/BjoAJnpYMmrRqEUogIVYhUlJSXjl582bh1d++AXdqEWjFsEB42g1MWrRqEWjFmEAln379tHFIsY3b97QpQgCACOeES1Sk59DAAAAAElFTkSuQmCC"
+ },
+ "2d33f283-d329-4087-96d7-2908f34cd33e.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAbCAYAAABiFp9rAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjExOjUwIFBNIENEVCBvAD4AAAESSURBVEiJ7dM9qoQwFAXgc/WhpT8odi7ANbgPQVdhI3EF4jbsrFyH67CTgKQRLTRTzfCqN+bJyDDMqVIkfLnJvSSllLgg2hXIF/owiHOOPM+R5zk456+BpmlCVVUQQkAIgaqqME2TEkTP5uiObNsG0zRBRJjnGYZhgDEGx3EOQX9WdL/9uq4oyxK2bcOyLDDGsCwL6rqGEOI8RERwXReMMXieByklNE1DEAQoigKO44CIDkFPn+536roGEaEoiqNHHnm/9j6bH5XNcRz/G1L6ozM5XFHf9+i6DqZpIkkSRFGkBB3+o6ZpMI4jhmFA27ZKiBKk6/pjve/766Asy+D7PsIwRJqmytBlzfB5A/uF3h+6AXevaAdMxBhAAAAAAElFTkSuQmCC"
+ },
+ "5cd6164b-a7da-414b-8b42-1ff682e50ace.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAbCAYAAABiFp9rAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjEyOjExIFBNIENEVCjLN60AAAEeSURBVEiJ7ZQxjoJQEIa/t26UC1jiAWyJJQVcgkQtuI3gKQgFiTReAGmouAMUaucVSBiLzZrdbOI+2ZUY41/Ny8s/X2bevFEiIvSgtz4gL9ATg8IwZL1e3x/URY8Hqqrq21kpBYCIUNf1/4D2+z1BEJAkyY+7JElYrVYcDoerOd51QKZpYlkWWZZhGAZKKUSENE3Z7XbMZjNM07yaQ+nuOhEhiiKKomA4HCIiNE2Dbdv4vn9p5Z8qgo838X0fgKIoAHAch+Vy+SsEbqjoq/I8B8B1XW1PJ1AXabfuU2VZst1uGY1GeJ7HdDrV8t38YeM45nQ6cTwe2Ww22r6bQYPB4BK3bXs/0GKxYDweM5lMmM/n2r7ehuHxluoL9PygM2PsY5JoyAZJAAAAAElFTkSuQmCC"
+ },
+ "a3c30096-71b3-4281-95b3-fa0cf967bbc9.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJYAAAAbCAYAAACeL3bkAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjIzOjExIFBNIENEVJ7bOp0AAAMVSURBVGiB7dpdS/JwHMbx7zSmbmYZ2YMUBFZGB+mkh8NeT6+o1xN0EHSwRR2klUlRiRSUDWrLufsgiru7J0undfP7nM0/2/XHXXvQTfF930eIDgv1egLi/yTFEoGQYolASLFEIKRYIhB9vZ7A/6DRaGDbNvF4nL6+YL5Sy7JQFIVcLhfI9t9yf3+PaZoAGIZBNBpteV0pVguazSYXFxecnp7iOA6qqhKPx0kkEkxOTmLbNjs7O+RyOQYHB3s93Y5wHAfTNHFdFwDTNCkUCkQikZbWl2J94urqilKphOu6JJNJRkZGcF0X27apVCpUq1WmpqZ6Pc2OchwHy7IA0DQN3/fxPO/54GmlXN8q1vb2Nuvr6wCsra0BvFheWlr6zmY/tbGx8eH46upqR/Pq9Tp7e3uoqophGCQSiRfjt7e37O7uUiqVOpr7d/6/ma2MtcN1XSzLwvM8CoUCxWIRgNnZWUzTxLIsDMNAVdUPtyM37x8ol8uEQiEWFhZe7cR6vY7neaTTaZrNZsezbdvGsiwODw9fjR0cHGBZFrZtdzwXIBKJkM/niUaj+L6PoijEYrGWz1Ygl8J3OY7Dzc0NExMT6Lr+anx/f5+7u7vnZVVV0TStY/m6rjM8PMzZ2RnhcBhFUQA4Ojri/PycVCr15rzapaoq+Xz+xWdPT/10XX819h4p1jsajQYDAwOkUqk3x+fm5l6cqTRN+/Ty8BWKojA/P0+xWOTk5IRwOIzv+1xfXzM2NkY2m+1YVhCkWO/47OgM4v7mLU8FqlarAKTTaWZmZrqS3Q4p1i+QzWbp7+8HHovVTePj43znBRgp1hdcXl5SLpdRFIVMJsPQ0FDXsrtdqCejo6PfWk+K9QWlUomHhwfg8ZfZyspKV3JrtRrHx8eEw2EymQzJZPLH5yryol/rtra2cBwHgFgsxvLycldyNzc38TwPeLz3W1xc/PG58j/WF0xPTxOLxdB1nUwm07XcUKg3u6mdXDlj/QK1Wo1KpfJ8SerW88h2cqVYIhByKRSBkGKJQEixRCCkWCIQUiwRCCmWCMQf0sgg9cuvoIEAAAAASUVORK5CYII="
+ },
+ "b25aea2c-891f-447e-a405-91fa95ba1b27.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAB0AAAAYCAYAAAAGXva8AAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDExOjU5OjUyIEFNIENEVG9kKZwAAAG3SURBVEiJ7ZU7SyNRFIC/zAwhQiLJBpX4Ykt39Reo4KO3UDSx8Uf4gG00u7JsoWhvb6GJkMpKG8UHNoKCGtwtBN/ohqwZcBIZ5lqEXQnqeAcxq+Apz718H+fce891CSEERQ6l2MJ36bv0/0jF9RWpaBvmcfJfzjxOkoq2IwxdmqM5kaKoAKRGWnF/agbgJrmKVtsALtcLSYVAGDrW1QXZjcRd2tABealLZiLd7Cyhx75h/TnHPNl/cI9WVYfir8DXO4q7vsWW56hS8/QXAEppGVrN53zuaA8rc4l5+hO3v0KKI1Xp3zjryrfQ0xQmMBgDID0ZIbsWByCUkENJSbNrcdKTESlgYCiOp7Hn+VIrc4l5uEsq2gaAu6EVX/grAHp8FCvzG2/nF9RgNVptPUppmS3P2XBQ718BNRAi+H2Z3NYC6fEujKXpJzFy7V2fIz0RfnDN1zeGebiDsXwn8w/MUNLc+yhPqlJPYw+hhKB86gDFFyxYUz9UktucL8jlthdteY7aq5Z/JPhjhZKmCEogBOTP29s9XLDP29Fvy3H0ZOzCWJ0lt72It6M/PxaLIXUSr/9re9PSW+9hoKu52EnDAAAAAElFTkSuQmCC"
+ },
+ "d4c26cbe-f2b6-477f-960b-1758b11853e0.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAbCAYAAABiFp9rAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjEyOjM0IFBNIENEVE7dEU8AAAFlSURBVEiJ7dS/y0FRGMDxr/cyXzZX3Ymibjb5AxSrzcLuD1AGf4JJNtONMihlN0jZDSYZ0C2lkBK3uOqaXov34rzDHeSZzuk553zO0/nhsW3bxoX4cQP5Qo5hmibT6RTTNB3HeN9ZyLIshsMh/X6f3W6H3+9HVVUikQiZTAbDMKhWq5TLZWKx2P+gyWSCruscDgc0TSORSHA8Hlkul/R6PUajEdls9uVmn0KLxYJ6vY4sy1QqFcLh8EO+VqvRbDZfQk/PqNPp4PP5KJVKD8h8Pud8PpNKpbhery8hx4r2+z2z2Yx0Ok0oFHrINxoNNpvNvR8IBFAURRw6nU5Eo1GSyeSf+WKxyOVyufcVRUGWZUfI83Ff0Fvv6DfG4zHdbhdJksjlcsTj8bfnClXUarVYr9esViva7bbIVDFIkqR7W/RohaBCoUAwGERVVfL5vBD0ebfuC30h9yHvYDBwBfJst1tXHuwNToSCN+PeLD4AAAAASUVORK5CYII="
+ },
+ "e535eef7-4136-4ece-a1fd-f4d4f3259ad5.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAbCAYAAABiFp9rAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjEzOjM0IFBNIENEVI9Tzo8AAAC4SURBVEiJ7dUhCoVAFIXh36dtQLC4EaPBTThbcBOzCYvRYHMVgsHoMiwyIAhGGdPrKszAe8zph++kewNjjMFBPi4QD/0R1Pc953nah7ZtQynFPM92IYB1XWmahrZt2ffdHvTNNE0opRjH0S4EcBwHXddR1zXLstiD3iR6UxJCUJYlRVHYg/I8R0pJHMePerehNE2RUpJl2dNt96EkSaiqijAMXyEAgf9HHvLQ70DRMAxOoEBr7eQyXM/+OREmn9GvAAAAAElFTkSuQmCC"
+ },
+ "f3649896-c4f8-4e83-a695-8c629044e611.png": {
+ "image/png": "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"
+ },
+ "fc577085-ab22-4961-ad11-7ef72fca0505.png": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJYAAAAbCAYAAACeL3bkAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAtdEVYdENyZWF0aW9uIFRpbWUAU3VuIDE1IFNlcCAyMDI0IDEyOjIyOjU5IFBNIENEVNFcr+QAAAPbSURBVGiB7drNSzJrGAbwa/RURqBNRDnZEJTQF62kNhaRUP0DmUEurEW1CiQw+3DRplFXEbRoUaCQWERuWkVBEC3cVLSSCCOXpQ0GGvbhvIuD8h56T6dsRj3x/Hbjw3Pfj+PlfDGUIAgCCEJkskIvgPiZSLAISZBgEZIgwSIkQYJFSIIESwTJZBKhUAjJZFKyHi6XC263W7L6fxKNRmG1WmG1WhGNRr809y+J1vSjvLy84Pj4GAcHB4jFYqisrATLstBqtRgYGEAkEoHb7YbNZkNLS0uhlysKnufBcRzi8TgAgOM4LC4ugqbpT83P+Yjl9/vx9vaW6/T/jcvLS9hsNvj9fjAMg8HBQbS3t+Ph4QGBQAAOhwOxWKzQyxRVJlQAoFarwTAM0uk0nE4neJ7/VI2cj1g8z2NhYQFGoxE6nS7XMl8yPj7+4fjm5qao/W5ubrC6ugqVSoX5+Xk0NTW9G19ZWYHH4xG1b8b19TW0Wm12m6IoAIAgCAiHw+/WI4Z4PA6O45BKpeBwOLL7dHp6GsvLy3C5XJibm4NKpfqwzreuse7u7rC2toaNjQ08Pj5+p1RR2t7eRklJCWZmZt79iOFwGKlUCgaDAa+vr6L3vr29hdPphM/nezfm8/nAcRwikYjofSmKQlVVFex2O6qrqyEIAmQyGWpra2Gz2UDTdDbgHxHlGuv09BQXFxcYGhpCb2+vGCULjud5XF1dob+/H3V1de/G19fXcX9/n92maRoMw4jWn2VZ6HQ6HB4eQqFQgKIoCIKAnZ0dHB0dobOzEyzLitYvQ6lUwm63/+OzdDoNANBoNJidnf1UHdEu3hOJBDweD87Pz2E0GqHRaMQqXRCJRALNzc3o6ur64/jk5CSen5+z2wzD/Ofp4StkMhmmpqagUCiwv7+P0tJSCIKAUCiEnp4eWCyWTx05CoXcFf6L+vr6D/+djY2Nkq+BoihYLBYAwMnJCQCgr68PZrO5qEMFiBisioqKH3UqLBYURWFsbAwNDQ0AAIPBkNf+3d3dOc0TJVh6vR5GoxFKpVKMckXr7OwMu7u7kMvlGB4eRkdHR9565ztQGXq9Pqd53wpWTU1NXh83FJrX683e/W5tbcHpdOalbzAYRCAQQFlZGUwmE9ra2oq+b87BomkaExMTkMvluZb4MrGfU33V7981n+9Her1ePD09Afj7EcjS0lLR9835OdbIyEheQ1UMzGYz1Go1WJbF6Oho3vr+vp8zt/7F3pciryYXv2AwiL29PZSXl8NkMqG1tbXo+5JgEZIgr80QkiDBIiRBgkVIggSLkAQJFiEJEixCEr8AFZFOmXk+Z0EAAAAASUVORK5CYII="
+ }
+ },
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Tracing Code Execution Using the Debugger\n",
+ "\n",
+ "Tracing code is the process of working through by hand the order that lines of code will be executed. A debugger can be very helpful in this process.\n",
+ "\n",
+ " 1. Turn on the debugger and open the debugger sidepanel.\n",
+ " \n",
+ " \n",
+ " \n",
+ " 2. Add a breakpoint to your code. Do this by clicking on the line number of a line of code within the cell. A red dot should appear next to that line of code. Now, when you run the code in the cell when that line is reached the debugger will stop executing your code.\n",
+ " \n",
+ " \n",
+ " \n",
+ " 3. Click the run button (or press shift-enter) to start running the code in the cell. The code will run up to the line where you added a breakpoint and will then stop.\n",
+ " 4. Use the buttons in the bebugger sidepanel next to the \"callstack\" section in the side panel to control the continued execution of the code:\n",
+ " -  (**next**) - Run the next line of code.\n",
+ " -  (**step-into**) - If a line of code calls a function, go into that function stop on the first line of code within the function.\n",
+ " -  (**step-out**) - Execute all lines of code of the function you are currently in and stop at the first line of code outside of the function.\n",
+ " -  (**continue**) - Run the code until you reach the next breakpoint\n",
+ " -  (**terminate**) - stop running the code.\n",
+ "\n",
+ "Be aware if the buttons are greyed out or not. This is another way you can tell if the kernel is still busy trying to execute the code in the cell. Even after every line of code in the cell has finished executing, you will still need to continue stepping until the kernel is free (or you can click the stop button).\n",
+ "\n",
+ " (kernel is still busy with the code in the cell)\n",
+ "\n",
+ " (kernel has finished executing the code in the cell)\n",
+ "\n",
+ "Follow along as we use the debugger on the code cell below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "A1\n",
+ "B1\n",
+ "C\n",
+ "B2\n",
+ "A2\n"
+ ]
+ }
+ ],
+ "source": [
+ "def func_c():\n",
+ " print(\"C\")\n",
+ "\n",
+ "def func_b():\n",
+ " print(\"B1\")\n",
+ " func_c()\n",
+ " print(\"B2\")\n",
+ "\n",
+ "def func_a():\n",
+ " print(\"A1\")\n",
+ " func_b()\n",
+ " print(\"A2\")\n",
+ "\n",
+ "func_a()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## You Try It\n",
+ "\n",
+ "For the code cells below, can you think through what will be printed, and in what order? Use the debugger to set a breakpoint and step through the lines of code and see if it is executed and the output is printed in the order that you thought."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "A\n",
+ "C\n",
+ "B\n",
+ "D\n",
+ "B\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"A\")\n",
+ "\n",
+ "def foo():\n",
+ " print(\"B\")\n",
+ "print(\"C\")\n",
+ "foo()\n",
+ "print(\"D\")\n",
+ "foo()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "A\n",
+ "B\n",
+ "C\n",
+ "D\n",
+ "B\n",
+ "C\n"
+ ]
+ }
+ ],
+ "source": [
+ "#Almost the same as the last cell but the print(\"C\") has been indented\n",
+ "print(\"A\")\n",
+ "\n",
+ "def foo():\n",
+ " print(\"B\")\n",
+ " print(\"C\")\n",
+ "foo()\n",
+ "print(\"D\")\n",
+ "foo()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "D\n",
+ "A\n",
+ "E\n",
+ "B\n"
+ ]
+ }
+ ],
+ "source": [
+ "def f():\n",
+ " print(\"A\")\n",
+ " return \"B\" \n",
+ " print(\"C\")\n",
+ "print(\"D\")\n",
+ "x = f()\n",
+ "print(\"E\")\n",
+ "print(x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Summary\n",
+ "\n",
+ "You have learned how to **define a function** and what the different portions of the definition are called (header, body, parameters, default value, return). You know how to **pass values by position, keyword, or use the default value**. You know the difference between and **fruitful function and a void function** and the difference between using a print statement and a return statement. You have practiced **using the debugger to step through execution** of Python code.\n"
+ ]
+ }
+ ],
+ "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.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}