Variable Scopes in Python

Understanding the ‘LEGB’ Rule

In Python, there are four different variable scopes: Local, Enclosing, Global, Built-in. This leads to the ‘LEGB’ rule, which defines how Python resolves / looks up names. In this post we will introduce all scopes with examples, and also show how one can ‘interact’ between these — e.g. via the global or nonlocal keyword.

Python, compared to other languages like C++, does not know the concept of declaring a variable. A variable simply is created the moment we first assign a value to it. It is only available in the “region” / “area” it was created in — this is called scope. In the following we will introduce the four available variable scopes: Local, Enclosing, Global, Built-in.

Local Scope

Variables created inside a function belong to the local scope corresponding to that function — and are not available outside:

def foo():
    x = 10
    print(f"Value of x in foo: {x}")

foo()
print(f"Value of x outside: {x}")

In above example, x is a local variable inside foo’s scope — and trying to access it from outside yields an error.

Enclosing Scope

For example in this previous post about closures we have seen inner functions — functions declared inside another, also called nested functions. In this case, the nested function has access to the variables of the outer function, that is, those of the enclosing scope.

def outer():
    x = 10

    def inner():
        y = 20
        print(f"Value of x in inner: {x}")

    inner()
    # print(y) - this would fail

outer()

inner can access x from the enclosing scope, but outer cannot access inner’s local variable y.

Global Scope

The global scope contains all variables defined outside of any function — all functions have access to the contained variables:

x = 10
def foo():
    print(f"Value of x inside foo: {x}")

foo()
print(f"Value of x outside foo: {x}")

Built-in Scope

The built-in scope is the widest scope, and contains all built-in keywords, which you can use anywhere in your code without importing or defining them. A list of Python keywords can be found here.

Modifying Variables of Different Scopes.

Above explanations were probably quite easy to read and understand — however, things get a little bit more complicated, when wanting to modify variables of different scopes. So far, we used them read-only.

Writing Global Variables

Consider the following code:

x = 10
def foo():
    x = 20
    print(f"Value of x inside foo: {x}")

foo()
print(f"Value of x outside foo: {x}")

This prints:

Value of x inside foo: 20
Value of x outside foo: 10

Potentially not what you expected — although x is changed to 20 inside foo, this does not reflect outside. The reason is that variables created inside a function are local by default — i.e. a new variable x with value 20 is created inside foo. Also trying something like x += 10 would raise UnboundLocalError: local variable ‘x’ referenced before assignment — as in this case x is correctly identified as a global variable, but we cannot modify it by default. For this, we can use the global keyword, afterwards causing both prints to be 20:

x = 10

def foo():
    global x
    x = 20
    print(f"Value of x inside foo: {x}")

foo()
print(f"Value of x outside foo: {x}")

Modifying Mutable Objects

To complicate things a little further, things change when working with mutable objects, such as lists. What we discussed above, i.e. the no-write access for global variables from within a function, actually only forbids the direct assignment (x = …). However, as we have read access to the object, we can also call functions using it — and in particular modify the contents!

This code works for example without the global keyword, for this reason:

x = [0, 1]

def foo():
    x.append(2)
    print(f"Value of x inside foo: {x}")

foo()
print(f"Value of x outside foo: {x}")

The nonlocal Keyword

Now let’s have a look at write-access to variables of the enclosing scope. Initial results show similar behaviour to before, i.e. “modifying” x inside inner does not cause a change in outer:

def outer():
    x = 10

    def inner():
        x = 20
        print(f"Value of x in inner: {x}")

    inner()
    print(f"Value of x in outer: {x}")

outer()

In this case the keyword nonlocal can be used to force this:

def outer():
    x = 10

    def inner():
        nonlocal x
        x = 20
        print(f"Value of x in inner: {x}")

    inner()
    print(f"Value of x in outer: {x}")

outer()

Note the same comments about mutable objects hold as for the global keyword — i.e. we don’t need to use nonlocal when working with mutable objects.

Difference Between Keywords global and nonlocal

Above shown use-cases and usages of global and nonlocal seem fairly similar: in both cases they enable modifying a variable from a larger scope. Nevertheless, they are specific to their respective use-cases, i.e. one cannot use nonlocal to modify a global variable from within a function. Another distinction is that nonlocal needs a previously created variable — while using global from within a function can bind a new variable to the global namespace:

def foo():
    global x
    x = 10

foo()
print(f"Accessing x from the global namespace: {x}")

In Plain English 🚀

Thank you for being a part of the In Plain English community! Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Discord | Newsletter
• Visit our other platforms: Stackademic | CoFeed | Venture | Cubed
• More content at PlainEnglish.io