{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Chapter 11: Functions and scope\n",
"*We use an example from [this website](http://anh.cs.luc.edu/python/hands-on/3.1/handsonHtml/functions.html) to show you some of the basics of writing a function. \n",
"We use some materials from [this other Python course](https://github.com/kadarakos/python-course).*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We have seen that Python has several built-in functions (e.g. `print()` or `max()`). But you can also create a function. A function is a reusable block of code that performs a specific task. Once you have defined a function, you can use it at any place in your Python script. You can even import a function from an external module (as we will see in the next chapter). Therefore, they are beneficial for tasks that you will perform more often. Plus, functions are a convenient way to order your code and make it more readable!\n",
"\n",
"### At the end of this chapter, you will be able to:\n",
"* write a function\n",
"* work with function inputs\n",
"* understand the difference between (keyword and positional) arguments and parameters\n",
"* return zero, one, or multiple values\n",
"* write function docstrings\n",
"* understand the scope of variables\n",
"* store your function in a Python module and call it\n",
"* debug your functions\n",
"\n",
"### If you want to learn more about these topics, you might find the following link useful:\n",
"* [Tutorial: Defining Functions of your Own](http://anh.cs.luc.edu/python/hands-on/3.1/handsonHtml/functions.html)\n",
"* [The docstrings main formats](http://daouzli.com/blog/docstring.html)\n",
"* [PEP 287 -- reStructured Docstring Format](https://www.python.org/dev/peps/pep-0287/)\n",
"* [Introduction to assert](https://www.programiz.com/python-programming/assert-statement)\n",
"\n",
"**Now let's get started!**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If you have **questions** about this chapter, please contact us **(cltl.python.course@gmail.com)**."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 1. Writing a function\n",
"\n",
"A **function** is an isolated chunk of code that has a name, gets zero or more parameters, and returns a value. In general, a function will do something for you based on the input parameters you pass it, and it will typically return a result. You are not limited to using functions available in the standard library or the ones provided by external parties. You can also write your own functions!\n",
"\n",
"Whenever you are writing a function, you need to think of the following things:\n",
"* What is the purpose of the function?\n",
"* How should I name the function?\n",
"* What input does the function need?\n",
"* What output should the function generate?\n",
"\n",
"## 1.1. Why use a function?\n",
"\n",
"There are several good reasons why functions are a vital component of any non-ridiculous programmer:\n",
"\n",
"* encapsulation: wrapping a piece of useful code into a function so that it can be used without knowledge of the specifics\n",
"* generalization: making a piece of code useful in varied circumstances through parameters\n",
"* manageability: Dividing a complex program up into easy-to-manage chunks\n",
"* maintainability: using meaningful names to make the program better readable and understandable\n",
"* reusability: a good function may be useful in multiple programs\n",
"* recursion!\n",
"\n",
"## 1.2. How to define a function\n",
"\n",
"Let's say we want to sing a birthday song to Emily. Then we print the following lines:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"Happy Birthday to you!\")\n",
"print(\"Happy Birthday to you!\")\n",
"print(\"Happy Birthday, dear Emily.\")\n",
"print(\"Happy Birthday to you!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This could be the purpose of a function: to print the lines of a birthday song for Emily. \n",
"Now, we define a function to do this. Here is how you define a function:\n",
"\n",
"* write `def`;\n",
"* the name you would like to call your function;\n",
"* a set of parentheses containing zero or more parameter(s) for the function;\n",
"* a colon;\n",
"* a docstring describing what your function does; (optional but highly recommended)\n",
"* the function definition;\n",
"* ending with a return statement; (optional)\n",
"\n",
"Statements must be indented so that Python knows what belongs in the function and what not. Functions are only executed when you call them. It is good practice to define your functions at the top of your program or in another Python module.\n",
"\n",
"We give the function a clear name, `happy_birthday_to_emily`, and we define the function as shown below. Note that we specify what it does in the docstring at the beginning of the function:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def happy_birthday_to_emily(): # Function definition\n",
" \"\"\"\n",
" Print a birthday song to Emily.\n",
" \"\"\"\n",
" print(\"Happy Birthday to you!\")\n",
" print(\"Happy Birthday to you!\")\n",
" print(\"Happy Birthday, dear Emily.\")\n",
" print(\"Happy Birthday to you!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If we execute the code above, we don't get any output. That's because we only told Python: \"Here's a function to do this, please remember it.\" If we actually want Python to execute everything inside this function, we have to *call* it:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.3 How to call a function"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"It is important to distinguish between a function **definition** and a function **call**. We illustrate this in 1.3.1. You can also call functions from within other functions. This will become useful when you split up your code into small chunks that can be combined to solve a larger problem. This is illustrated in 1.3.2. \n",
"\n",
"\n",
"### 1.3.1) A simple function call\n",
"A function is **defined** once. After the definition, Python has remembered what this function does in its memory.\n",
"A function is **executed/called** as many times as we like. When calling a function, you should always use parenthesis. \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# function definition:\n",
"\n",
"def happy_birthday_to_emily(): # Function definition\n",
" \"\"\"\n",
" Print a birthday song to Emily.\n",
" \"\"\"\n",
" print(\"Happy Birthday to you!\")\n",
" print(\"Happy Birthday to you!\")\n",
" print(\"Happy Birthday, dear Emily.\")\n",
" print(\"Happy Birthday to you!\")\n",
" \n",
"# function call:\n",
"\n",
"print('Function call 1')\n",
"\n",
"happy_birthday_to_emily()\n",
"\n",
"print()\n",
"# We can call the function as many times as we want (but we define it only once)\n",
"print('Function call 2')\n",
"\n",
"happy_birthday_to_emily()\n",
"\n",
"print()\n",
"\n",
"print('Function call 3')\n",
"\n",
"happy_birthday_to_emily()\n",
"\n",
"print()\n",
"# This will not call the function \n",
"\n",
"print('This is not a function call')\n",
"happy_birthday_to_emily"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.3.2 Calling a function from within another function\n",
"\n",
"We can also define functions that call other functions, which is very helpful if we want to split our task into smaller, more manageable subtasks:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def new_line():\n",
" \"\"\"Print a new line.\"\"\"\n",
" print()\n",
"\n",
"def two_new_lines():\n",
" \"\"\"Print two new lines.\"\"\"\n",
" new_line()\n",
" new_line()\n",
"\n",
"print(\"Printing a single line...\")\n",
"new_line()\n",
"print(\"Printing two lines...\")\n",
"two_new_lines()\n",
"print(\"Printed two lines\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can do the same tricks that we learnt to apply on the built-in functions, like asking for `help` or for a function `type`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"help(happy_birthday_to_emily)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"type(happy_birthday_to_emily)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The help we get on a function will become more interesting once we learn about function inputs and outputs ;-)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.4 Working with function input\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.4.1 Parameters and arguments"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We use parameters and arguments to make a function execute a task depending on the input we provide. For instance, we can change the function above to input the name of a person and print a birthday song using this name. This results in a more generic function.\n",
"\n",
"To understand how we use **parameters** and **arguments**, keep in mind the distinction between function *definition* and function *call*.\n",
"\n",
"**Parameter**: The variable `name` in the **function definition** below is a **parameter**. Variables used in **function definitions** are called **parameters**. \n",
"\n",
"**Argument**: Is the entity that is passed as value to a parameter when calling a function. E.g., the first time we call the function below we pass the string `\"James\"` as a value to the parameter `name`. In the second call, we use the variable `my_name` instead. We refer to such values/variables as **arguments**. We use arguments so we can direct the function to do different kinds of work when we call it at different times."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# function definition with using the parameter `name'\n",
"def happy_birthday(name): \n",
" \"\"\"\n",
" Print a birthday song with the \"name\" of the person inserted.\n",
" \"\"\"\n",
" print(\"Happy Birthday to you!\")\n",
" print(\"Happy Birthday to you!\")\n",
" print(f\"Happy Birthday, dear {name}.\")\n",
" print(\"Happy Birthday to you!\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# function call using specifying the value of the argument\n",
"happy_birthday(\"James\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can also store the name in a variable:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"my_name=\"James\"\n",
"happy_birthday(my_name)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If we forgot to specify the name, we get an error:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"happy_birthday()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Functions can have multiple parameters. We can for example multiply two numbers in a function (using the two parameters x and y) and then call the function by giving it two arguments:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def multiply(x, y):\n",
" \"\"\"Multiply two numeric values.\"\"\"\n",
" result = x * y\n",
" print(result)\n",
" \n",
"multiply(2020,5278238)\n",
"multiply(2,3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.4.2 Positional vs keyword parameters and arguments"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The function definition tells Python which parameters are positional and which are keyword. As you might remember, positional means that you have to give an argument for that parameter; keyword means that you can give an argument value, but this is not necessary because there is a default value.\n",
"\n",
"So, to summarize these two notes, we distinguish between:\n",
"\n",
"1) **positional parameters**: (we indicate these when defining a function, and they are compulsory when calling the function)\n",
"\n",
"2) **keyword parameters**: (we indicate these when defining a function, but they have a default value - and are optional when calling the function)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For example, if we want to have a function that can either multiply two or three numbers, we can make the third parameter a keyword parameter with a default of 1 (remember that any number multiplied with 1 results in that number):"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def multiply(x, y, third_number=1): # x and y are positional parameters, third_number is a keyword parameter\n",
" \"\"\"Multiply two or three numbers and print the result.\"\"\"\n",
" result=x*y*third_number\n",
" print(result)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"multiply(2,3) # We only specify values for the positional parameters\n",
"multiply(2,3,third_number=4) # We specify values for both the positional parameters, and the keyword parameter\n",
"multiply(2,3,4) # This also works, do you have an idea why?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If we do not specify a value for a positional parameter, the function call will fail (with a very helpful error message):"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"multiply(3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.5 Output: the `return` statement"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Functions can have a **return** statement. The `return` statement returns a value back to the caller and **always** ends the execution of the function. This also allows us to use the result of a function outside of that function by assigning it to a variable:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def multiply(x, y):\n",
" \"\"\"Multiply two numbers and return the result.\"\"\"\n",
" multiplied = x * y\n",
" return multiplied\n",
"\n",
"#here we assign the returned value to the variable \"result\" \n",
"result = multiply(2, 5)\n",
"\n",
"print(result)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can also print the result directly (without assigning it to a variable), which gives us the same effect as using the print statements we used before:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"print(multiply(30,20))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If we assign the result to a variable, but do not use the return statement, the function cannot return it. Instead, it returns `None` (as you can try out below).\n",
"\n",
"This is important to realize: even functions without a `return` statement do return a value, albeit a rather boring one. This value is called `None` (it’s a built-in name). You have seen this already with list methods - for example `list.append(val)` adds a value to a list, but does not return anything explicitly.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"def multiply_no_return(x, y):\n",
" \"\"\"Multiply two numbers and does not return the result.\"\"\"\n",
" result = x * y\n",
" \n",
"is_this_a_result = multiply_no_return(2,3)\n",
"print(is_this_a_result)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Returning multiple values**\n",
"\n",
"Similarly as the input, a function can also return **multiple values** as output. We call such a collection of values a *tuple* (does this term sound familiar ;-)?).\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"def calculate(x,y):\n",
" \"\"\"Calculate product and sum of two numbers.\"\"\"\n",
" product = x * y\n",
" summed = x + y\n",
" \n",
" #we return a tuple of values\n",
" return product, summed\n",
"\n",
"# the function returned a tuple and we unpack it to var1 and var2\n",
"var1, var2 = calculate(10,5)\n",
"\n",
"print(\"product:\",var1,\"sum:\",var2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Make sure you actually save your 2 values into 2 variables, or else you end up with errors or unexpected behavior:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"#this will assign `var` to a tuple:\n",
"var = calculate(10,5)\n",
"print(var)\n",
"\n",
"#this will generate an error\n",
"var1, var2, var3 = calculate(10,5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Saving the resulting values in different variables can be useful when you want to use them in different places in your code:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"def sum_and_diff_len_strings(string1, string2):\n",
" \"\"\"\n",
" Return the sum of and difference between the lengths of two strings.\n",
" \"\"\"\n",
" sum_strings = len(string1) + len(string2)\n",
" diff_strings = len(string1) - len(string2)\n",
" return sum_strings, diff_strings\n",
"\n",
"sum_strings, diff_strings = sum_and_diff_len_strings(\"horse\", \"dog\")\n",
"print(\"Sum:\", sum_strings)\n",
"print(\"Difference:\", diff_strings)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.6 Documenting your functions with docstrings\n",
"\n",
"**Docstring** is a string that occurs as the first statement in a function definition.\n",
"\n",
"For consistency, always use \"\"\"triple double quotes\"\"\" around docstrings. Triple quotes are used even though the string fits on one line. This makes it easy to expand it later.\n",
"\n",
"There's no blank line either before or after the docstring.\n",
"\n",
"In practice, there are several formats for writing docstrings, and all of them contain more information than the single sentence description we mention here. Probably the most well-known format is reStructured Text. Here is an example of a function description in reStructured Text (reST):\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def my_function(param1, param2):\n",
" \"\"\"\n",
" This is a reST style.\n",
"\n",
" :param param1: this is a first param\n",
" :param param2: this is a second param\n",
" :returns: this is a description of what is returned\n",
" \"\"\"\n",
" return "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can see that this docstring describes the function goal, its parameters, its outputs, and the errors it raises.\n",
"\n",
"It is a good practice to write a docstring for your functions, so we will always do this! For now we will stick with single-sentence docstrings\n",
"\n",
"You can read more about this topic [here](http://daouzli.com/blog/docstring.html), [here](https://stackoverflow.com/questions/3898572/what-is-the-standard-python-docstring-format), and [here](https://www.python.org/dev/peps/pep-0287/)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.7 Debugging a function\n",
"Sometimes, it can hard to write a function that works perfectly. A common practice in programming is to check whether the function performs as you expect it to do. The `assert` statement is one way of debugging your function. The syntax is as follows:\n",
"\n",
"assert `code` == `your expected output`,`message to show when code does not work as you'd expected`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's try this on our simple function."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def is_even(p):\n",
" \"\"\"Check whether a number is even.\"\"\"\n",
" if p % 2 == 1:\n",
" return False\n",
" else:\n",
" return True"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If the function output is what you expect, Python will show nothing."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"input_value = 2\n",
"expected_output = True\n",
"actual_output = is_even(input_value)\n",
"assert actual_output == expected_output, f'expected {expected_output}, got {actual_output}'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"However, when the actual output is different from what we expected, we got an error. Let's say we made a mistake in writing the function."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def is_even(p):\n",
" \"\"\"Check whether a number is even.\"\"\"\n",
" if p % 2 == 1:\n",
" return False\n",
" else:\n",
" return False"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"input_value = 2\n",
"expected_output = True\n",
"actual_output = is_even(input_value)\n",
"assert actual_output == expected_output, f'expected {expected_output}, got {actual_output}'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.8 Storing a function in a Python module"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Since Python functions are nice blocks of code with a clear focus, wouldn't it be nice if we can store them in a file? By doing this, we make our code visually very appealing since we are only left with functions calls instead of function definitions."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Please open the file **utils_chapter11.py** (is in the same folder as the notebook you are now reading). In it, you will find three of the functions that we've shown so far in this notebook. So, how can we use those functions? We can `import` the function using the following syntax:\n",
"\n",
"`from` `NAME OF FILE WITHOUT .PY` `import` `function name`"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from utils_chapter11 import happy_birthday"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"happy_birthday('George')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from utils_chapter11 import multiply"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"multiply(1,2)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from utils_chapter11 import is_even"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"is_it_even = is_even(5)\n",
"print(is_it_even)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 2. Variable scope\n",
"Please note: scope is a hard concept to grasp, but we think it is important to introduce it here. We will do our best to repeat it during the course."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Any variables you declare in a function, as well as the arguments that are passed to a function will only exist within the **scope** of that function, i.e., inside the function itself. The following code will produce an error, because the variable `x` does not exist outside of the function:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"def setx():\n",
" \"\"\"Set the value of a variable to 1.\"\"\"\n",
" x = 1\n",
" \n",
"\n",
"setx()\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Even when we return x, it does not exist outside of the function:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"def setx():\n",
" \"\"\"Set the value of a variable to 1.\"\"\"\n",
" x = 1\n",
" return x\n",
" \n",
"setx()\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Also consider this:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"x = 0\n",
"def setx():\n",
" \"\"\"Set the value of a variable to 1.\"\"\"\n",
" x = 1\n",
"setx()\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In fact, this code has produced two completely unrelated `x`'s!\n",
"\n",
"So, you can not read a local variable outside of the local context. Nevertheless, it is possible to read a global variable from within a function, in a strictly read-only fashion."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"x = 1\n",
"def getx():\n",
" \"\"\"Print the value of a variable x.\"\"\"\n",
" print(x)\n",
" \n",
"getx()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can use two built-in functions in Python when you are unsure whether a variable is local or global. The function `locals()` returns a list of all local variables, and the function `globals()` - a list of all global variables. Note that there are many non-interesting system variables that these functions return, so in practice it is best to check for membership with the `in` operator. For example:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"a=3\n",
"b=2\n",
"\n",
"def setb():\n",
" \"\"\"Set the value of a variable b to 11.\"\"\"\n",
" b=11\n",
" c=20\n",
" print(\"Is 'a' defined locally in the function:\", 'a' in locals())\n",
" print(\"Is 'b' defined locally in the function:\", 'b' in locals())\n",
" print(\"Is 'b' defined globally:\", 'b' in globals())\n",
" print(\"I see 'b' as:\", b) # the local value prevails\n",
" \n",
"setb()\n",
"\n",
"print()\n",
"print(\"Is 'a' defined globally:\", 'a' in globals())\n",
"print(\"Is 'b' defined globally:\", 'b' in globals())\n",
"\n",
"print(\"Is 'c' defined globally:\", 'c' in globals())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finally, note that the local context stays local to the function, and is not shared even with other functions called within a function, for example:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"def setb_again():\n",
" \"\"\"Set the value of a variable to 3.\"\"\"\n",
" b=3\n",
" print(\"in 'setb_again' b =\", b)\n",
"\n",
"def setb():\n",
" \"\"\"Set the value of a variable b to 2.\"\"\"\n",
" b=2\n",
" setb_again()\n",
" print(\"in 'setb' b =\", b)\n",
"b=1\n",
"setb()\n",
"print(\"global b =\", b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We call the function `setb()` from the global context, and we call the function `setb_again()` from the context of the function `setb()`. The variable `b` in the function `setb_again()` is set to 3, but this does not affect the value of this variable in the function `setb()` which is still 2. And as we saw before, the changes in `setb()` do not influence the value of the global variable (`b=1`)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercises"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Exercise 1:** \n",
"\n",
"Write a function that converts meters to centimeters and prints the resulting value (please ignore units)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"# you code here"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Exercise 2**: \n",
"\n",
"Add another keyword parameter `message` to the multiply function below, which will allow a user to print a message. The default value of this keyword parameter should be an empty string. Test this with 2 messages of your choice. Also test it without specifying a value for the keyword argument when calling a function."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"# function to modify:\n",
"\n",
"def multiply(x, y, third_number=1): \n",
" \"\"\"Multiply two or three numbers and print the result.\"\"\"\n",
" result=x*y*third_number\n",
" print(result)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Exercise 3:** \n",
"\n",
"Write a function called `multiple_new_lines` which takes as argument an integer and prints that many newlines by calling the function newLine."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"def new_line():\n",
" \"\"\"Print a new line.\"\"\"\n",
" print()\n",
" \n",
"# you code here"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Exercise 4:** \n",
"\n",
"Let's refactor the happy birthday function to have no repetition. Note that previously we print \"Happy birthday to you!\" three times. Make another function `happy_birthday_to_you()` that only prints this line and call it inside the function `happy_birthday(name)`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"def happy_birthday_to_you():\n",
" # your code here\n",
"\n",
"# original function - replace the print statements by the happy_birthday_to_you() function:\n",
"def happy_birthday(name): \n",
" \"\"\"\n",
" Print a birthday song with the \"name\" of the person inserted.\n",
" \"\"\"\n",
" print(\"Happy Birthday to you!\")\n",
" print(\"Happy Birthday to you!\")\n",
" print(\"Happy Birthday, dear \" + name + \".\")\n",
" print(\"Happy Birthday to you!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Exercise 5:** \n",
"\n",
"Try to figure out what is going on in the following examples. How does Python deal with the order of calling functions?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"def multiply(x, y, third_number=1): \n",
" \"\"\"Multiply two or three numbers and print the result.\"\"\"\n",
" result=x*y*third_number\n",
" \n",
" return result\n",
" \n",
"print(multiply(1+1,6-2))\n",
"print(multiply(multiply(4,2),multiply(2,5)))\n",
"print(len(str(multiply(10,100))))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Exercise 6:** \n",
"\n",
"Complete this code to switch the values of two variables:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"def switch_two_values(x,y):\n",
" # your code here\n",
" \n",
"a='orange'\n",
"b='apple'\n",
"\n",
"a,b = switch_two_values(a,b) # `a` should contain \"apple\" after this call, and `b` should contain \"orange\"\n",
"\n",
"print(a,b)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": []
}
],
"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.11.4"
}
},
"nbformat": 4,
"nbformat_minor": 4
}