Benefits of Using @staticmethod in Python

python

I was wondering if you use @staticmethod decorator in your code.

Personally I don't use it, since it takes more letters to write @staticmethod then self.

The only benefit (which comes to me) from using it may be a better clarity of a code, but since I usually write a method description for sphinx, I always state whether a method is using object or not.

Or maybe I should start using @staticmethod decorator ?

Best Answer

Whether to use @staticmethod or not depends on what you want to achieve. Ignoring the decorator because there is more to type is a rather silly reason (no offense!) and indicates that you have not understood the concept of a static method in Python!

Static methods are independent of the class and any class instance. They only use the class scope as a namespace. If you omit the @staticmethod decorator, you are creating an instance method that cannot be used without constructing an instance.

Here is a very simple class Foo:

>>> class Foo(object):
...    @staticmethod
...    def foo():
...       print 'foo'
...
...    def bar(self):
...       print 'bar'

Now, Foo.foo() is a static method that can be called directly:

>>> Foo.foo()
foo

Foo.bar() on the other hand is an instance method, that can only be called from instances (objects) of Foo:

>>> Foo.bar()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method foo() must be called with Foo instance as first argument (got nothing instead)
>>> foo = Foo()
>>> foo.bar()
bar

To answer your question: If you want to define a static method, use @staticmethod. Otherwise, don't.

If you have a method that does not use self, and therefore could be written as a static method, ask yourself: Will you ever want to access this function from outside without having an instance? Most of the times, the answer will be: No.

Related Solutions

Python – Why Use @staticmethod

The reason to use staticmethod is if you have something that could be written as a standalone function (not part of any class), but you want to keep it within the class because it's somehow semantically related to the class. (For instance, it could be a function that doesn't require any information from the class, but whose behavior is specific to the class, so that subclasses might want to override it.) In many cases, it could make just as much sense to write something as a standalone function instead of a staticmethod.

Your example isn't really the same. A key difference is that, even though you don't use self, you still need an instance to call static_add_one --- you can't call it directly on the class with test2.static_add_one(1). So there is a genuine difference in behavior there. The most serious "rival" to a staticmethod isn't a regular method that ignores self, but a standalone function.

Python OOP – Is @staticmethod Decorator Needed for Static Methods?

You need the decorator if you intend to try to call the @staticmethod from the instance of the class instead of of the class directly

class Foo():
    def bar(x):
        return x + 5

>>> f = Foo()
>>> f.bar(4)
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    f.bar(4)
TypeError: bar() takes 1 positional argument but 2 were given

Now if I declare @staticmethod the self argument isn't passed implicitly as the first argument

class Foo():
    @staticmethod
    def bar(x):
        return x + 5

>>> f = Foo()
>>> f.bar(4)
9

Best Answer

Related Solutions

Python – Why Use @staticmethod

Python OOP – Is @staticmethod Decorator Needed for Static Methods?

Related Question