chapters/chap03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1331faa1",
   "metadata": {},
   "source": [
    "You can order print and ebook versions of *Think Python 3e* from\n",
    "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n",
    "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "103cbe3c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from os.path import basename, exists\n",
    "\n",
    "def download(url):\n",
    "    filename = basename(url)\n",
    "    if not exists(filename):\n",
    "        from urllib.request import urlretrieve\n",
    "\n",
    "        local, _ = urlretrieve(url, filename)\n",
    "        print(\"Downloaded \" + str(local))\n",
    "    return filename\n",
    "\n",
    "download('https://github.com/AllenDowney/ThinkPython/raw/v3/thinkpython.py');\n",
    "download('https://github.com/AllenDowney/ThinkPython/raw/v3/diagram.py');\n",
    "\n",
    "import thinkpython"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bd858a8",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "In the previous chapter we used several functions provided by Python, like `int` and `float`, and a few provided by the `math` module, like `sqrt` and `pow`.\n",
    "In this chapter, you will learn how to create your own functions and run them.\n",
    "And we'll see how one function can call another.\n",
    "As examples, we'll display lyrics from Monty Python songs.\n",
    "These silly examples demonstrate an important feature -- the ability to write your own functions is the foundation of programming.\n",
    "\n",
    "This chapter also introduces a new statement, the `for` loop, which is used to repeat a computation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4ea99c5",
   "metadata": {},
   "source": [
    "## Defining new functions\n",
    "\n",
    "A **function definition** specifies the name of a new function and the sequence of statements that run when the function is called. Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d28f5c1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_lyrics():\n",
    "    print(\"I'm a lumberjack, and I'm okay.\")\n",
    "    print(\"I sleep all night and I work all day.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0174fc41",
   "metadata": {},
   "source": [
    "`def` is a keyword that indicates that this is a function definition.\n",
    "The name of the function is `print_lyrics`.\n",
    "Anything that's a legal variable name is also a legal function name.\n",
    "\n",
    "The empty parentheses after the name indicate that this function doesn't take any arguments.\n",
    "\n",
    "The first line of the function definition is called the **header** -- the rest is called the **body**.\n",
    "The header has to end with a colon and the body has to be indented. By convention, indentation is always four spaces. \n",
    "The body of this function is two print statements; in general, the body of a function can contain any number of statements of any kind.\n",
    "\n",
    "Defining a function creates a **function object**, which we can display like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2850a402",
   "metadata": {},
   "outputs": [],
   "source": [
    "print_lyrics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12bd0879",
   "metadata": {},
   "source": [
    "The output indicates that `print_lyrics` is a function that takes no arguments.\n",
    "`__main__` is the name of the module that contains `print_lyrics`.\n",
    "\n",
    "Now that we've defined a function, we can call it the same way we call built-in functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9a048657",
   "metadata": {},
   "outputs": [],
   "source": [
    "print_lyrics()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f0fc45d",
   "metadata": {},
   "source": [
    "When the function runs, it executes the statements in the body, which display the first two lines of \"The Lumberjack Song\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d35193e",
   "metadata": {},
   "source": [
    "## Parameters\n",
    "\n",
    "Some of the functions we have seen require arguments; for example, when you call `abs` you pass a number as an argument.\n",
    "Some functions take more than one argument; for example, `math.pow` takes two, the base and the exponent.\n",
    "\n",
    "Here is a definition for a function that takes an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e5d00488",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_twice(string):\n",
    "    print(string)\n",
    "    print(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1716e3dc",
   "metadata": {},
   "source": [
    "The variable name in parentheses is a **parameter**.\n",
    "When the function is called, the value of the argument is assigned to the parameter.\n",
    "For example, we can call `print_twice` like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a3ad5f46",
   "metadata": {},
   "outputs": [],
   "source": [
    "print_twice('Dennis Moore, ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f02be6d2",
   "metadata": {},
   "source": [
    "Running this function has the same effect as assigning the argument to the parameter and then executing the body of the function, like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "042dfec1",
   "metadata": {},
   "outputs": [],
   "source": [
    "string = 'Dennis Moore, '\n",
    "print(string)\n",
    "print(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea8b8b6e",
   "metadata": {},
   "source": [
    "You can also use a variable as an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8f078ad0",
   "metadata": {},
   "outputs": [],
   "source": [
    "line = 'Dennis Moore, '\n",
    "print_twice(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c1884ad",
   "metadata": {},
   "source": [
    "In this example, the value of `line` gets assigned to the parameter `string`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3e5a790",
   "metadata": {},
   "source": [
    "## Calling functions\n",
    "\n",
    "Once you have defined a function, you can use it inside another function.\n",
    "To demonstrate, we'll write functions that print the lyrics of \"The Spam Song\" (<https://www.songfacts.com/lyrics/monty-python/the-spam-song>).\n",
    "\n",
    "> Spam, Spam, Spam, Spam,  \n",
    "> Spam, Spam, Spam, Spam,  \n",
    "> Spam, Spam,  \n",
    "> (Lovely Spam, Wonderful Spam!)  \n",
    "> Spam, Spam,\n",
    "\n",
    "We'll start with the following function, which takes two parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e86bb32c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def repeat(word, n):\n",
    "    print(word * n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdd4daa4",
   "metadata": {},
   "source": [
    "We can use this function to print the first line of the song, like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ec117999",
   "metadata": {},
   "outputs": [],
   "source": [
    "spam = 'Spam, '\n",
    "repeat(spam, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6f81e09",
   "metadata": {},
   "source": [
    "To display the first two lines, we can define a new function that uses `repeat`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3731ffd8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def first_two_lines():\n",
    "    repeat(spam, 4)\n",
    "    repeat(spam, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8058ffe4",
   "metadata": {},
   "source": [
    "And then call it like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6792e63b",
   "metadata": {},
   "outputs": [],
   "source": [
    "first_two_lines()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07ca432a",
   "metadata": {},
   "source": [
    "To display the last three lines, we can define another function, which also uses `repeat`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2dcb020a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def last_three_lines():\n",
    "    repeat(spam, 2)\n",
    "    print('(Lovely Spam, Wonderful Spam!)')\n",
    "    repeat(spam, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9ff8c60e",
   "metadata": {},
   "outputs": [],
   "source": [
    "last_three_lines()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6456a19",
   "metadata": {},
   "source": [
    "Finally, we can bring it all together with one function that prints the whole verse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "78bf3a7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_verse():\n",
    "    first_two_lines()\n",
    "    last_three_lines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ba5da431",
   "metadata": {},
   "outputs": [],
   "source": [
    "print_verse()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d088fe68",
   "metadata": {},
   "source": [
    "When we run `print_verse`, it calls `first_two_lines`, which calls `repeat`, which calls `print`.\n",
    "That's a lot of functions.\n",
    "\n",
    "Of course, we could have done the same thing with fewer functions, but the point of this example is to show how functions can work together."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3b16e3f",
   "metadata": {},
   "source": [
    "## Repetition\n",
    "\n",
    "If we want to display more than one verse, we can use a `for` statement.\n",
    "Here's a simple example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "29b7eff3",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf320549",
   "metadata": {},
   "source": [
    "The first line is a header that ends with a colon.\n",
    "The second line is the body, which has to be indented.\n",
    "\n",
    "The header starts with the keyword `for`, a new variable named `i`, and another keyword, `in`. \n",
    "It uses the `range` function to create a sequence of two values, which are `0` and `1`.\n",
    "In Python, when we start counting, we usually start from `0`.\n",
    "\n",
    "When the `for` statement runs, it assigns the first value from `range` to `i` and then runs the `print` function in the body, which displays `0`.\n",
    "\n",
    "When it gets to the end of the body, it loops back around to the header, which is why this statement is called a **loop**.\n",
    "The second time through the loop, it assigns the next value from `range` to `i`, and displays it.\n",
    "Then, because that's the last value from `range`, the loop ends.\n",
    "\n",
    "Here's how we can use a `for` loop to print two verses of the song."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "038ad592",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(2):\n",
    "    print(\"Verse\", i)\n",
    "    print_verse()\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88a46733",
   "metadata": {},
   "source": [
    "You can put a `for` loop inside a function.\n",
    "For example, `print_n_verses` takes a parameter named `n`, which has to be an integer, and displays the given number of verses. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8887637a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_n_verses(n):\n",
    "    for i in range(n):\n",
    "        print_verse()\n",
    "        print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad8060fe",
   "metadata": {},
   "source": [
    "In this example, we don't use `i` in the body of the loop, but there has to be a variable name in the header anyway."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b320ec90",
   "metadata": {},
   "source": [
    "## Variables and parameters are local\n",
    "\n",
    "When you create a variable inside a function, it is **local**, which\n",
    "means that it only exists inside the function.\n",
    "For example, the following function takes two arguments, concatenates them, and prints the result twice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "0db8408e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cat_twice(part1, part2):\n",
    "    cat = part1 + part2\n",
    "    print_twice(cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a35a6d0",
   "metadata": {},
   "source": [
    "Here's an example that uses it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1c556e48",
   "metadata": {},
   "outputs": [],
   "source": [
    "line1 = 'Always look on the '\n",
    "line2 = 'bright side of life.'\n",
    "cat_twice(line1, line2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ab4e008",
   "metadata": {},
   "source": [
    "When `cat_twice` runs, it creates a local variable named `cat`, which is destroyed when the function ends.\n",
    "If we try to display it, we get a `NameError`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "73f03eea",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%expect NameError\n",
    "\n",
    "print(cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ae36c29",
   "metadata": {},
   "source": [
    "Outside of the function, `cat` is not defined. \n",
    "\n",
    "Parameters are also local.\n",
    "For example, outside `cat_twice`, there is no such thing as `part1` or `part2`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eabac8a6",
   "metadata": {},
   "source": [
    "## Stack diagrams\n",
    "\n",
    "To keep track of which variables can be used where, it is sometimes useful to draw a **stack diagram**. \n",
    "Like state diagrams, stack diagrams show the value of each variable, but they also show the function each variable belongs to.\n",
    "\n",
    "Each function is represented by a **frame**.\n",
    "A frame is a box with the name of a function on the outside and the parameters and local variables of the function on the inside.\n",
    "\n",
    "Here's the stack diagram for the previous example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "83df4e32",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from diagram import make_frame, Stack\n",
    "\n",
    "d1 = dict(line1=line1, line2=line2)\n",
    "frame1 = make_frame(d1, name='__main__', dy=-0.3, loc='left')\n",
    "\n",
    "d2 = dict(part1=line1, part2=line2, cat=line1+line2)\n",
    "frame2 = make_frame(d2, name='cat_twice', dy=-0.3, \n",
    "                    offsetx=0.03, loc='left')\n",
    "\n",
    "d3 = dict(s = line1+line2)\n",
    "frame3 = make_frame(d3, name='print_twice', \n",
    "                    offsetx=-0.28, offsety=-0.3, loc='left')\n",
    "\n",
    "d4 = {\"?\": line1+line2}\n",
    "frame4 = make_frame(d4, name='print', \n",
    "                    offsetx=-0.28, offsety=0, loc='left')\n",
    "\n",
    "stack = Stack([frame1, frame2, frame3, frame4], dy=-0.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "bcd5e1df",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from diagram import diagram, adjust\n",
    "\n",
    "\n",
    "width, height, x, y = [3.8, 2.91, 1.15, 2.66]\n",
    "ax = diagram(width, height)\n",
    "bbox = stack.draw(ax, x, y)\n",
    "#adjust(x, y, bbox)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "854fee12",
   "metadata": {},
   "source": [
    "The frames are arranged in a stack that indicates which function called\n",
    "which, and so on. Reading from the bottom, `print` was called by `print_twice`, which was called by `cat_twice`, which was called by `__main__` -- which is a special name for the topmost frame.\n",
    "When you create a variable outside of any function, it belongs to `__main__`.\n",
    "\n",
    "In the frame for `print`, the question mark indicates that we don't know the name of the parameter.\n",
    "If you are curious, ask a virtual assistant, \"What are the parameters of the Python print function?\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5690cfc0",
   "metadata": {},
   "source": [
    "## Tracebacks\n",
    "\n",
    "When a runtime error occurs in a function, Python displays the name of the function that was running, the name of the function that called it, and so on, up the stack.\n",
    "To see an example, I'll define a version of `print_twice` that contains an error -- it tries to print `cat`, which is a local variable in another function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "886519cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_twice(string):\n",
    "    print(cat)            # NameError\n",
    "    print(cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7c0713b",
   "metadata": {},
   "source": [
    "Now here's what happens when we run `cat_twice`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1fe8ee82",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This cell tells Jupyter to provide detailed debugging information\n",
    "# when a runtime error occurs, including a traceback.\n",
    "\n",
    "%xmode Verbose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d9082f88",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%expect NameError\n",
    "\n",
    "cat_twice(line1, line2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f4defcf",
   "metadata": {},
   "source": [
    "The error message includes a **traceback**, which shows the function that was running when the error occurred, the function that called it, and so on.\n",
    "In this example, it shows that `cat_twice` called `print_twice`, and the error occurred in a `print_twice`.\n",
    "\n",
    "The order of the functions in the traceback is the same as the order of the frames in the stack diagram.\n",
    "The function that was running is at the bottom."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "374b4696",
   "metadata": {},
   "source": [
    "## Why functions?\n",
    "\n",
    "It may not be clear yet why it is worth the trouble to divide a program into\n",
    "functions.\n",
    "There are several reasons:\n",
    "\n",
    "-   Creating a new function gives you an opportunity to name a group of\n",
    "    statements, which makes your program easier to read and debug.\n",
    "\n",
    "-   Functions can make a program smaller by eliminating repetitive code.\n",
    "    Later, if you make a change, you only have to make it in one place.\n",
    "\n",
    "-   Dividing a long program into functions allows you to debug the parts\n",
    "    one at a time and then assemble them into a working whole.\n",
    "\n",
    "-   Well-designed functions are often useful for many programs. Once you\n",
    "    write and debug one, you can reuse it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6dd486e",
   "metadata": {},
   "source": [
    "## Debugging\n",
    "\n",
    "Debugging can be frustrating, but it is also challenging, interesting, and sometimes even fun.\n",
    "And it is one of the most important skills you can learn.\n",
    "\n",
    "In some ways debugging is like detective work.\n",
    "You are given clues and you have to infer the events that led to the\n",
    "results you see.\n",
    "\n",
    "Debugging is also like experimental science.\n",
    "Once you have an idea about what is going wrong, you modify your program and try again.\n",
    "If your hypothesis was correct, you can predict the result of the modification, and you take a step closer to a working program.\n",
    "If your hypothesis was wrong, you have to come up with a new one.\n",
    "\n",
    "For some people, programming and debugging are the same thing; that is, programming is the process of gradually debugging a program until it does what you want.\n",
    "The idea is that you should start with a working program and make small modifications, debugging them as you go.\n",
    "\n",
    "If you find yourself spending a lot of time debugging, that is often a sign that you are writing too much code before you start tests.\n",
    "If you take smaller steps, you might find that you can move faster."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4e95e63",
   "metadata": {},
   "source": [
    "## Glossary\n",
    "\n",
    "**function definition:**\n",
    "A statement that creates a function.\n",
    "\n",
    "**header:**\n",
    " The first line of a function definition.\n",
    "\n",
    "**body:**\n",
    " The sequence of statements inside a function definition.\n",
    "\n",
    "**function object:**\n",
    "A value created by a function definition.\n",
    "The name of the function is a variable that refers to a function object.\n",
    "\n",
    "**parameter:**\n",
    " A name used inside a function to refer to the value passed as an argument.\n",
    "\n",
    "**loop:**\n",
    " A statement that runs one or more statements, often repeatedly.\n",
    "\n",
    "**local variable:**\n",
    "A variable defined inside a function, and which can only be accessed inside the function.\n",
    "\n",
    "**stack diagram:**\n",
    "A graphical representation of a stack of functions, their variables, and the values they refer to.\n",
    "\n",
    "**frame:**\n",
    " A box in a stack diagram that represents a function call.\n",
    " It contains the local variables and parameters of the function.\n",
    "\n",
    "**traceback:**\n",
    " A list of the functions that are executing, printed when an exception occurs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eca485f2",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "3f77b428",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This cell tells Jupyter to provide detailed debugging information\n",
    "# when a runtime error occurs. Run it before working on the exercises.\n",
    "\n",
    "%xmode Verbose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82951027",
   "metadata": {},
   "source": [
    "### Ask a virtual assistant\n",
    "\n",
    "The statements in a function or a `for` loop are indented by four spaces, by convention.\n",
    "But not everyone agrees with that convention.\n",
    "If you are curious about the history of this great debate, ask a virtual assistant to \"tell me about spaces and tabs in Python\".\n",
    "\n",
    "Virtual assistant are pretty good at writing small functions.\n",
    "\n",
    "1. Ask your favorite VA to \"Write a function called repeat that takes a string and an integer and prints the string the given number of times.\" \n",
    "\n",
    "2. If the result uses a `for` loop, you could ask, \"Can you do it without a for loop?\"\n",
    "\n",
    "3. Pick any other function in this chapter and ask a VA to write it. The challenge is to describe the function precisely enough to get what you want. Use the vocabulary you have learned so far in this book.\n",
    "\n",
    "Virtual assistants are also pretty good at debugging functions.\n",
    "\n",
    "1. Ask a VA what's wrong with this version of `print_twice`.\n",
    "\n",
    "    ```\n",
    "    def print_twice(string):\n",
    "        print(cat)\n",
    "        print(cat)\n",
    "    ```\n",
    "    \n",
    "And if you get stuck on any of the exercises below, consider asking a VA for help."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7157b09",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Write a function named `print_right` that takes a string named `text` as a parameter and prints the string with enough leading spaces that the last letter of the string is in the 40th column of the display."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "a6004271",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "428fbee5",
   "metadata": {},
   "source": [
    "Hint: Use the `len` function, the string concatenation operator (`+`) and the string repetition operator (`*`).\n",
    "\n",
    "Here's an example that shows how it should work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f142ce6a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print_right(\"Monty\")\n",
    "print_right(\"Python's\")\n",
    "print_right(\"Flying Circus\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b47467fa",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Write a function called `triangle` that takes a string and an integer and draws a pyramid with the given height, made up using copies of the string. Here's an example of a pyramid with `5` levels, using the string `'L'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "7aa95014",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b8146a0d",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "triangle('L', 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a28f635",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Write a function called `rectangle` that takes a string and two integers and draws a rectangle with the given width and height, made up using copies of the string. Here's an example of a rectangle with width `5` and height `4`, made up of the string `'H'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "bcedab79",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "73b0c0f6",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "rectangle('H', 5, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44a5de6f",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "The song \"99 Bottles of Beer\" starts with this verse:\n",
    "\n",
    "> 99 bottles of beer on the wall  \n",
    "> 99 bottles of beer  \n",
    "> Take one down, pass it around  \n",
    "> 98 bottles of beer on the wall  \n",
    "\n",
    "Then the second verse is the same, except that it starts with 98 bottles and ends with 97. The song continues -- for a very long time -- until there are 0 bottles of beer.\n",
    "\n",
    "Write a function called `bottle_verse` that takes a number as a parameter and displays the verse that starts with the given number of bottles.\n",
    "\n",
    "Hint: Consider starting with a function that can print the first, second, or last line of the verse, and then use it to write `bottle_verse`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "53424b43",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "61010ffb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee0076dd",
   "metadata": {
    "tags": []
   },
   "source": [
    "Use this function call to display the first verse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "47a91c7d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "bottle_verse(99)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42c237c6",
   "metadata": {
    "tags": []
   },
   "source": [
    "If you want to print the whole song, you can use this `for` loop, which counts down from `99` to `1`.\n",
    "You don't have to completely understand this example---we'll learn more about `for` loops and the `range` function later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "336cdfa2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for n in range(99, 0, -1):\n",
    "    bottle_verse(n)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b02510c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a7f4edf8",
   "metadata": {
    "tags": []
   },
   "source": [
    "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n",
    "\n",
    "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n",
    "\n",
    "Code license: [MIT License](https://mit-license.org/)\n",
    "\n",
    "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}