Difference between staticmethod and classmethod

Asked : Nov 17

Viewed : 35 times

What is the difference between a function decorated with @staticmethod and one decorated with @classmethod?

oop python methods python-decorators 

Nov 17

4 Answers

Maybe a bit of example code will help: Notice the difference in the call signatures of foo, class_foo and static_foo:

class A(object):
    def foo(self, x):
        print(f"executing foo({self}, {x})")

    def class_foo(cls, x):
        print(f"executing class_foo({cls}, {x})")

    def static_foo(x):
        print(f"executing static_foo({x})")

a = A()

Below is the usual way an object instance calls a method. The object instance, a, is implicitly passed as the first argument.

# executing foo(<__main__.A object at 0xb7dbef0c>, 1)

With class methods, the class of the object instance is implicitly passed as the first argument instead of self.

# executing class_foo(<class '__main__.A'>, 1)

You can also call class_foo using the class. In fact, if you define something to be a class method, it is probably because you intend to call it from the class rather than from a class instance. A.foo(1) would have raised a TypeError, but A.class_foo(1) works just fine:

# executing class_foo(<class '__main__.A'>, 1)

One use people have found for class methods is to create inheritable alternative constructors.

With staticmethods, neither self (the object instance) nor cls (the class) is implicitly passed as the first argument. They behave like plain functions except that you can call them from an instance or the class:

# executing static_foo(1)

# executing static_foo(hi)

Static methods are used to group functions that have some logical connection with a class to the class.

foo is just a function, but when you call a.foo you don't just get the function, you get a "partially applied" version of the function with the object instance a bound as the first argument to the function. foo expects 2 arguments, while a.foo only expects 1 argument.

a is bound to foo. That is what is meant by the term "bound" below:

# <bound method A.foo of <__main__.A object at 0xb7d52f0c>>

With a.class_foo, a is not bound to class_foo, rather the class A is bound to class_foo.

# <bound method type.class_foo of <class '__main__.A'>>

Here, with a static method, even though it is a method, a.static_foo just returns a good 'ole function with no arguments bound. static_foo expects 1 argument, and a.static_foo expects 1 argument too.

# <function static_foo at 0xb7d479cc>

And of course, the same thing happens when you call static_foo with the class A instead.

# <function static_foo at 0xb7d479cc>

answered Jan 20

I think a better question is "When would you use @classmethod vs @staticmethod?"

@classmethod allows you easy access to private members that are associated to the class definition. this is a great way to do singletons, or factory classes that control the number of instances of the created objects exist.

@staticmethod provides marginal performance gains, but I have yet to see a productive use of a static method within a class that couldn't be achieved as a standalone function outside the class.

answered Jan 20

Static Methods:

  • Simple functions with no self-argument.
  • Work on class attributes; not on instance attributes.
  • Can be called through both class and instance.
  • The built-in function static method()is used to create them.

Benefits of Static Methods:

  • It localizes the function name in the class scope
  • It moves the function code closer to where it is used

More convenient to import versus module-level functions since each method does not have to be specially imported

Class Methods:

  • Functions that have the first argument as class name.
  • Can be called through both class and instance.

These are created with class method in-built function.

 def some_class_method(cls, *args, **kwds):
def some_static_method(*args, **kwds):

answered Jan 20

Class Method


class C(object):
    def fun(cls, arg1, arg2, ...):
fun: function that needs to be converted into a class method
returns: a class method for function.

Static Method

A static method does not receive an implicit first argument. 


class C(object):
    def fun(arg1, arg2, ...):
returns: a static method for function fun.

answered Jan 20

Login and Submit Your Answer
Browse other questions tagged  oop  python  methods  python-decorators or ask your own question.