Static Method

A static method in Python is a function stored as an attribute within a class namespace that does not receive an implicit first argument (neither the instance reference self nor the class reference cls). Because it lacks these bindings, a static method cannot implicitly access or modify object or class state. It behaves entirely like a standard module-level function, but is housed within the class namespace for organizational purposes.

Static methods are defined using the built-in @staticmethod decorator.

class Component:
    class_attribute = "state"

    def __init__(self):
        self.instance_attribute = "state"

    @staticmethod
    def static_operation(param1, param2):
        # Lacks implicit access to instance or class attributes because self and cls are absent.
        # However, explicit access to class state is fully permitted via the global class name:
        # Component.class_attribute = "new state"
        return param1 + param2

Invocation Mechanics

Static methods can be invoked through the class itself or through an instance of the class. In both scenarios, the method signature remains identical, and no implicit arguments are passed by the Python interpreter.

# Invocation via the class
result_class = Component.static_operation(5, 10)


# Invocation via an instance
obj = Component()
result_instance = obj.static_operation(5, 10)

Descriptor Protocol Implementation

Under the hood, @staticmethod is a built-in class that implements the non-data descriptor protocol.

When a standard function is accessed via an instance, its __get__ method returns a bound method object, which wraps the original function and binds the instance to the first argument. When accessed via a class, its __get__ method returns the raw function object.

The @staticmethod decorator overrides this behavior. Its __get__ method always returns the underlying raw function without binding any object to it, regardless of whether it is accessed via the class or an instance.

class Example:
    def instance_method(self):
        pass

    @staticmethod
    def static_method():
        pass


# Standard method accessed via instance returns a bound method object
print(Example().instance_method) 

# <bound method Example.instance_method of <__main__.Example object at 0x...>>


# Standard method accessed via class returns a raw function object
print(Example.instance_method)

# <function Example.instance_method at 0x...>


# Static method always returns a standard function object
print(Example().static_method)   

# <function Example.static_method at 0x...>
print(Example.static_method)

# <function Example.static_method at 0x...>

Method Resolution Comparison

To understand static methods technically, they must be contrasted with Python’s other method types regarding implicit argument passing:

• Instance Method: Implicitly passes the instance (self) as the first argument. Has implicit read/write access to the instance namespace, and implicit read access to the class namespace (via self fallback). It does not have implicit write access to the class namespace; assigning to self.attribute writes to the instance’s __dict__, shadowing the class attribute.
• Class Method (@classmethod): Implicitly passes the class (cls) as the first argument. Has implicit read/write access to the class namespace, but no implicit access to the instance namespace.
• Static Method (@staticmethod): Passes no implicit arguments. Lacks implicit access to both instance and class namespaces, though it can still explicitly access the class namespace by referencing the class name directly from the global scope.

Master Python with Deep Grasping Methodology!

Learn More