How to Access a Local Variable Outside a Function in Python Without Using global?

Today, I will discuss an interesting topic someone asked me about in a training group. I will show you how to access a local variable outside its function without using the global keyword. We will understand the concept of variable scope in Python, explain why accessing local variables outside their function is generally discouraged, and identify some alternatives.

To access a local variable outside a function in Python without using the global keyword, the most straightforward and recommended approach is to return the variable from the function. By doing this, you can capture the returned value and use it outside the function, maintaining clean and encapsulated code. For example:

def my_function():
    local_var = 10
    return local_var

result = my_function()
print(result)  # This will print 10

This method ensures the local variable is accessible outside the function without compromising code readability and maintainability.

Understanding Variable Scope in Python

First, let us understand the variable scope in Python. In Python, the scope of a variable determines where that variable can be accessed or modified. There are mainly two types of scopes:

1. Local Scope: Variables defined within a function are in the local scope. They are only accessible within that function.
2. Global Scope: Variables defined outside any function are in the global scope. They can be accessed from anywhere in the code.

Here’s a simple example to illustrate this:

def my_function():
    local_var = 10  # local variable
    print(local_var)

my_function()
print(local_var)  # This will raise an error

In this example, local_var is a local variable and cannot be accessed outside my_function.

Why Not Use global?

The global keyword allows you to modify a global variable inside a function. However, using global is generally discouraged because it can make the code harder to understand and debug. It breaks the encapsulation principle, leading to tightly coupled code.

global_var = 20

def my_function():
    global global_var
    global_var = 30

my_function()
print(global_var)  # This will print 30

While this works, it’s not the best practice.

Now, let me show you different methods to access a local variable outside a function in Python without using the global keyword.

Access a Local Variable Outside a Function in Python Without Using global

Here are the four methods to access a Python local variable outside a function without using the global.

1. Return Values from Functions

The most recommended way to access a local variable outside a function in Python is to return it. This method keeps the function’s scope intact and makes the code more readable and maintainable. Let me show you an example.

def my_function():
    local_var = 10
    return local_var

result = my_function()
print(result)  # This will print 10

By returning the local variable, you can use it outside the function without breaking the encapsulation.

The output in the screenshot below is after I executed the code using VS code.

Read How to Call a Variable from Another Function in Python?

2. Using Function Attributes

Another interesting way to access a local variable outside a function in Python without using global() is by using function attributes.

Here is an example.

def my_function():
    my_function.local_var = 10

my_function()
print(my_function.local_var)  # This will print 10

Here, my_function.local_var is an attribute of the function object, allowing you to access the local variable after the function has been called.

The output is in the screenshot below after I executed the above Python code.

3. Using Closures

Closures provide another way to maintain access to local variables outside their function. A closure is a function object that remembers values in enclosing scopes even if they are not present in memory.

Here is an example of accessing local variable outside a function in Python without using global.

def outer_function():
    local_var = 15
    def inner_function():
        return local_var
    return inner_function

closure = outer_function()
print(closure())  # This will print 15

In this example, inner_function retains access to local_var even after outer_function has finished executing.

You can see the exact output in the screenshot below:

4. Using Classes

Using classes can be a more structured and scalable approach for more complex scenarios. By encapsulating variables within a class, you can maintain state and access these variables as needed.

Here is the Python code.

class MyClass:
    def __init__(self):
        self.local_var = 10

    def get_local_var(self):
        return self.local_var

obj = MyClass()
print(obj.get_local_var())  # This will print 10

Classes provide a clear and organized way to manage state and behavior, making them ideal for larger projects.

Conclusion

Accessing local variables outside their function without using global is only possible using different methods like returning values, using function attributes, closures, or classes, etc. I hope all these examples help you.

You may also like the following tutorials:

• How to Check Variable Type is datetime in Python?
• How to Check if a Variable is a Float in Python?
• Check Type of Variable Is String in Python