05-functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8z5cONg8rUrX",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions\n",
    "\n",
    "## Programming Fundamentals (NB05)\n",
    "\n",
    "### MIEIC/2020-21\n",
    "\n",
    "#### João Correia Lopes\n",
    "\n",
    "FEUP/DEI and INESC TEC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MZzE7pYorju5",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Goals\n",
    "\n",
    "By the end of this class, the student should be able to:\n",
    "\n",
    "\n",
    "- Describe function definition and formal parameters\n",
    "\n",
    "- Describe function body and local variables\n",
    "\n",
    "- Describe function call, actual parameters or arguments and the flow\n",
    "    of execution\n",
    "\n",
    "- Describe void functions and fruitful functions that return values\n",
    "\n",
    "- Use the Python Help and understand its meta-notation\n",
    "\n",
    "- Describe the basics of program debugging\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eR5Lh1jNroE2",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Bibliography\n",
    "\n",
    "- Peter Wentworth, Jeffrey Elkner, Allen B. Downey, and Chris Meyers, *How to Think Like a Computer Scientist — Learning with Python 3* (Chapter 4, Section 3.3.8)\n",
    "\n",
    "- Brad Miller and David Ranum, Learning with Python: Interactive Edition. Based on material by Jeffrey Elkner, Allen B. Downey, and Chris Meyers (Chapter 6, Chapter 3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5-x3RnJ0WpW5",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Help & debug"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZtOFJ3RaWIJi",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 3.3.8 Help & Meta-notation\n",
    "\n",
    "- Python comes with extensive documentation for all its built-in\n",
    "    functions, and its libraries.\n",
    "\n",
    "- See for example\n",
    "    [[docs.python.org/3/library/\\...range](https://docs.python.org/3/library/stdtypes.html#typesseq-range)]\n",
    "    \n",
    "- The square brackets (in the description of the arguments) are\n",
    "    examples of *meta-notation* --- notation that describes Python\n",
    "    syntax, but is not part of it\n",
    "\n",
    "    -   `range([start,] stop [, step])`\n",
    "\n",
    "    -   `for variable in list :`\n",
    "\n",
    "    -   `print( [object, ... ] )`\n",
    "\n",
    "-   Meta-notation gives us a concise and powerful way to describe the\n",
    "    *pattern* of some syntax or feature."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2RRDA-HfW7Og",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### How to be a Successful Programmer\n",
    "\n",
    "- One of the most important skills you need to aquire is the ability\n",
    "    to debug your programs\n",
    "\n",
    "- Debugging is a skill that you need to master over time\n",
    "\n",
    "- As programmers we spend 99% of our time trying to get our program to\n",
    "    work\n",
    "\n",
    "- But here is the secret, when you are successful, you are happy, your\n",
    "    brain releases a bit of chemical that makes you feel good\n",
    "\n",
    "- **Start small, get something small working, and then add to it**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KryyOvPAXDal",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### How to Avoid Debugging\n",
    "\n",
    "\n",
    ">Mantra: Get something working and keep it working\n",
    "\n",
    "- **Start Small**\n",
    "\n",
    "    - This is probably the single biggest piece of advice for\n",
    "        programmers at every level.\n",
    "\n",
    "- **Keep it working**\n",
    "\n",
    "    - Once you have a small part of your program working the next step\n",
    "        is to figure out something small to add to it.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4VWan9AmXeWA",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Beginning tips for Debugging\n",
    "\n",
    "Debugging a program is a different way of thinking than writing a\n",
    "program.\n",
    "\n",
    "The process of debugging is much more like being a detective.\n",
    "\n",
    "1. Everyone is a suspect (Except Python)!\n",
    "\n",
    "2. Find clues\n",
    "\n",
    "    -   Error messages\n",
    "\n",
    "    -   Print statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kqDH7CMXXk8h",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Summary on debugging\n",
    "\n",
    "- Make sure you take the time to understand error messages\n",
    "\n",
    "    - They can help you a lot\n",
    "\n",
    "- `print` statements are your friends\n",
    "\n",
    "    - Use them to help you uncover what is **really** happening in\n",
    "        your code\n",
    "\n",
    "- Work backward from the error\n",
    "\n",
    "    - Many times an error message is caused by something that has\n",
    "        happened before it in the program\n",
    "\n",
    "    - Always remember that python evaluates a program top to bottom"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fxtTHNoKPrAL",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 4. Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UU97kB5o7v_n",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 4.1 Functions\n",
    "\n",
    "- A *function* is a named sequence of statements that belong together\n",
    "\n",
    "- Their primary purpose is to help us organize programs into chunks\n",
    "    that match how we think about the problem\n",
    "\n",
    "- The syntax for a function definition is:\n",
    "\n",
    "```\n",
    "   def <NAME>( <PARAMETERS> ):\n",
    "       <STATEMENTS>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7CiUOTCpB-Pr",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Runestone Interactive vídeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5ZomfzYWB5Zi",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('4wKtB57J5J4')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dmwqYSHc9bM-",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Function definitions\n",
    "\n",
    "- Function definitions are **compound statements**<sup>1</sup> which follow\n",
    "    the pattern:\n",
    "\n",
    "    1.  A **header** line which begins with the keyword **def** and ends with a\n",
    "        *colon*\n",
    "\n",
    "    2.  A **body** consisting of *one or more* Python statements, each\n",
    "        *indented* the same amount from the header line\n",
    "\n",
    "\n",
    "<sup>1</sup> as was the case with `for` before\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "e_7A01TK9jer",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Draw a square\n",
    "\n",
    "\n",
    "- Suppose we're working with turtles, and a common operation we need\n",
    "    is to *draw squares*\n",
    "\n",
    "- \"Draw a square\" is an abstraction, or a mental chunk, of a number of\n",
    "    smaller steps\n",
    "\n",
    "- So let's write a function to capture the pattern of this \"building\n",
    "    block\"\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/05/turles.py>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7DgYrnW0cOBP",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import turtle\n",
    "\n",
    "def draw_square(t, sz):\n",
    "    \"\"\"Make turtle t draw a square of with side sz.\"\"\"\n",
    "    for i in range(4):\n",
    "        t.forward(sz)\n",
    "        t.left(90)\n",
    "\n",
    "wn = turtle.Screen()      # Set up the window and its attributes\n",
    "wn.setup(600, 600)        # Set the size of the screen window\n",
    "wn.bgcolor(\"lightgreen\")  # Set the background color\n",
    "\n",
    "alex = turtle.Turtle()    # Create alex\n",
    "draw_square(alex, 50)     # Call the function to draw the square passing\n",
    "                          #  the actual turtle and the actual side size\n",
    "draw_square(alex, 75)     # Draw another square\n",
    "\n",
    "wn.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_gMkNMkn9pm_",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### *Docstrings* for documentation\n",
    "\n",
    "- If the first thing after the function header is a string, it is\n",
    "    treated as a **docstring** and gets special treatment\n",
    "\n",
    "- *Docstrings* are usually formed using triple-quoted strings\n",
    "\n",
    "- *Docstrings* are the key way to document our functions in Python and\n",
    "    the documentation part is important\n",
    "\n",
    "- *docstrings* are not comments:\n",
    "\n",
    "    - a string at the start of a function (a *docstring*) is retrievable\n",
    "        by Python tools *at runtime*\n",
    "\n",
    "    - comments are completely eliminated when the program is parsed\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cg8s3YmO91s_",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Function call\n",
    "\n",
    "\n",
    "- Defining the function just tells Python *how* to do a particular\n",
    "    task, not to *perform* it\n",
    "\n",
    "- In order to execute a function we need to make a **function call**\n",
    "\n",
    "- Function calls contain the name of the function being executed\n",
    "    followed by a list of values, called *arguments* (**actual\n",
    "    parameters**), which are assigned to the parameters in the function\n",
    "    definition (**formal parameters**)\n",
    "\n",
    "- Once we've defined a function, we can call it as often as we like,\n",
    "    and its statements will be executed each time we call it\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/05/moreturtles.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZKXE3UeN96q6",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Abstraction\n",
    "\n",
    "- The following diagram is often called a **black-box diagram**\n",
    "    because it only states the requirements from the perspective of the\n",
    "    user\n",
    "\n",
    "- The user must know the name of the function and what arguments need\n",
    "    to be passed\n",
    "\n",
    "- The details of how the function works are hidden inside the\n",
    "    \"black-box\"\n",
    "\n",
    "![blackbox](images/05/blackbox.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0YqTw30071Z-",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 4.2 Functions can call other functions\n",
    "\n",
    "A Square is a (special) Rectangle\n",
    "\n",
    "- Let's assume now we want a function to draw a rectangle\n",
    "\n",
    "- We may use it to draw a square\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/05/rectangle.py>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "paSQokz9gh3E",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import turtle\n",
    "\n",
    "\n",
    "def draw_rectangle(animal, width, height):\n",
    "    \"\"\"Get animal to draw a rectangle of given width and height.\"\"\"\n",
    "    for _ in range(2):\n",
    "        animal.forward(width)\n",
    "        animal.left(90)\n",
    "        animal.forward(height)\n",
    "        animal.left(90)\n",
    "\n",
    "\n",
    "wn = turtle.Screen()             # Set up the window and its attributes\n",
    "wn.bgcolor(\"lightgreen\")\n",
    "tess = turtle.Turtle()           # create tess and set some attributes\n",
    "tess.pensize(3)\n",
    "\n",
    "draw_rectangle(tess, 200, 80)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lFVY4l0AgpP6",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def draw_square(animal, size):   # A new version of draw_square\n",
    "    draw_rectangle(animal, size, size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "SSgrOgdrgwRJ",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def move_n_draw(animal, x, y):\n",
    "    \"\"\" Get an animal to go to (x,y) and draw a square 80x80 \"\"\"\n",
    "    animal.penup()\n",
    "    animal.goto(x, y)\n",
    "    animal.pendown()\n",
    "    draw_square(animal, 80)\n",
    "\n",
    "\n",
    "move_n_draw(tess, 120, 100)\n",
    "move_n_draw(tess, 120, -100)\n",
    "move_n_draw(tess, 0, -100)\n",
    "move_n_draw(tess, 0, 100)\n",
    "move_n_draw(tess, -100, 0)\n",
    "\n",
    "wn.mainloop()\n",
    "turtle.done()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bsH-_Dky75Jj",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 4.3 Flow of execution\n",
    "\n",
    "- Execution always begins at the first statement of the program\n",
    "\n",
    "- Statements are executed one at a time, in order from top to bottom\n",
    "\n",
    "- Function definitions do not alter the flow of execution of the\n",
    "    program\n",
    "\n",
    "    - Statements inside the function are not executed until the\n",
    "        function is called\n",
    "\n",
    "- Function calls are like a detour in the flow of execution\n",
    "\n",
    "    - Instead of going to the next statement, the flow jumps to the\n",
    "        first line of the called function, executes all the statements\n",
    "        there, and then comes back to pick up where it left off.\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/05/pytutor.py>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ymc_fjCLg9uZ",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    y = x * x\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PSxNH-YVhAFo",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def sum_of_squares(x, y, z):\n",
    "    a = square(x)\n",
    "    b = square(y)\n",
    "    c = square(z)\n",
    "    return a + b + c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XxdYwEx8hClR",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = -5\n",
    "b = 2\n",
    "c = 10\n",
    "result = sum_of_squares(a, b, c)\n",
    "print(result)\n",
    "\n",
    "# visualise it in http://www.pythontutor.com/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7W8Kt2Bh-6VU",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Trace a program\n",
    "\n",
    "> **Moral**:\n",
    ">\n",
    "> To read a program, don't read from top to bottom.\n",
    ">\n",
    "> Instead, follow the flow of execution.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LhHvh7At7869",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 4.4 Functions that require arguments\n",
    "\n",
    "- Most functions require arguments: the arguments provide for\n",
    "    generalisation\n",
    "\n",
    "- Some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XluI2Hsdc0Fs",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(abs(5))\n",
    "\n",
    "print(abs(-5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kMmOsVNEc8bg",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "print(math.pow(2, 3))\n",
    "print(math.pow(7, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "k_BKxlbMdC-A",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(max(7, 11))\n",
    "print(max(4, 1, 17, 2, 12))\n",
    "print(max(3 * 11, 5 ** 3, 512 - 9, 1024 ** 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "D0tIb4d48AhK",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 4.5 Functions that return values\n",
    "\n",
    "- A function that returns a value is called a **fruitful function**\n",
    "\n",
    "- The opposite of a fruitful function is **void function** --- one\n",
    "    that is not executed for its resulting value (e.g. `draw_square`)\n",
    "\n",
    "- Python will automatically return the value `None` for void functions\n",
    "    (aka *procedures*)\n",
    "\n",
    "- Most of the time, calling functions generates a value, which we\n",
    "    usually assign to a variable or use as part of an expression\n",
    "\n",
    "- Procedures do not return useful values but may have (ugly) side-effects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fQmTTDLadvAZ",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "biggest = max(3, 7, 2, 5)\n",
    "\n",
    "x = abs(3 - 11) + 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "K1F2rfggd-E6",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(biggest)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VsGGwH-s_o1U",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Interest rates\n",
    "\n",
    " The standard formula for compound interest:\n",
    "$$A = P \\left(1 + \\frac{r}{n}\\right)^{nt}$$\n",
    "\n",
    "Where:\n",
    "\n",
    "- P = principal amount (initial investment)\n",
    "\n",
    "- r = annual nominal interest rate (as a decimal)\n",
    "\n",
    "- n = the number of times the interest is compounded per year\n",
    "\n",
    "- t = the number of years that the interest is calculated for\n",
    "\n",
    "\n",
    "Recall your implementation without functions. Cumbersome,\n",
    "right?\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/05/interests.py>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mut2adCpioqv",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def final_amount(p, r, n, t):\n",
    "    a = p * (1 + r/n) ** (n*t)\n",
    "    return a\n",
    "\n",
    "to_invest = float(input(\"How much do you want to invest?\"))\n",
    "fnl = final_amount(to_invest, 0.02, 12, 5)\n",
    "print(\"At the end of the period you'll have\", fnl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xrVoJGhq8ErU",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 4.6 Variables and parameters are local\n",
    "\n",
    "- When we create a local variable inside a function, it only exists\n",
    "    inside the function, and we cannot use it outside\n",
    "\n",
    "- For example, consider again this function:\n",
    "\n",
    "\n",
    "```\n",
    "  def final_amount(p, r, n, t):\n",
    "      a = p * (1 + r/n) ** (n*t)\n",
    "      return a\n",
    "```\n",
    "\n",
    "- If we try to use `a`, outside the function, we'll get an error\n",
    "\n",
    "- `a` only exists while the function is being executed --- its\n",
    "    **lifetime**\n",
    "\n",
    "- When the execution of the function terminates, the local variables\n",
    "    are destroyed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TrrIQa1XejSh",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    y = x * x\n",
    "    return y\n",
    "\n",
    "z = square(10)\n",
    "print(y)        # what do you get here?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ELWEZP-0AlvY",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Variables and parameters are local (2)\n",
    "\n",
    "\n",
    "- Parameters are also local, and act like local variables\n",
    "\n",
    "- Remember, `pythontutor` is your friend!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qea3lfqefE6C",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    y = x * x\n",
    "    x = 0       # assign a new value to the parameter x\n",
    "    return y\n",
    "\n",
    "x = 2\n",
    "z = square(x)\n",
    "print(x, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "e4ZuRg_5ev03",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "$\\Rightarrow$\n",
    "http://pythontutor.com/visualize.html#mode=edit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ut2WGZ3k8H7-",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 4.7 Turtles Revisited\n",
    "\n",
    "- Now that we have fruitful functions, we can focus our attention on\n",
    "    reorganizing our code so that it fits more nicely into our mental\n",
    "    chunks\n",
    "\n",
    "- This process of rearrangement is called **refactoring** the code\n",
    "\n",
    "\n",
    "> Two things we’re always going to want to do when working with turtles is to create the window \n",
    "> for the turtle, and to create one or more turtles. \n",
    "> We could write some functions to make these tasks easier in future:\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/05/refactoring.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Zz-UtV8ORH_t",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Ticket to leave"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C-hchAExRRVh",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Moodle activity\n",
    "\n",
    "[LE05: Functions](https://moodle.up.pt/course/view.php?id=1738#section-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uV1OP6ahRYne",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "\n",
    "$\\Rightarrow$ \n",
    "[Go back to the Table of Contents](00-contents.ipynb)\n",
    "\n",
    "$\\Rightarrow$ \n",
    "[Read the Preface](00-preface.ipynb)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "05-functions.ipynb",
   "private_outputs": true,
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "rise": {
   "enable_chalkboard": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}