> ## 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 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. ```python theme={"dark"} 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. ```python theme={"dark"} # 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. ```python theme={"dark"} 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) # > # Standard method accessed via class returns a raw function object print(Example.instance_method) # # Static method always returns a standard function object print(Example().static_method) # print(Example.static_method) # ``` ## 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.

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