Python's Instance, Class, and Static Methods
Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: OOP Method Types in Python: @classmethod vs @staticmethod vs Instance Methods
If you develop an intuitive understanding for their differences you’ll be able to write object-oriented Python that communicates its intent more clearly and will be easier to maintain in the long run.
Instance, Class, and Static Methods — An Overview
Let’s begin by writing a (Python 3) class that contains simple examples for all three method types:
class MyClass: def method(self): return 'instance method called', self @classmethod def classmethod(cls): return 'class method called', cls @staticmethod def staticmethod(): return 'static method called'
NOTE: For Python 2 users: The
@classmethoddecorators are available as of Python 2.4 and this example will work as is. Instead of using a plain
class MyClass:declaration you might choose to declare a new-style class inheriting from
class MyClass(object):syntax. Other than that you’re good to go.
The first method on
method, is a regular instance method. That’s the basic, no-frills method type you’ll use most of the time. You can see the method takes one parameter,
self, which points to an instance of
MyClass when the method is called (but of course instance methods can accept more than just one parameter).
self parameter, instance methods can freely access attributes and other methods on the same object. This gives them a lot of power when it comes to modifying an object’s state.
Not only can they modify object state, instance methods can also access the class itself through the
self.__class__ attribute. This means instance methods can also modify class state.
Let’s compare that to the second method,
MyClass.classmethod. I marked this method with a
@classmethod decorator to flag it as a class method.
Instead of accepting a
self parameter, class methods take a
cls parameter that points to the class—and not the object instance—when the method is called.
Because the class method only has access to this
cls argument, it can’t modify object instance state. That would require access to
self. However, class methods can still modify class state that applies across all instances of the class.
The third method,
MyClass.staticmethod was marked with a
@staticmethod decorator to flag it as a static method.
This type of method takes neither a
self nor a
cls parameter (but of course it’s free to accept an arbitrary number of other parameters).
Therefore a static method can neither modify object state nor class state. Static methods are restricted in what data they can access - and they’re primarily a way to namespace your methods.
Let’s See Them In Action!
I know this discussion has been fairly theoretical up to this point. And I believe it’s important that you develop an intuitive understanding for how these method types differ in practice. We’ll go over some concrete examples now.
Let’s take a look at how these methods behave in action when we call them. We’ll start by creating an instance of the class and then calling the three different methods on it.
MyClass was set up in such a way that each method’s implementation returns a tuple containing information for us to trace what’s going on — and which parts of the class or object the method can access.
Here’s what happens when we call an instance method:>>>
>>> obj = MyClass() >>> obj.method() ('instance method called', <MyClass instance at 0x10205d190>)
This confirmed that
method (the instance method) has access to the object instance (printed as
<MyClass instance>) via the
When the method is called, Python replaces the
self argument with the instance object,
obj. We could ignore the syntactic sugar of the dot-call syntax (
obj.method()) and pass the instance object manually to get the same result:
>>> MyClass.method(obj) ('instance method called', <MyClass instance at 0x10205d190>)
Can you guess what would happen if you tried to call the method without first creating an instance?
By the way, instance methods can also access the class itself through the
self.__class__ attribute. This makes instance methods powerful in terms of access restrictions - they can modify state on the object instance and on the class itself.
Let’s try out the class method next: