> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Python Static Method Decorator The `@staticmethod` decorator is a built-in Python class used to define a method within a class namespace that does not receive an implicit first argument. Unlike standard instance methods that automatically receive the instance reference (`self`), or class methods that receive the class reference (`cls`), a static method operates independently of both object and class state. Under the hood, `@staticmethod` alters Python's default descriptor protocol. Normally, accessing a function from an instance triggers a descriptor `__get__` method that creates a bound method object. Wrapping a callable in `@staticmethod` returns a non-data descriptor whose `__get__` method simply returns the underlying callable unmodified. This prevents the binding process, causing the method to behave exactly like a standard module-level function while remaining lexically scoped inside the class. ## Syntax ```python theme={"dark"} class TargetClass: @staticmethod def static_operation(param1, param2): # No 'self' or 'cls' is declared or passed 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 execution resolves to the exact same underlying function object without passing any implicit context. ```python theme={"dark"} # Invocation via the class namespace TargetClass.static_operation(1, 1) # Invocation via an instance instance = TargetClass() instance.static_operation(1, 1) ``` ## Technical Characteristics * **Type Resolution:** Calling `type()` on an accessed static method returns ``, whereas accessing a standard instance method returns ``. * **State Isolation:** Because neither the instance nor the class is passed to the method, it cannot read or mutate `self.*` or `cls.*` attributes directly. * **Inheritance:** Static methods participate in standard Method Resolution Order (MRO). If a subclass redefines a static method, the subclass's implementation will override the parent's implementation when invoked through the subclass namespace. * **Callable Descriptors:** As of Python 3.10, `staticmethod` descriptor objects themselves are callable. This means the raw descriptor object returned by `staticmethod(func)` can be executed directly (e.g., `staticmethod(func)()` is valid). Prior to Python 3.10, the descriptor had to be accessed via a class or instance namespace to trigger `__get__` before it could be invoked.

Tired of Poor Python Skills? Fix That With Deep Grasping! Learn More