Scope

Local Scope

A variable created inside a function is local to that function. It only exists while the function is running and cannot be accessed from outside it. Once the function finishes the variable is gone.

The variable message only exists inside greet(). Trying to print it outside the function throws a NameError because as far as the rest of the program is concerned that variable does not exist.

Global Scope

A variable created at the top level of your file, outside of any function, is global. It can be read from anywhere in the file including inside functions. However reading a global variable and modifying it are two different things.

The function can read language because it is global. But if you try to reassign it inside the function without telling Python explicitly, it will create a new local variable with the same name instead of modifying the global one. This is one of the most common sources of confusion around scope.

Both print statements print Python because the assignment inside the function created a new local variable called language that only exists inside the function. The global language was never touched.

The global Keyword

If you genuinely need to modify a global variable from inside a function you can use the global keyword to tell Python explicitly that you want to work with the global version rather than creating a local one.

Use the global keyword sparingly. Modifying global variables from inside functions makes your code harder to follow and debug because the value of the variable can change from anywhere in the program. In most cases it is better to pass values in as arguments and return results instead.

Enclosing Scope

Enclosing scope applies when you have a function defined inside another function. The inner function has access to variables defined in the outer function even though they are not global. This is the E in LEGB.

The inner function inner() can read name from the outer function even though it was not passed in as an argument. This is enclosing scope in action.

The nonlocal Keyword

Just as global lets you modify a global variable from inside a function, the nonlocal keyword lets you modify a variable from an enclosing function rather than creating a new local one.

Without nonlocal, the assignment inside inner() would create a new local variable called count and the outer count would remain unchanged. With nonlocal, Python knows to modify the variable in the enclosing scope.

Built in Scope

The outermost level of scope is built in scope. This contains all the names that Python provides automatically without you having to define or import anything. Functions like print(), len(), range(), type() and input() all live in built in scope. They are always available everywhere in your program.

This is also why you should never name your own variables or functions the same as a built in. If you create a variable called list or print you will shadow the built in and Python will use your version instead, which will almost certainly cause unexpected behaviour.

Exercise 1: Local vs Global

• Task: Create a global variable country = "Thailand" and a function called show_country().
• Goal: Inside the function create a local variable also called country with a different value. Print the local version inside the function and the global version outside it. Write a comment explaining why both print statements produce different results even though the variable has the same name.

Exercise 2: The global Keyword

• Task: Create a global variable high_score = 0 and a function called update_score(new_score).
• Goal: Use the global keyword inside the function to update high_score if new_score is greater than the current high_score. Call the function three times with different scores and print high_score after each call to verify it is being updated correctly. Write a comment explaining what would happen if you removed the global keyword.

Exercise 3: Enclosing Scope

• Task: Create a function called outer() that defines a variable message = "Hello from outer" and contains an inner function called inner().
• Goal: Inside inner() print message without passing it as an argument. Call outer() and verify that inner() can access the variable from the enclosing scope. Write a comment explaining the difference between enclosing scope and global scope.

Exercise 4: The nonlocal Keyword

• Task: Create a function called counter() that defines a variable count = 0 and contains an inner function called increment().
• Goal: Use the nonlocal keyword inside increment() to increase count by 1 each time it is called. Call increment() five times inside counter() and print count after each call. Write a comment explaining what would happen if you removed the nonlocal keyword and why.

Exercise 5: Spot the Scope Bug

• Task: The following code has a scope related bug. Find it, fix it and explain why it caused a problem:

• Goal: Fix the bug and write a comment explaining why Python threw an error and what the correct solution is. Then write a second version of the function that avoids using the global keyword entirely by passing score as a parameter instead.