staticmethod vs classmethod

The difference is what the method receives as its first argument. An ordinary instance method receives the instance, so its first parameter is named self. A classmethod receives the class, so its first parameter is named cls. A staticmethod receives nothing at all, because it has no implicit first parameter.

That single difference decides everything else. A staticmethod is really just a plain function that happens to live inside the class body, so it cannot reach the class or any instance. A classmethod can reach class-level data, and more importantly it can build new instances by calling cls(...), which is why it is the right tool for alternative constructors and for factory methods.

Both of them are usually called through the class name, which is how you would normally use them. The subtle part is that neither one is affected by being called through an instance. A staticmethod and a classmethod both ignore the instance they were accessed through, so obj.helper() behaves in exactly the same way as Class.helper(). If a method needs the data of the object itself, then it has to be an ordinary instance method.

Two naming conventions complete the picture. The style guide says that a classmethod's first parameter should be called cls and not self, so that a reader knows at once what it holds. The classmethod and staticmethod decorators have both been available since Python 2.4, and you will still meet older code that calls them directly as built-in functions on a class.

A classmethod is designed to be called on the class, but it also works when you call it from an instance.

class Counter:
    total = 0

    @classmethod
    def show_total(cls):
        return cls.total

    @staticmethod
    def helper(value):
        return value * 2


print(Counter.show_total())       # 0
print(Counter.helper(4))          # 8
print(Counter().show_total())     # 0 - the instance is ignored

Both calls to show_total return 0, and the reason is that a classmethod always receives the class and never the instance. Calling it through an instance is allowed, but the instance is simply thrown away, because there is no self in the signature and so there is nothing to bind it to.

The same is true of the staticmethod. It receives no implicit first argument at all, so the value 4 is simply the first real argument of helper.

There are two things to remember here. The classmethod receives the class through cls, so inside the method you write cls.something instead of ClassName.something, and that is what keeps the method working for subclasses. The staticmethod has no self at all, so it cannot touch instance data, and if a method needs the data of the object then it must be an ordinary instance method.

A classmethod receives the class, so it can build new instances of that class, and of any subclass of it as well.

class User:
    def __init__(self, name, email=None):
        self.name = name
        self.email = email

    @classmethod
    def from_string(cls, text):
        name, email = text.split('|')
        return cls(name, email)

    @classmethod
    def anonymous(cls, name):
        return cls(name)


user = User.from_string('Ada|[email protected]')
print(user.name, user.email)      # Ada [email protected]
print(User.anonymous('Guest').email)   # None

The from_string method reads a pipe-separated string and builds a User from it, and the anonymous method builds a user with no email at all. Both of them read like named constructors, which is a common and readable alternative to writing a separate factory function for every case.

The reason to use a classmethod here rather than a staticmethod is the cls argument. Writing cls(name, email) instead of User(name, email) means that the method keeps working when somebody subclasses the class. Call from_string on a subclass and you get an instance of that subclass, and not an instance of User.

That is the general rule to give in an interview. Use a classmethod when the method needs to build instances or needs to reach class-level data. Use a staticmethod when the method is a helper that needs neither of those things. Use an ordinary instance method for anything that needs the data of the object itself.