Skip to content

Master Static Methods for Utility Functions in Python

Updated: at 02:50 AM

Utility functions are common in programming to encapsulate reusable logic into standalone methods. These functions typically perform general tasks unrelated to a specific class or module. In Python, utility functions can be defined as static methods to associate them with a class while keeping them independent from class state or instances.

Static methods provide several advantages for utility functions in Python:

This comprehensive guide will explain what static methods are, their use cases, how to properly define them, and best practices for using static methods for utility functions in Python.

Table of Contents

Open Table of Contents

What Are Static Methods in Python?

Static methods in Python are functions that are bound to a class rather than its object instances. They can be called directly from the class without creating a class instance.

Regular class methods take the class instance as the first argument which is conventionally called self. Static methods do not take this self or cls argument.

Below is an example comparing a regular instance method to a static method:

class MyClass:

    def instance_method(self):
        print(f"Called on instance: {self}")

    def static_method():
        print("Called directly on the class.")

To call the instance method, we first need to instantiate the class:

obj = MyClass()

# Called on instance: <__main__.MyClass object at 0x7fb04e9fc340>

The static method can be called directly on the class without instantiation:


# Called directly on the class.

This demonstrates how static methods are callable on the class rather than its instances. Next, we’ll explore some common use cases where static methods are applicable.

Use Cases for Static Methods in Python

Some typical use cases for static methods include:

1. Utility Functions

Grouping reusable utility functions under a class as static methods avoids cluttering the module namespace. The math module uses this technique with the Math class containing math utility functions as static methods.

import math

# 120

2. Factory Methods

Factory methods instantiate classes, while remaining independent of the class instances. For example:

class Dog:

    def create_from_birth_year(birth_year):
        # Factory method to instantiate the class
        return Dog(2022 - birth_year)

puppy = Dog.create_from_birth_year(2017)

3. Singleton Classes

The singleton pattern returns the same class instance from the static method.

class Logger:

    _instance = None

    def get_logger():
        if not Logger._instance:
            Logger._instance = Logger()
        return Logger._instance

4. Namespace Isolation

Similar methods can be isolated into static method namespaces. For example, separate static methods for class methods when working with class attributes vs. instance attributes.

Defining Static Methods in Python

Python provides the @staticmethod decorator to convert a regular function into a static method.

class MyClass:

    def my_static_method():
        # Static method code

This designation as a static method is only enforced at runtime. Static methods have no compile time distinction from regular functions.

The @staticmethod decorator can actually be applied to any function, not just methods on a class:

def non_class_static_method():
   # Function is now a static method

However, conventionally the @staticmethod decorator is applied to methods defined within a class.

Static methods can also call other static methods directly through the class:

class Utilities:

    def method_a():

    def method_b():
        Utilities.method_a() # Call static method directly

Utilities.method_b() # Prints "a"

Next, we’ll go over some best practices to use when defining static methods.

Best Practices for Static Methods

Follow these best practices when defining and using static methods in Python:

By following these best practices you can leverage static methods to effectively structure reusable utility functions in Python.

Example Utility Class with Static Methods

Let’s look at an example utility class containing validation functions as static methods:

class ValidationUtils:
    """Provides validation utility functions as static methods"""

    def validate_email(email: str) -> bool:
        """Validates that an email address matches expected format.

            email (str): Email address to validate

            bool: True if valid email format, False otherwise

        if not re.match(r"[^@]+@[^@]+\.[^@]+", email):
            return False
        return True

    def validate_phone_number(phone_number: str) -> bool:
        """Validates a phone number matches expected format.

            phone_number (str): Phone number to validate

            bool: True if valid phone number, False otherwise

        if not re.match(r"^(\+\d{1,2}\s)?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}$", phone_number):
            return False
        return True

    def validate_zip_code(zip_code: str) -> bool:
        """Validates a zip code matches common US zip code format.

            zip_code (str): Zip code to validate

            bool: True if valid zip code, False otherwise

        if not re.match(r"^\d{5}(?:[-\s]\d{4})?$", zip_code):
            return False
        return True

This ValidationUtils class groups related utilities for validating values as static methods. They can be called directly like:

isValid = ValidationUtils.validate_email("[email protected]")
# True

isValid = ValidationUtils.validate_phone_number("555-555-1234")
# True

The methods are properly documented and type hinted. Additional validation utilities could be added to the class as more static methods.

Since they are static, each method works independently without any shared class state. The class simply provides logical grouping and prevents naming collisions.

Subclasses could be created to extend the utilities by overriding methods. For example, providing country-specific phone and zip code validators.

When Not to Use Static Methods

While static methods have several advantages, they may not always be the best design choice:

Evaluate whether instances, state sharing, organization, extendibility, and readability are important when deciding between static methods and other function definition approaches.


Static methods are a useful construct in Python for grouping utility functions and isolating them from class instance state. By decorating regular functions with @staticmethod, they become associated with a particular class while remaining independent.

Typical use cases for static methods include utility functions, factory methods, and organizing namespaces. Following best practices like descriptive names, docstrings, type hinting, and testing makes static methods even more effective.

Static methods strike the right balance for utility functions by keeping them bundled in classes, while still allowing them to be called in a stateless functional manner. Leveraging them appropriately will make your Python codebase better organized, easier to maintain, and more Pythonic.