# 11B: Variable Scope

**Source**: https://cscircles.cemc.uwaterloo.ca/11b-how-functions-work/
**Parent**: https://cscircles.cemc.uwaterloo.ca/

*Lesson 11 has three parts A, B, C which can be completed in any order.*

In this lesson we explain a concept called *variable scope*. The main idea is that it is possible to have two *different* variables with the *same* name whenever they have different scopes. This makes it much easier to write and edit programs, especially large ones. It is also a necessary ingredient in a later topic, recursion.

## An example of variable scope

For this example, part of our program will be the following function:

```
def square(x):
   value = x * x
   return value
```

This is a function which computes the square of the number `x`, for example `square(5)` returns `25`. Now suppose we call `square` from another part of the program which also uses a `value` variable for another purpose:

```
# main body of the program starts here
value = 17
fivesquared = square(5)
print(fivesquared, value)
```

The question is, what will be printed in this scenario? There are two possibilities, if we don't know how Python works:

1. One possibility is that Python recognizes that the two `value` variables should be "kept separate" somehow. Thus, the call to `square` will return 25, but the value of `value` in the main body will stay at 17, and we see the output `25``17`.
2. The other possibility is that when `square`, executes, it over-writes the existing value of `value` with 25, and we see the output `25``25`.

Let's see what actually happens!

We see that Python's behaviour is consistent with possibility #1. In fact, *whenever you call a function, you cannot affect any variables defined outside the function.* Instead, any statements that assign values to variables affect only a "local" variable which is "inside" the function call. The **reason** that Python, and most other languages, work like this is that it makes it much more simple to write long programs with many functions. In particular, when we define a new function, we are always allowed to use any variable names inside the function (including common ones like `result,` `temp` and `i`) even if they are being used somewhere else for different purposes.

To see this in detail, look at "Step 6 of 8" in the visualizer. Notice that there are two different `value` variables: one inside of the `square` function, and one outside (in the "global" area).

Multiple Choice Exercise: Inner and Outer

What is the output of the following program?

```
x = "outer"\
def xReplace(value):\
   x = value\
xReplace("inner")\
print(x)
```

Your choice: Select oneouterThe program causes an error.inner

Correct! The statement `x = value` only affects the local version of variable `x` inside the function. The global version of `x` does not change. (So, the function `xReplace` is useless and never has any effect.)

Another similar concept to *scope* is a *namespace;* a namespace is like a scope for a package. So even if you `import` a package (such as `math`) which uses variable name `x` somewhere, it does not overlap with the variable `x` used by your program, since they lie in different namespaces.

## Scoping Rules: Seeing Out

There are situations where we want to mix variables from local and global scopes. One common example is where you have some common variable initialized once at the start of the program, but you also want your functions to be able to read the variable.

Example

Reading a global variable from inside a function

favouriteTopping='pepperoni'
def orderPizzas(n):
print("I'd like", str(n), favouriteTopping, "pizzas")
orderPizzas(3)

|  |  |  |
| --- | --- | --- |
|  |  |  |

Here, the local scope did not contain a variable named `favouriteTopping`, *but this did not cause an error*. Python's rule for evaluating variables is that, if a variable needs to be evaluated which does not exist in the local scope, then it looks for it in the global scope. In our case, it indeed found `favouriteTopping` in the global scope. (In a more general case with one function body calling another function you would have three scopes; Python always checks the "localmost" first and goes one step at a time to the global scope until the variable is found.)

|  |  |
| --- | --- |
|  | Two of the examples above, with `orderPizzas` and `xReplace`, are almost syntactically identical. Why does Python create a new local variable `x` in `xReplace`, but no new `favouriteTopping` in `orderPizzas`? Python's rule is the following: if you only read from the variable, then no new local variable is created; but if you write to the variable even once, then the variable is treated as local throughout the function body. (This is the most common cause of [`UnboundLocalError`](https://cscircles.cemc.uwaterloo.ca/console/?consolecode=x%20%3D%201%0Adef%20f%28%29%3A%0A%20%20%20print%28x%29%0A%20%20%20x%20%3D%202%0Af%28%29): see these two questions [[1](http://docs.python.org/py3k/faq/programming.html#why-am-i-getting-an-unboundlocalerror-when-the-variable-has-a-value), [2](http://docs.python.org/py3k/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python)] in the official Python documentation.) |

Function arguments are *always* treated as new local variables, as the following broken code fragment illustrates (it attempts to reset the variable `g` to `0`, but fails).

## `global` Changes

Like many other things, the normal flow described above works for 99% of all situations. But that remaining 1% of the time, you really might want to change a global variable from within a function. Python allows you to do this using the `global` statement.

Here's a modification of the earlier `xReplace` example. Note that we declaring the variable as `global` in the function. This lets you change the global value from within the function.

Reiterating: when inside of a function, assigning to a variable name defined at global scope actually creates a separate new local-scope variable with the same name, instead of modifying the global-scope variable (like `resetToZero`). If you want to update the global-scope variable, you must include the statement `global «variable-name»` inside of the function (like the fixed `xReplace` example). Then Python understands that changes to `«variable-name»` in the function are meant to refer to the existing global-scope variable.

As we mentioned earlier, *reading* a global variable does not require using the `global` statement; only *writing*. That concludes the lesson!