How to Loop Through All Variables in Memory Python: Complete Guide

When working with Python, you might need to inspect or manipulate all variables in memory. This guide explores different methods to loop through variables effectively while viewing their names and values.

Using locals() Function

The locals() function returns a dictionary containing current local symbol table, which includes all local variables in the current scope.

# Define some local variables
x = 10
y = "Hello"
z = [1, 2, 3]

# Loop through local variables
for var_name, var_value in locals().items():
    # Skip internal variables (starting with underscore)
    if not var_name.startswith('_'):
        print(f"Variable: {var_name} = {var_value}")

Variable: x = 10
Variable: y = Hello
Variable: z = [1, 2, 3]

Using globals() Function

The globals() function returns a dictionary of the current global symbol table. This is useful when you need to access global variables in your program.

# Define global variables
global_var1 = 100
global_var2 = "World"

def inspect_globals():
    for var_name, var_value in globals().items():
        # Filter out system variables and modules
        if not var_name.startswith('__'):
            print(f"Global Variable: {var_name} = {var_value}")
            
inspect_globals()

Using dir() Function

The dir() function returns a list of valid attributes and methods of the specified object, or the current scope if no argument is given.

# Create some variables
name = "John"
age = 30
numbers = [1, 2, 3]

# Loop through variables using dir()
for var_name in dir():
    if not var_name.startswith('_'):  # Skip internal names
        value = eval(var_name)  # Get variable value
        print(f"{var_name}: {value} (Type: {type(value).__name__})")

Best Practices and Considerations

Filter unwanted variables by checking variable names and types. System variables typically start with underscores and should be excluded from the loop.

When using these methods to modify variables in loops, be careful about modifying the dictionary while iterating through it.

# Safe way to modify variables
variables = locals().copy()  # Create a copy before modification
for var_name, var_value in variables.items():
    if isinstance(var_value, (int, float)):  # Only modify numeric variables
        exec(f"{var_name} = {var_value * 2}")

Conclusion

Looping through variables in memory is a powerful feature in Python that can be achieved through different methods like locals(), globals(), and dir().

Remember to handle system variables and use appropriate filtering methods when processing variables. Always consider memory management and scope when manipulating variables programmatically.