What is the Python equivalent of static variables inside a function?

python

functions

best-practices

functional-programming

byNikita Barsukov·Oct 13, 2024

Creating a static variable in Python comes in the form of a function attribute:

def my_func():
    # He who controls the static_var, controls the universe... 😂
    my_func.static_var = getattr(my_func, 'static_var', 0) + 1
    return my_func.static_var

# Usage:
print(my_func())  # first time's a charm, it prints 1
print(my_func())  # remember the '1' I told you about?

Within the confines of this code, my_func.static_var is the static variable. It comes alive with a life span of 0 only to increment with each call.

Crafting staticity with decorators

Decorators provide a seamless avenue for infusing static behavior into a function. They allow variables to be initialized and retain their context across several calls:

def static_vars(**kwargs):
    def decorate(func):
        for k in kwargs:
            setattr(func, k, kwargs[k])
        return func
    return decorate

@static_vars(counter=0)
def func_with_static():
    func_with_static.counter += 1
    return func_with_static.counter

Decorators are like the secret superheroes of functions, keeping their body clean and organized while working wonders on behind the scenes.

Nesting with nonlocal

When dealing with nested functions, the nonlocal keyword takes precedence by signifying a variable's scope beyond the innermost function.

def outer():
    count = 0
    def inner():
        nonlocal count
        count += 1
        return count
    return inner

In the code above, count comes in as a static variable in the inner function.

Playing with mutable defaults

Making use of mutable default arguments like lists to store static variables is plausible, yet fraught with risk, due to the shared nature of these mutable types>

def risky_func(accumulator=[]):
    accumulator.append(1)
    return accumulator

A safer notation would be to utilize the function attribute, thereby avoiding the Pandora's box of issues associated with mutable defaults.

Turning to classes as an alternative

When the usage of the static variable starts feeling more like rocket science, a perfect foil is to utilize a class. This approach results in more readable and maintainable code:

class SampleClass:
    static_var = 0
    
    @staticmethod
    def my_method():
        SampleClass.static_var += 1
        return SampleClass.static_var

Handling exceptions like a Pro

Implementing staticity sometimes pulls up an AttributeError. This can be deftly handled pre-emptively with a try-except block:

def my_function():
    try:
        my_function.counter += 1
    except AttributeError:
        my_function.counter = 1
    return my_function.counter

All future calls to my_function.counter are performed uninterrupted, ensuing optimal performance.

Function scope considerations

If the static variable is sparsely utilized, consider relocating it outside the function's scope. This would result in simplified function definition and better memory allocation.

Importance of initialization

Careful initialization of static variables is crucial. Uncertain initialization can lead to hard-to-track bugs. Always ensure that variables are set up with a definite state before use.

Zen of Python and static variables

Just like the Zen of Python advises on simplicity, when considering the use of static variables, apply the same principle. If static variables complicate the logic, it signals a time for change. Indeed, impractical static variables that tarnish code readability need a rethinking.

Taking static variables deeper

Defining applications of static variables

Static variables shine when a function needs to remember something across it calls. This frequently applies to counters, caches, and tracking state in a functional programming style.