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
In this tutorial I’ll help demystify what’s behind class methods, static methods, and regular 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
@staticmethod
and@classmethod
decorators are available as of Python 2.4 and this example will work as is. Instead of using a plainclass MyClass:
declaration you might choose to declare a new-style class inheriting fromobject
with theclass MyClass(object):
syntax. Other than that you’re good to go.
Instance Methods
The first method on MyClass
, called 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).
Through the 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.
Class Methods
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.
Static Methods
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 self
argument.
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: