What is the scope of variables in Python?

Types of scopes in Python

Python has four types of variable scopes, and each scope defines where variables can be accessed and modified:

Now let’s look at each of these variable scopes in detail using a real-life example. We’ll use the example of a library management system to explain these scopes in a relatable and meaningful way. So let’s begin!

1. Python global scope

We start with the library’s basic setup: its name. This information is global to the entire system because it doesn’t change regardless of the operation being performed—whether it’s adding new books, registering members, or handling loans.

In this case, we create a variable called library_name that should be available to all parts of the program. Any other function that we write can access this information.

2. Python local scope

Now, let’s move to member registration. Each member’s details are unique to that specific function call. We don’t need these details outside the registration process, so we use local variables for this. Here, member_name exists only within the register_member() function. This isolates it from the rest of the program, making it a local variable.

Accessing the local variable from within and outside of the function

That’s simple. But can this local variable be accessed outside of the function? Let’s see.

Now, what if we had a local and global variable of the same name?

Using global keyword for global variables

There are cases when we might want to access and modify the global variables inside a function. Let’s say there’s a global variable borrowing limit for borrowing books. To update the library’s borrowing list, we have a function called update_borrowing_limit().

To update this policy, we need to update the global variable by reassigning it inside the function update_borrowing_limit. Look at the code below and execute it.

The updated borrowing limit is not updated at all. This is because we cannot update/reassign a global variable inside a function unless we use the global keyword. Without the global keyword, Python would create a local variable inside the function and leave the global borrowing_limit unchanged.

We need to explicitly write the global keyword with the global variable that we want to update.

See the line 5 in the code below and run the code:

This time the borrowing limit is updated to 7.

Note: The global keyword is not needed for printing and accessing, just for modifying. Feel free to change the variable names, scopes, or values to see how the change affects program behavior.

3. Enclosed scope

Imagine that we want to add a feature where members can check access to premium sections of the library. To implement this, we need two levels of functions: one for general access and another for specific section access. The access code for each section will be set in the outer function, while the inner function checks it. This brings us to the enclosed scope.

Here’s how we define access to special library sections. The inner function will check the access code, which is defined in the outer function. The access_code variable belongs to the enclosed scope because it’s defined in the outer library_section() function but is used inside the inner check_access() function.

4. Nonlocal scope

Now, suppose we want to allow premium members to enjoy an updated discount rate. The discount rate is set when membership is defined but can change. The inner function can modify this discount rate, but only if it’s allowed to access the variable in the enclosing scope using the nonlocal keyword.

We use the nonlocal scope to modify variables in the enclosing function without making them global. The nonlocal keyword lets the inner function update_discount() modify the discount_rate in the outer membership() function. Without nonlocal, the change wouldn’t apply to the variable in the outer function.

Quiz yourself

Now solve the quiz on Python variable scopes, designed to not only test knowledge but also teach you the subtleties of variable scopes:

Exercise: Correct the code

The code below is intended to count the number of times a function is called, but it has scope-related errors. Fix the code so that it correctly counts and prints the number of function calls.

The code is supposed to keep track of:

1. A global count of the total number of times any counter() function is called across all instances.

2. A local count that resets each time the outer() function is called and only counts calls to counter() within each specific call to outer().

Your task is to correct these mistakes so that both total_count and local_count work as intended.

The LEGB rule

Now let’s look at the rule (LEGB) that Python uses to search for variables in different scopes. To help us remember, we’ve broken down the acronym LEGB to understand what it entails:

1. L (Local): Python looks in the current local scope first (inside the function).

2. E (Enclosed): If the variable is not found locally, Python checks for it in any enclosing functions (if there are any).

3. G (Global): If the variable is not found in an enclosing function, Python checks the global scope (variables defined at the top level of the script or module).

4. B (Built-in): If Python still hasn’t found the variable, it checks the built-in scope, which contains Python’s built-in functions and constants like print(), len(), etc.

Each scope defines where variables can be accessed and modified, making it crucial to understand how they work when writing Python programs.