Python locals() Function

Spread the love

The locals() function returns a dictionary containing the variables defined in the local namespace at the point where the function is called. Unlike global variables that are accessible throughout the entire program, local variables exist only within the scope of the function or block in which they are defined.

Understanding Local Namespace

Before delving into locals(), one must first understand what a local namespace is. In Python, a namespace is a mapping from names (identifiers) to objects. Each function call creates a new namespace where the names defined in the function’s block are stored. This namespace is considered “local” to the function.


The syntax of locals() is simple:



The locals() function doesn’t take any parameters.

Return Value:

The locals() function returns the dictionary of the current local symbol table.


Here’s a basic example.

def function_example():
    local_variable = 10


Running function_example() will output:

{'local_variable': 10}

locals( ) Under the Hood

locals() operates differently depending on where it’s called. Inside a function, it can effectively access and even modify local variables. However, at the module level, locals() and globals() are essentially the same, since there is no enclosing function scope.

Inside Functions

Within a function, locals() will return a dictionary reflective of the current local symbol table. This is dynamic and will change if the local scope is altered (for example, by defining a new variable).

def foo():
    localVar = 1
    anotherVar = 2


This would result in output:

{'localVar': 1, 'anotherVar': 2}

Inside Classes

When locals() is used within a method of a class, it will return a dictionary of the local scope within that method, not the attributes of the class instance.

Practical Uses of locals( )

locals() is often used for debugging purposes, as it allows you to inspect the values of local variables at a specific point in time.


Consider the following example:

def complex_function(a, b):
    result = a + b
    # Lots of complex code here
    return result

complex_function(5, 7)


{'a': 5, 'b': 7, 'result': 12}


The print(locals()) statement allows you to see the state of your local variables and can help in tracking down issues.

String Formatting

Another use case is dynamic string formatting:

name = "Alice"
occupation = "developer"
print("Name: {name}, Occupation: {occupation}".format(**locals()))

The **locals() here unpacks the local namespace and passes it as keyword arguments to the format() function, which can be very handy.


In more advanced scenarios, such as meta-programming, locals() can be used to perform operations that require knowledge of the current local state. It is sometimes used in decorators, class decorators, or metaclasses where you want to add or alter the functionality of local methods or attributes dynamically.

locals() to change values:

In Python, the locals() function returns a dictionary that represents the current local symbol table. This table contains information about all local variables in the scope in which the locals() call is made. However, the use of locals() to change the values of local variables is generally not recommended and may lead to unexpected behavior.

Let’s explore why this is the case and what you should be aware of when attempting to use locals() to modify values.

Behavior of locals( ) in Different Contexts

The behavior of locals() can vary depending on where it is called. If you call locals() at the module level, it is essentially the same as calling globals(), and modifications to the returned dictionary do affect the actual global variables.

However, inside a function, while you can still retrieve the local variables with locals(), the official Python documentation states that changes to the dictionary may not affect the local variables. This is because the dictionary returned by locals() may not be directly linked to the internal representation of the local scope.

Modifying locals( ) Inside Functions

Consider the following example:

def test_locals():
    x = 10
    locals_dict = locals()
    print(f"Before: x = {x}")
    locals_dict['x'] = 20
    print(f"After: x = {x}")



Before: x = 10
After: x = 10

In this code, changing the value of ‘x’ in the locals_dict does not guarantee that the local variable x will reflect this new value. When you run this code, you’ll likely see that x remains unchanged after the attempt to modify it through the locals_dict.

Why is Changing locals( ) Unreliable?

The main reason behind this unreliability is the way Python’s local variables are stored and accessed. Python uses a fast-access mechanism for local variables in functions, which are not always synchronized with the dictionary that locals() returns.

Additionally, some optimizations in the Python interpreter, like the use of slots for local variables, mean that changes to the dictionary you get from locals() might not propagate back to the actual local scope. For instance, in the case of functions, local variables are stored in an array, and the locals() dictionary is created from this array on-demand when you call locals(). But modifying the dictionary afterward doesn’t mean that the array will be updated.

Correct Way to Modify Local Variables

The proper way to modify local variables is by direct assignment:

def test_assignment():
    x = 10
    print(f"Before: x = {x}")
    x = 20
    print(f"After: x = {x}")



Before: x = 10
After: x = 20

The capability of locals() to change local variables is restricted and not recommended. It should primarily be used for reading local variables rather than writing to them. Direct assignment is always the correct way to change the value of a local variable in Python. For complex scenarios that require dynamic access to variables, consider using other features of Python such as descriptors, properties, or dictionary-based objects where the attributes are actually stored in a modifiable dictionary.

Comparison with globals( )

While locals() pertains to the local scope, globals() pertains to the global scope, which is the module-level namespace where your code is executed. globals() returns a dictionary of the global namespace, and unlike locals(), modifications to this dictionary are guaranteed to affect the global variables.

x = 10
def example():
    y = 11
    print('Local scope:', locals())
    print('Global scope:', globals())


This will output the local variables within example() and the global variables at the module level.


Python’s locals() function is a window into the local namespace of a function or block. Its proper use can greatly aid in debugging and certain meta-programming tasks, allowing developers to introspect the state of their code at runtime. While powerful, it should be employed judiciously and with an understanding of its limitations, especially in relation to the scope of variables and the nature of the Python execution model.

Leave a Reply