Compare Instance Methods vs Class Methods vs Static Methods

If you’re here for a quick reminder of how the three method types differ from one another, then consider the following overview that compares them:

• Instance methods use aself parameter pointing to aninstance of theclass. They can access and modify instance state throughself and class state throughself.__class__. These are the most common methods in Python classes.

• Class methods use acls parameter pointing to the class itself. They can modify class-level state throughcls, but they can’t modify individual instance state.

• Static methods don’t takeself orcls parameters. They can’t modify instance or class state directly, and you’ll mainly use them for organizational purposes and namespacing.

If you need to revisit information quickly, there’s nothing quite like a table. So here are the most important aspects of the three different types of methods in Python classes summed up in a table:

That’s enough super-condensed, repetitive reference information! If you want to know what all of this means in practice, and you like to learn by running code snippets and reasoning about them, then keep on reading.

Next, you’ll explore the differences between instance, class, and static methods in a somewhat abstract code example. Abstract you say? Don’t worry—it involves runnable code, and it’s there to set the stage for a more practical example later on.

Gain Insight Through an Abstract Example

To get warmed up, you’ll write a small Python file calleddemo.py with a bare-bones Python class that contains stripped-down examples of all three method types:

classDemoClass:definstance_method(self):return("instance method called",self)@classmethoddefclass_method(cls):return("class method called",cls)@staticmethoddefstatic_method()return("static method called",)

Insidedemo.py, you createDemoClass—a descriptively named custom class with the sole purpose of demoing the differences between instance methods, class methods, and static methods.

Consequently, you also implement one of each of the three method types and name them accordingly. They each return atuple containing information to help you trace what’s going on, as well as the arguments the method received, such asself andcls. The output will help you understand whichobjects each of the methods can access.

Now it’s time to call these demo methods in a newREPL session. ImportDemoClass and create an instance of it, then start by calling theinstance method:

>>>fromdemoimportDemoClass>>>obj=DemoClass()>>>obj.instance_method()('instance method called', <demo.DemoClass object at 0x100a30d70>)

The output confirms that.instance_method() has access to the object instance through theself argument. Python prints the object instance as<demo.DemoClass object at 0x100a30d70>. When you call the instance method, Python replaces theself argument with the instance object,obj.

Instance methods can also access the class itself through theself.__class__ attribute. This makes instance methods powerful in terms of access restrictions. They can modify state on the object instanceand on the class itself.

Next, you can try out theclass method:

>>>obj.class_method()('class method called', <class 'demo.DemoClass'>)

Calling.class_method() shows that the method doesn’t have access to theDemoClass instance object that the instance method had access to. However, it can access the class, which you can see by the output<class 'demo.DemoClass'>. This output represents the class object itself. Remember that everything in Python is an object, even classes themselves!

Notice how Python automatically passes the class as the first argument to the function when you callobj.class_method(). Calling a class method in Python through thedot notation triggers this behavior. Theself parameter on instance methods works in the same way. Now, Python automatically passes the instance as the first argument when you call an instance method on an instance object.

Finally, it’s time to call thestatic method:

>>>obj.static_method()('static method called',)

You get your information message as output but no additional objects. This confirms that static methods can neither access the object instance state nor the class state. They work like regular functions but belong to the namespace of the class. They also belong to the namespace of each instance.

Now, take a look at what happens when you attempt to call these methods on the class itself without creating an object instance beforehand. To do this properly, you should start a newREPL session to ensure there are no existing instances of the class:

>>>fromdemoimportDemoClass>>>DemoClass.class_method()('class method called', <class 'demo.DemoClass'>)>>>DemoClass.static_method()('static method called',)>>>DemoClass.instance_method()Traceback (most recent call last):...TypeError:DemoClass.instance_method()⮑ missing 1 required positional argument: 'self'

You’re able to call.class_method() and.static_method() just fine, but attempting to call.instance_method() fails with aTypeError.

This is to be expected because in this case, you didn’t create an object instance and tried calling an instance method directly on the class itself. Since there’s no way for Python to populate theself argument, the call fails.

However, you don’tneed to call an instance method on the instance object like you did previously. In the end, that’s justsyntactic sugar that Python implements to make the call more intuitive. If you want, you can ignore the syntactic sugar of the dot notation syntax and pass the instance object manually to get the same result:

>>>obj=DemoClass()>>>DemoClass.instance_method(obj)('instance method called', <demo.DemoClass object at 0x100a30d70>)

In this case, you manually pass theobj instance to the instance method while calling the instance method on the class object. Doing so produces the same result as calling the instance method on the instance, without explicitly passingself.

Now that you’ve worked through this bare-bones example and have a better understanding of how the different method types work, you’re ready to look at a more realistic example of when to use each of the three method types.

Apply Your Knowledge With a Practical Example

The basic example from the previous section shows the distinction between instance methods, class methods, and static methods. However, it’s quite abstract and doesn’t give you a good idea of why and when you might want to use one method type over another. To connect what you learned with the real world, you’ll now explore this topic with a more realistic example.

Everyone loves pizza, so it’ll be your delicious and circular gateway to implementing instance methods, class methods, and a static method in the real world. Go ahead and define a basicPizza class inpizza.py:

classPizza:def__init__(self,toppings):self.toppings=list(toppings)def__repr__(self):returnf"Pizza({self.toppings})"

The class contains the twospecial methods.__init__() and.__repr__(). Both of these methods operate on the instance, so you don’t need to add adecorator. It’s common to set up these two special methods for most of your custom Python classes:

• .__init__() controls object instantiation.
• .__repr__() provides a string representation for when you need to display an object.

If you’re not familiar with these two special methods, then you may want to first read more aboutclass constructors andcustomizing object rerpresentation. But feel free to skip that and keep going with this tutorial.Understanding special methods isn’t crucial to grasp how to distinguish between instance, class, and static methods.

ThePizza class defines a dataattribute called.toppings. You can use anyiterable containing the pizza toppings when you create an instance of the class. However, the.__init__() method casts this into alist, as your class definition will assume this attribute is a list.

You can explore your newPizza class in a REPL session:

>>>frompizzaimportPizza>>>Pizza(["cheese","tomatoes"])Pizza(['cheese', 'tomatoes'])

Yum! Cheese and tomato pizza. That’s already a good start, but of course there’s a lot more to pizza. You want to customize the toppings on your pizza, so it’s time to add two instance methods that can handle the task.

classPizza:# ...defadd_topping(self,topping):self.toppings.append(topping)defremove_topping(self,topping):iftoppinginself.toppings:self.toppings.remove(topping)

>>>frompizzaimportPizza>>>a_pizza=Pizza(["cheese","tomatoes"])>>>a_pizzaPizza(['cheese', 'tomatoes'])>>>a_pizza.add_topping("garlic")>>>a_pizzaPizza(['cheese', 'tomatoes', 'garlic'])>>>a_pizza.remove_topping("cheese")>>>a_pizzaPizza(['tomatoes', 'garlic'])

>>>Pizza(["mozzarella","tomatoes"])Pizza(['mozzarella', 'tomatoes'])>>>Pizza(["mozzarella","tomatoes","ham","mushrooms"])Pizza(['mozzarella', 'tomatoes', 'ham', 'mushrooms'])>>>Pizza(["mozzarella"]*4)Pizza(['mozzarella', 'mozzarella', 'mozzarella', 'mozzarella'])

classPizza:# ...@classmethoddefmargherita(cls):returncls(["mozzarella","tomatoes"])@classmethoddefprosciutto(cls):returncls(["mozzarella","tomatoes","ham"])

>>>frompizzaimportPizza>>>Pizza.margherita()Pizza(['mozzarella', 'tomatoes'])>>>Pizza.prosciutto()Pizza(['mozzarella', 'tomatoes', 'ham'])

>>>a_pizza=Pizza.prosciutto()>>>a_pizzaPizza(['mozzarella', 'tomatoes', 'ham'])>>>a_pizza.add_topping("garlic")>>>a_pizzaPizza(['mozzarella', 'tomatoes', 'ham', 'garlic'])

classPizza:# ...@staticmethoddefget_size_in_inches(size):"""Returns the diameter in inches for common pizza sizes."""size_map={"small":8,"medium":12,"large":16,}returnsize_map.get(size,"Unknown size")

>>>frompizzaimportPizza>>>a_pizza=Pizza(["mozzarella","tomatoes"])>>>a_pizza.get_size_in_inches("medium")12>>>Pizza.get_size_in_inches("small")8

Conclusion

By now, you’ve seen that instance, class, and static methods each play a distinct role in designing maintainable, object-oriented Python code. When you use them intentionally, these three method types can improve your code’s clarity, reusability, and testability.

In this tutorial, you learned that:

• Instance methods encapsulate logic that operateson individual objects, giving you direct access to instance-specific state throughself.
• Class methods focus onclass-level concerns, providing an elegant way to createfactory methods and alternative constructors throughcls.
• Static methods act asstand-alone utilities that fit neatly within a class’snamespace.
• Choosing the right method type helpscommunicate developer intent by clarifying which data each method cares about.
• Using all three method types intentionally reduces bugs and improves maintainability by setting upstructured boundaries in class design.

The next time you design a Python class, take a moment to consider whether your methods need access to instance data, class data, or neither. If it makes sense, then place a decorator before your method definition to make your code both more readable and more robust.

Use all three method types in combination with Python’s other object-oriented features to create classes that are intuitive to read and straightforward to maintain. Happy coding—and happy pizza-making!

Frequently Asked Questions

Now that you have some experience with instance, class, and static methods in Python, you can use the questions and answers below to check your understanding and recap what you’ve learned.

These FAQs are related to the most important concepts you’ve covered in this tutorial. Click theShow/Hide toggle beside each question to reveal the answer.

Take the Quiz: Test your knowledge with our interactive “Python's Instance, Class, and Static Methods Demystified” quiz. You’ll receive a score upon completion to help you track your learning progress:

---

Interactive Quiz

Python's Instance, Class, and Static Methods Demystified

In this quiz, you'll test your understanding of instance, class, and static methods in Python. By working through this quiz, you'll revisit the differences between these methods and how to use them effectively in your Python code.