Python's Instance, Class, and Static Methods Demystified

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 a self parameter pointing to an instance of the class. They can access and modify instance state through self and class state through self.__class__. These are the most common methods in Python classes.

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

• Static methods don’t take self or cls 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 called demo.py with a bare-bones Python class that contains stripped-down examples of all three method types:

class DemoClass:
    def instance_method(self):
        return ("instance method called", self)

    @classmethod
    def class_method(cls):
        return ("class method called", cls)

    @staticmethod
    def static_method()
        return ("static method called",)

Inside demo.py, you create DemoClass—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 a tuple containing information to help you trace what’s going on, as well as the arguments the method received, such as self and cls. The output will help you understand which objects each of the methods can access.

Now it’s time to call these demo methods in a new REPL session. Import DemoClass and create an instance of it, then start by calling the instance method:

>>> from demo import DemoClass

>>> 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 the self argument. Python prints the object instance as <demo.DemoClass object at 0x100a30d70>. When you call the instance method, Python replaces the self argument with the instance object, obj.

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.

Next, you can try out the class method:

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

Calling .class_method() shows that the method doesn’t have access to the DemoClass 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 call obj.class_method(). Calling a class method in Python through the dot notation triggers this behavior. The self 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 the static 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 new REPL session to ensure there are no existing instances of the class:

>>> from demo import DemoClass

>>> 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 a TypeError.

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 the self argument, the call fails.

However, you don’t need to call an instance method on the instance object like you did previously. In the end, that’s just syntactic 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 the obj 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 passing self.

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 basic Pizza class in pizza.py:

class Pizza:
    def __init__(self, toppings):
        self.toppings = list(toppings)

    def __repr__(self):
        return f"Pizza({self.toppings})"

The class contains the two special methods .__init__() and .__repr__(). Both of these methods operate on the instance, so you don’t need to add a decorator. 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 about class constructors and customizing 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.

The Pizza class defines a data attribute called .toppings. You can use any iterable containing the pizza toppings when you create an instance of the class. However, the .__init__() method casts this into a list, as your class definition will assume this attribute is a list.

You can explore your new Pizza class in a REPL session:

>>> from pizza import Pizza

>>> 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.

class Pizza:
    # ...

    def add_topping(self, topping):
        self.toppings.append(topping)

    def remove_topping(self, topping):
        if topping in self.toppings:
            self.toppings.remove(topping)

>>> from pizza import Pizza
>>> a_pizza = Pizza(["cheese", "tomatoes"])
>>> a_pizza
Pizza(['cheese', 'tomatoes'])

>>> a_pizza.add_topping("garlic")
>>> a_pizza
Pizza(['cheese', 'tomatoes', 'garlic'])

>>> a_pizza.remove_topping("cheese")
>>> a_pizza
Pizza(['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'])

class Pizza:
    # ...

    @classmethod
    def margherita(cls):
        return cls(["mozzarella", "tomatoes"])

    @classmethod
    def prosciutto(cls):
        return cls(["mozzarella", "tomatoes", "ham"])

>>> from pizza import Pizza

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

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

>>> a_pizza = Pizza.prosciutto()
>>> a_pizza
Pizza(['mozzarella', 'tomatoes', 'ham'])

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

class Pizza:
    # ...

    @staticmethod
    def get_size_in_inches(size):
        """Returns the diameter in inches for common pizza sizes."""
        size_map = {
            "small": 8,
            "medium": 12,
            "large": 16,
        }
        return size_map.get(size, "Unknown size")

>>> from pizza import Pizza

>>> 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 operates on individual objects, giving you direct access to instance-specific state through self.
• Class methods focus on class-level concerns, providing an elegant way to create factory methods and alternative constructors through cls.
• Static methods act as stand-alone utilities that fit neatly within a class’s namespace.
• Choosing the right method type helps communicate developer intent by clarifying which data each method cares about.
• Using all three method types intentionally reduces bugs and improves maintainability by setting up structured 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 the Show/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.