What's the point of @staticmethod in Python?

Question

I've developed this short test/example code, in order to understand better how static methods work in Python.

class TestClass:
    def __init__(self, size):
        self.size = size

    def instance(self):
        print("regular instance method - with 'self'")

    @staticmethod
    def static():
        print("static instance method - with @staticmethod")

    def static_class():
        print("static class method")


a = TestClass(1000)

a.instance()
a.static()
TestClass.static_class()

This code works correctly, it doesn't return any errors. My questions are:

Do I understand correctly that "self" can be understood as something like "this method will be called from an instance"?
Then again, what's the logic behind @staticmethod - is it to create static methods which can be called from an instance? Isn't that exactly not what static methods are about?
Why would the second approach be favored over the third one? (I assume that since the decorator exists, there is a point to this.) The 3rd option seems to be the simpler and more straightforward.

Note that this will not work at all in 2.x, and `a.static_class()` won't work in either. — jonrsharpe, Nov 27 '16 at 21:36
Add ``TestClass.static()`` and ``a.static_class()`` to your test cases and observe what happens. That may help to illustrate why ``@staticmethod`` is useful. — Graham Dumpleton, Nov 27 '16 at 21:37
*"Isn't that exactly not what static methods are about?"* - the advantage of being able to call it on the instance is that `cls.whatever()` and `self.whatever()` will work correctly, allowing you to keep the class name out of your class and instance methods and handle inheritance correctly. — jonrsharpe, Nov 27 '16 at 21:41
Possible duplicate of [Class method differences in Python: bound, unbound and static](http://stackoverflow.com/questions/114214/class-method-differences-in-python-bound-unbound-and-static) — pvg, Nov 27 '16 at 21:42

pylang · Accepted Answer · 2022-07-11T05:07:29.957

Here is a post on static methods. In summary:

instance methods: require the instance as the first argument
class methods: require the class as the first argument
static methods: require neither as the first argument

Examples

It may be more clear to see how these work when called with arguments. A modified example:

class TestClass:

    weight = 200                             # class attr 

    def __init__(self, size):
        self.size = size                     # instance attr

    def instance_mthd(self, val):
        print("Instance method, with 'self':", self.size*val)

    @classmethod
    def class_mthd(cls, val):
        print("Class method, with `cls`:", cls.weight*val)

    @staticmethod
    def static_mthd(val):
        print("Static method, with neither args:", val)

a = TestClass(1000)

a.instance_mthd(2)
# Instance method, with 'self': 2000

TestClass.class_mthd(2)
# Class method, with `cls`: 400

a.static_mthd(2)
# Static method, with neither args: 2

Notes

Overall, you can think of each method in terms of access:

If you need to access the instance or an instance component (e.g. an instance attribute), use an instance method as it passes self as the first argument.
Similarly, if you need to access a class, use a class method.
If access to neither an instance nor class is important, you can use a static method.

In the example above, the same argument is passed for each method type, but access to instance and class attributes differ through self and cls respectively.

Note, there is a way to access class components from an instance method by using self.__class__, thereby obviating the need for a class method:

    ...

    def instance_mthd2(self, val):
        print("Instance method, with class access via `self`:", self.__class__.weight*val)
    ...

a.instance_mthd2(2)
# Instance method, with class access via `self`: 400

Regarding your questions:

Yes. While the variable name self is a convention, it pertains to the instance.
Static methods can be used to group similar utility methods under the same class.
For methods within a class, you either need to add self as the first argument or decorate the method with @staticmethod. "Non-decorated methods" without arguments will raise an error.

See Also

R. Hettinger's talk Python's Class Development Toolkit - explains the purpose for each method type clearly with examples.

Is static_class() from my example what you define as a class method? — rbrtk, Nov 27 '16 at 21:42
Not quite. Decorate with `@classmethod` and pass `cls` as the first arg. Then it will be a class method. — pylang, Nov 29 '16 at 22:24

score 2 · Answer 2 · answered Nov 27 '16 at 21:59

Methods act on the instances on which they're invoked. The instance is passed as the first parameter, conventionally called self.

Class methods are similar, but act on the overall class object rather than one of the instances. They're handy as constructors and factory functions, or for configuration setting and other situations that affect the class or all of its instances at once, rather than individual instances.

The third option, static methods, is odd man out. They don't pass either the instance or the class. They're good for nesting utility functions within a program's class structure for organizational purposes, but in a way that clearly signals (to code reviewers, "linting" and program checking tools, etc.) that you are intentionally not depending on instance or class values. That way, you won't get "variable declared but never used" warnings about that unused self.

From the caller's point of view, static methods look like any other method call. If you didn't have @staticmethod available, you could just use a normal instance or class method (albeit at the risk of excess "variable not used!!" linter warnings). So unlike class methods, static methods are an entirely optional part of Python. They don't add any functionality to the language; instead, they provide a way to make the developer's intentions clearer.

Moinuddin Quadri · Answer 3 · 2016-11-27T22:17:19.807

Here are the answers to your question:

Question 1:

Do I understand correctly that "self" can be understood as something like "this method will be called from an instance"?

No. That is not entirely True. self means that the first argument to the function should be the instance of class. For example:

def my_class_function(self)

could be called as:

self.my_class_function()
OR,
my_class_function(self)

Also, it is not neccesarry to use self as the reference to the class' object. You may use anything (as far as it is valid variable), but using self is the standard followed everywhere.

Question 2:

Then again, what's the logic behind @staticmethod - is it to create static methods which can be called from an instance? Isn't that exactly not what static methods are about?

@staticmethod variable is used with the functions where you do not need any reference to the class' object within the function i.e. you do not any usage of self for accessing any of class' property or function.

Question 3:

Why would the second approach be favored over the third one? (I assume that since the decorator exists, there is a point to this.) The 3rd option seems to be the simpler and more straightforward.

Using second approach i.e. using @staticmetod, you may call your function from outside the class using the class's object unlike your third approach (without using the decorator) as the scope of the function is within the class.

What's the point of @staticmethod in Python?

3 Answers3

Linked