Python Variable Scope – Local, Global, Built-in, Enclosed

Today, we will discuss Python Variable Scope. Here, we will learn different types of variable scope in Python, the Python Global Keyword, and Python Non-local keywords.

So, let’s start our learning.

What is Python Variable Scope?

Scope means where a variable can be seen in your code. A variable created inside a function lives only inside that function; this is called local scope. Once the function finishes, the local variable disappears.

Variables written outside all functions sit in the global scope. Any function can read them, but changing them inside a function needs the global keyword. Using too many globals can confuse larger programs.

Let’s take an example, but before, let’s revise Python syntax.

>>> b=8
>>> def func():
                a=7
                print(a)
                print(b)              
>>> func()

Output

>>> a

Output

Also, the duration for which a variable is alive is called its ‘lifetime’.

Types of Python Variable Scope

There are 4 types of Variable Scope in Python, let’s discuss them one by one:

Python Variable Scope – Types

1. Local Scope in Python

In the above code, we define a variable ‘a’ in a function ‘func’. So, ‘a’ is local to ‘func’. Hence, we can read/write it in func, but not outside it.

When we try to do so, it raises a NameError. Look at this code.

>>> a=0
>>> def func():
               print(a)
                a=1
                print(a)            
>>> func()

Output

Here, we could’ve accessed the global Scope ‘a’ inside ‘func’, but since we also define a local ‘a’ in it, it no longer accesses the global ‘a’.

Then, the first print statement inside ‘func’ throws an error in Python, because we’re trying to access the local scope ‘a’ before assigning it.

However, it is a bad practice to try to manipulate global values from inside local scopes. Try to pass it as a parameter to the function.

>>> def func(a=0):
                a+=1
                print(a)             
>>> func()

Output

2. Global Scope in Python

We also declare a variable ‘b’ outside any other Python variable scope, which makes it a global scope.

Consequently, we can read it anywhere in the program. Later in this article, we will see how to write it inside func.

3. Enclosing Scope in Python

Let’s take another example.

>>> def red():
                a=1
                def blue():
                                b=2
                                print(a)
                                print(b)
                blue()
                print(a)
>>> red()

Output

In this code, ‘b’ has local scope in the Python function ‘blue’, and ‘a’ has nonlocal scope in ‘blue’.

Of course, a Python variable scope that isn’t global or local is nonlocal. This is also called the enclosing scope.

4. Built-in Scope in Python

Finally, we talk about the widest scope. The built-in scope has all the names that are loaded into the scope of Python variables when we start the interpreter.

Characteristics of the built-in scope in Python:

• Available Everywhere: Python Functions like print(), len(), and range () can be used anywhere without importing modules.
• Always Active: Built-in names always stay available as long as the program is running.
• Checked Last: Python searches this scope only after checking local, enclosing, and global scopes.
• Global Access: No need to import or define these functions.

Global Keyword in Python

So far, we haven’t had any kind of problem with global scope. So let’s take an example.

>>> a=1
>>> def counter():
                a=2
                print(a)            
>>> counter()

Output

Now, when we make a reference to ‘a’ outside this function, we get 1 instead of 2.

>>> a

Output

Why does this happen? Well, this is because when we set ‘a’ to 2, it created a local variable ‘a’ in the local scope of ‘counter’.

This didn’t change anything for the global ‘a’. Now, what if you wanted to change the global version of ‘a’? We use the ‘global’ keyword in Python for this.

>>> a=1
>>> def counter():
                global a
                a=2
                print(a)    
>>> counter()

Output

>>> a

Output

What we do here is, we declare that the ‘a’ we’re going to use in this function is from the global scope.

After this, whenever we refer to ‘a’ inside ‘counter’, the interpreter knows we’re talking about the global ‘a’.

In this example, it changed the value of the global ‘a’ to 2.

Nonlocal Keyword in Python

Like the ‘global’ keyword, you want to make a change to a nonlocal variable, you must use the ‘nonlocal’ keyword. Let’s first try this without the keyword.

>>> def red():
                a=1
                def blue():
                                a=2
                                b=2
                                print(a)
                                print(b)
                blue()
                print(a)           
>>> red()

Output

As you can see, this did not change the value of ‘a’ outside the function ‘blue’. To be able to do that, we use ‘nonlocal’.

>>> def red():
                a=1
                def blue():
                                nonlocal a
                                a=2
                                b=2
                                print(a)
                                print(b)
                blue()
                print(a)             
>>> red()

Output

See? This works perfectly fine.

Python Interview Question on Python Variable Scope

1. What do you mean by scope?

2. What are the types of variable scope in Python?

3. What is the scope of a variable in Python with an example?

4. What are Python variables?

5. How do you declare a variable in Python 3?

Conclusion

We hope that the variable scope of Python is clearer to you. Here, we saw four types of variable scope in Python: local scope, enclosed scope, global scope, and built-in scope.

We also saw two keywords in Python – ‘global’ and ‘nonlocal’. Hope you had fun, see you again.