Python Cookbook

Implementing Static Methods

Credit: Alex Martelli, Carel Fellinger

Problem

You want to call methods directly on a class without supplying an instance of the class as the first argument, or on any instance without having the instance implicitly become the first argument.

Solution

In Python 2.2 (on either classic or new-style classes), the new built-in staticmethod function wraps any callable into a static method, and we just bind the same name to the staticmethod object in class scope:

class Greeter:
    def greet(name): print "Hello", name
    greet = staticmethod(greet)

In Python 2.1 and earlier, we can easily simulate the same construct:

class staticmethod:
    def _ _init_ _(self, anycallable): self._ _call_ _ = anycallable

Now, with any release of Python, we can say:

>>> greeting = Greeter(  )
>>> greeting.greet("Peter")
Hello Peter
>>> Greeter.greet("Paul")
Hello Paul

You can get a static method as a class attribute or as the attribute of any instance of the class. It does not matter which, because when you call the static method, it calls the underlying callable anyway.

Discussion

In Python, when you want to make a function available for calling, you normally expose it as an attribute of a module, not of a class. An attribute of a class object that starts out as a Python function implicitly mutates into an unbound method (see Recipe 5.13 for a way to exploit this). Thus, if you want to make the function available as a class attribute, without mutation, you need to wrap the function into a callable of another type and bind that wrapper callable as the class attribute. Python 2.2 offers a new built-in staticmethod type that performs just such a wrapping. This recipe shows how to use it and how to emulate it easily in earlier Python versions with a tiny auxiliary class of the same name.

As the recipe shows, you normally define the function that will become a static method with a def statement in the class body, and then immediately rebind the same name to the staticmethod object. You don’t have to do it this way, though. You could simply write the following code outside of the class body:

def anotherfunction(  ): print "Yes, you CAN do that"
Greeter.peculiarmethodname = staticmethod(anotherfunction)

Unless you have a good reason to proceed in this way, such a noncustomary way of doing things will just confuse future readers of your code.

In some languages (such as C++ or Java), static methods are also sometimes called class methods. However, the term class methods should be reserved for methods that belong to the class, in the same way that normal methods belong to the instance (i.e., for methods that receive the class object as their first implicit argument). Static methods in Python, as in C++, are little more than bland syntactical sugar for free-standing functions. See Recipe 5.8 for how to make real class methods (a la Smalltalk) in Python.

See Also

Recipe 5.8 and Recipe 5.13.