Python Class Method Explained With Examples

In Object-oriented programming, we use instance methods and class methods. Inside a Class, we can define the following three types of methods.

• Instance method: Used to access or modify the object state. If we use instance variables inside a method, such methods are called instance methods. It must have a self parameter to refer to the current object.
• Class method: Used to access or modify the class state. In method implementation, if we use only class variables, then such type of methods we should declare as a class method. The class method has a cls parameter which refers to the class.
• Static method: It is a general utility method that performs a task in isolation. Inside this method, we don’t use instance or class variable because this static method doesn’t take any parameters like self and cls.

Also, read Python Class method vs Static method vs Instance method.

After reading this article, you’ll learn:

• How to create and use the class methods in Python
• Create class method using the @classmethod decorator and classmethod() function
• how to dynamically add or delete class methods

What is Class Method in Python

Class methods are methods that are called on the class itself, not on a specific object instance. Therefore, it belongs to a class level, and all class instances share a class method.

• A class method is bound to the class and not the object of the class. It can access only class variables.
• It can modify the class state by changing the value of a class variable that would apply across all the class objects.

In method implementation, if we use only class variables, we should declare such methods as class methods. The class method has a cls as the first parameter, which refers to the class.

Class methods are used when we are dealing with factory methods. Factory methods are those methods that return a class object for different use cases. Thus, factory methods create concrete implementations of a common interface.

The class method can be called using ClassName.method_name() as well as by using an object of the class.

Define Class Method

Any method we create in a class will automatically be created as an instance method. We must explicitly tell Python that it is a class method using the @classmethod decorator or classmethod() function.

Class methods are defined inside a class, and it is pretty similar to defining a regular function.

Like, inside an instance method, we use the self keyword to access or modify the instance variables. Same inside the class method, we use the cls keyword as a first parameter to access class variables. Therefore the class method gives us control of changing the class state.

• You may use a variable named differently for cls, but it is discouraged since self is the recommended convention in Python.
• The class method can only access the class attributes, not the instance attributes

Example 1: Create Class Method Using @classmethod Decorator

To make a method as class method, add @classmethod decorator before the method definition, and add cls as the first parameter to the method.

The @classmethod decorator is a built-in function decorator. In Python, we use the @classmethod decorator to declare a method as a class method. The @classmethod decorator is an expression that gets evaluated after our function is defined.

Let’s see how to create a factory method using the class method. In this example, we will create a Student class object using the class method.

from datetime import date

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

    @classmethod
    def calculate_age(cls, name, birth_year):
        # calculate age an set it as a age
        # return new object
        return cls(name, date.today().year - birth_year)

    def show(self):
        print(self.name + "'s age is: " + str(self.age))

jessa = Student('Jessa', 20)
jessa.show()

# create new object using the factory method
joy = Student.calculate_age("Joy", 1995)
joy.show()

Output

Jessa's age is: 20
John's age is: 26

• In the above example, we created two objects, one using the constructor and the second using the calculate_age() method.
• The constructor takes two arguments name and age. On the other hand, class method takes cls, name, and birth_year and returns a class instance which nothing but a new object.
• The @classmethod decorator is used for converting calculate_age() method to a class method.
• The calculate_age() method takes Student class (cls) as a first parameter and returns constructor by calling Student(name, date.today().year - birthYear), which is equivalent to Student(name, age).

Example 2: Create Class Method Using classmethod() function

Apart from a decorator, the built-in function classmethod() is used to convert a normal method into a class method. The classmethod() is an inbuilt function in Python, which returns a class method for a given function.

Syntax:

classmethod(function)

• function: It is the name of the method you want to convert as a class method.
• It returns the converted class method.

Note: The method you want to convert as a class method must accept class (cls) as the first argument, just like an instance method receives the instance (self).

As we know, the class method is bound to class rather than an object. So we can call the class method both by calling class and object.

A classmethod() function is the older way to create the class method in Python. In a newer version of Python, we should use the @classmethod decorator to create a class method.

Example: Create class method using classmethod() function

class School:
    # class variable
    name = 'ABC School'

    def school_name(cls):
        print('School Name is :', cls.name)

# create class method
School.school_name = classmethod(School.school_name)

# call class method
School.school_name()

Output

School Name is : ABC School

Example 3: Access Class Variables in Class Methods

Using the class method, we can only access or modify the class variables. Let’s see how to access and modify the class variables in the class method.

Class variables are shared by all instances of a class. Using the class method we can modify the class state by changing the value of a class variable that would apply across all the class objects.

class Student:
    school_name = 'ABC School'

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

    @classmethod
    def change_school(cls, school_name):
        # class_name.class_variable
        cls.school_name = school_name

    # instance method
    def show(self):
        print(self.name, self.age, 'School:', Student.school_name)

jessa = Student('Jessa', 20)
jessa.show()

# change school_name
Student.change_school('XYZ School')
jessa.show()

Output:

Jessa 20 School: ABC School
Jessa 20 School: XYZ School

Class Method in Inheritance

In inheritance, the class method of a parent class is available to a child class.

Let’s create a Vehicle class that contains a factory class method from_price() that will return a Vehicle instance from a price. When we call the same method using the child’s class name, it will return the child’s class object.

Whenever we derive a class from a parent class that has a class method then it creates the correct instance of the derived class. The following example shows how the class method works in inheritance.

Example

class Vehicle:
    brand_name = 'BMW'

    def __init__(self, name, price):
        self.name = name
        self.price = price

    @classmethod
    def from_price(cls, name, price):
        # ind_price = dollar * 76
        # create new Vehicle object
        return cls(name, (price * 75))

    def show(self):
        print(self.name, self.price)

class Car(Vehicle):
    def average(self, distance, fuel_used):
        mileage = distance / fuel_used
        print(self.name, 'Mileage', mileage)

bmw_us = Car('BMW X5', 65000)
bmw_us.show()

# class method of parent class is available to child class
# this will return the object of calling class
bmw_ind = Car.from_price('BMW X5', 65000)
bmw_ind.show()

# check type
print(type(bmw_ind))

Output

BMW X5 65000
BMW X5 4875000
class '__main__.Car'

Dynamically Add Class Method to a Class

Typically, we add class methods to a class body when defining a class. However, Python is a dynamic language that allows us to add or delete methods at runtime. Therefore, it is helpful when you wanted to extend the class functionality without changing its basic structure because many systems use the same structure.

We need to use the classmethod() function to add a new class method to a class.

Example:

Let’s see how to add a new class method in the Student class at runtime.

class Student:
    school_name = 'ABC School'

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

    def show(self):
        print(self.name, self.age)

# class ended

# method outside class
def exercises(cls):
    # access class variables
    print("Below exercises for", cls.school_name)

# Adding class method at runtime to class
Student.exercises = classmethod(exercises)

jessa = Student("Jessa", 14)
jessa.show()
# call the new method
Student.exercises()

Output

Jessa 14
Below exercises for ABC School

Dynamically Delete Class Methods

We can dynamically delete the class methods from the class. In Python, there are two ways to do it:

• By using the del operator
• By using delattr() method

By using the del operator

The del operator removes the instance method added by class. Use the del class_name.class_method syntax to delete the class method.

Example:

In this example, we will delete the class method named change_school() from a Student class. If you try to access it after removing it, you’ll get an Attribute Error.

class Student:
    school_name = 'ABC School'

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

    @classmethod
    def change_school(cls, school_name):
        cls.school_name = school_name

jessa = Student('Jessa', 20)
print(Student.change_school('XYZ School'))
print(Student.school_name)

# delete class method
del Student.change_school

# call class method
# it will give error
print(Student.change_school('PQR School'))

Output

XYZ School
AttributeError: type object 'Student' has no attribute 'change_school'

By using delatt() method

The delattr() method is used to delete the named attribute and method from the class. The argument to delattr is an object and string. The string must be the name of an attribute or method name.

Example

jessa = Student('Jessa', 20)
print(Student.change_school('XYZ School'))
print(Student.school_name)

# delete class method
delattr(Student, 'change_school')

# call class method
# it will give error
print(Student.change_school('PQR School'))

Output

XYZ School
AttributeError: type object 'Student' has no attribute 'change_school'