How to Use Static Variables in Functions in Python?

Today, I will tell you about a tricky concept: static variables within Python functions. In this tutorial, I will guide you through various methods to implement static variables in functions in Python.

To use a static variable in a Python function, you can leverage default mutable arguments. This technique uses a mutable data type like a list as a default argument, which retains its state across multiple function calls. Here’s an example:

def visit_counter(counter=[0]):
    counter[0] += 1
    return counter[0]

# Calling the function multiple times
print(visit_counter())  # Output: 1
print(visit_counter())  # Output: 2
print(visit_counter())  # Output: 3

In this example, the list counter is initialized only once when the function is defined. Each time the function is called, the first element of the list is incremented, and the updated value is returned. This allows the list to maintain its state between calls, effectively acting as a static variable.

Table of Contents

What is a Static Variable in Python?

A static variable in Python is a variable that retains its value between function calls. In languages like C or C++, static variables within functions maintain their state across multiple invocations. While Python does not directly support this, you can mimic this behavior using several approaches.

Methods to Implement Static Variables in Python Functions

With examples, let me show you how to implement static variables in Python functions.

Method 1: Using Default Mutable Arguments

One way to simulate static variables in Python is by using default mutable arguments. This technique leverages the fact that default argument values are evaluated only once when the function is defined, not each time the function is called.

def visit_counter(counter=[0]):
    counter[0] += 1
    return counter[0]

print(visit_counter())  # Output: 1
print(visit_counter())  # Output: 2
print(visit_counter())  # Output: 3

In this example, the list counter is initialized only once, and its value persists between function calls. This allows the function to maintain a running count of how many times it has been called.

Here is the output in the screenshot below:

Check out How to Declare a Variable Without Assigning a Value in Python?

Method 2: Using Function Attributes

Let me show you another effective method is to use function attributes in Python. You can attach attributes to a function to store static data.

def visit_counter():
    if not hasattr(visit_counter, "count"):
        visit_counter.count = 0  # Initialize the attribute
    visit_counter.count += 1
    return visit_counter.count

print(visit_counter())  # Output: 1
print(visit_counter())  # Output: 2
print(visit_counter())  # Output: 3

In this case, visit_counter.count acts as a static variable. It is initialized the first time the function is called and retains its value across subsequent calls.

Here is the output in the screenshot below:

Method 3: Using a Class

A more structured approach is to encapsulate the function and its static variable within a class in Python. This method provides a clear and organized way to manage state.

class VisitCounter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

visit_counter = VisitCounter()

print(visit_counter())  # Output: 1
print(visit_counter())  # Output: 2
print(visit_counter())  # Output: 3

By defining a class with a __call__ method, you create an instance that behaves like a function while maintaining its state. This approach is particularly useful for more complex scenarios where multiple static variables or additional methods might be needed.

You can see the output in the screenshot below:

python static variable in class function

Read Constant Variables in Python

Static Variables in Functions in Python Example: Counting Function Calls

Let’s consider a practical example of counting the number of times a function is called in Python. This can be useful in various applications, such as monitoring usage statistics or limiting the number of times a function can be executed.

Using Default Mutable Arguments

def call_counter(counter=[0]):
    counter[0] += 1
    print(f"Function has been called {counter[0]} times")

call_counter()  # Output: Function has been called 1 times
call_counter()  # Output: Function has been called 2 times
call_counter()  # Output: Function has been called 3 times

Using Function Attributes

def call_counter():
    if not hasattr(call_counter, "count"):
        call_counter.count = 0
    call_counter.count += 1
    print(f"Function has been called {call_counter.count} times")

call_counter()  # Output: Function has been called 1 times
call_counter()  # Output: Function has been called 2 times
call_counter()  # Output: Function has been called 3 times

Using a Class

class CallCounter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        print(f"Function has been called {self.count} times")

call_counter = CallCounter()

call_counter()  # Output: Function has been called 1 times
call_counter()  # Output: Function has been called 2 times
call_counter()  # Output: Function has been called 3 times

Conclusion

In this tutorial, I have explained how to use the static variable in a function in Python using different methods with examples.