Class Method vs Static Method vs Instance Method in Python

Three important types of methods in Python are class methods, static methods, and instance methods. Each serves a distinct purpose and contributes to the overall flexibility and functionality of object-oriented programming in Python. In this article, we will see the difference between class method, static method, and instance method with the help of examples in Python.

Class Method in Python

Class methods are associated with the class rather than instances. They are defined using the @classmethod decorator and take the class itself as the first parameter, usually named cls. Class methods are useful for tasks that involve the class rather than the instance, such as creating class-specific behaviors or modifying class-level attributes.

Syntax Python Class Method

class C(object):
    @classmethod
    def fun(cls, arg1, arg2, ...):
       ....
fun: function that needs to be converted into a class method
returns: a class method for function.

In this example, the MyClass defines a class variable class_variable, and the class_method is a class method that increments this variable. When calling the method with different values, it updates and returns the modified class variable. Instances obj1 and obj2 have their own instance_variable.

class MyClass:
    class_variable = 0

    def __init__(self, value):
        self.instance_variable = value

    @classmethod
    def class_method(cls, x):
        cls.class_variable += x
        return cls.class_variable

# Creating instances of the class
obj1 = MyClass(5)
obj2 = MyClass(10)

# Calling the class method
print(MyClass.class_method(3))  # Output: 3
print(MyClass.class_method(7))  # Output: 10

3
10

Static Method in Python

Static methods, as the name suggests, are not bound to either the class or its instances. They are defined using the @staticmethod decorator and do not take a reference to the instance or the class as their first parameter. Static methods are essentially regular functions within the class namespace and are useful for tasks that do not depend on instance-specific or class-specific data.

Syntax Python Static Method

class C(object):
    @staticmethod
    def fun(arg1, arg2, ...):
        ...
returns: a static method for function fun.

In this example, the MathOperations class features static methods add and subtract for performing basic arithmetic operations. These methods can be directly invoked on the class without creating an instance, providing a convenient and state-independent way to perform mathematical operations.

class MathOperations:
    @staticmethod
    def add(x, y):
        return x + y

    @staticmethod
    def subtract(x, y):
        return x - y

# Using static methods without creating an instance
print(MathOperations.add(5, 3))        # Output: 8
print(MathOperations.subtract(10, 4))  # Output: 6

8
6

Instance Method in Python

Instance methods are the most common type of methods in Python classes. They are associated with instances of a class and operate on the instance's data. When defining an instance method, the method's first parameter is typically named self, which refers to the instance calling the method. This allows the method to access and manipulate the instance's attributes.

Syntax Instance Method

class MyClass:
   def instance_method(self, arg1, arg2, ...):
       # Instance method logic here
       pass

In this example, the Person class defines an instance method introduce which returns a formatted introduction based on the instance's name and age attributes. The instance person1 is created with the name "Kishan" and age 20, and invoking the introduce method prints a personalized introduction for that instance. Note that there's a small typo in the comment mentioning the age; it should be 20 instead of 30.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        return f"Hi, I'm {self.name} and I'm {self.age} years old."


# Creating an instance of the class
person1 = Person("Kishan", 20)

# Calling the instance method
print(person1.introduce())  # Output: Hi, I'm Kishan and I'm 30 years old.

Hi, I'm Kishan and I'm 20 years old.

Python Class Method Vs. Static Method Vs. Instance Method

Conclusion

In conclusion, we learn about the three commonly used methods in python, which are class method, static method and instance method. we also looked at how each of them work and how they are different from one another by looking at examples of programs with their code as well as outputs and a difference table that tells the difference between these 3 methods. you can also find some articles which are related to the methods in python programming below.