Close
Close

Python Instance Class and Static Method


We read about classes and objects in the previous chapter. We also read that the attributes which belong to a class and are accessible by all the objects of the class are called class attributes and the attributes which belong to objects are called instance attributes. In this chapter, we will be looking at different types of methods a class can have.

Till now, the methods we have seen were used to access or change instance attributes. These are called instance methods and you will be using mostly these methods only in classes. 

However, there are two other types of methods: class methods and static methods. Class methods are used to access or change class attributes. Static methods are normal functions which don’t deal with anything related to classes. For example, static methods can be used to print some message or detect if a number passed to it is even.

Let’s look at them one by one.

Python Instance Methods


Instance methods are the regular methods we use in classes. These are used most of the time. Till now, all the methods we saw were instance methods. 

We know that instance methods take self as the first parameter which refers to an object of the class. These are mostly used to access or change the attributes of the object on which they are called.

Instance methods can be called only by the objects of the class in which they are defined.

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

st1 = Student("John")
st2 = Student("Johny")

print(st1.display())
print(st2.display())
Output
John
Johny

The display() method is an instance method and so it receives self as a parameter which refers to the current object (object which calls the method). It accesses the attribute name in self.name of only the object which calls this method.

When the object st1 calls the method, then self.name becomes the same as st1.name. When st2 calls the method, then self.name becomes the same as st2.name.

Python Class Methods


Class methods take cls as the first parameter which refers to the current class. These are used to access or change the class attributes. You know that class attributes can be accessed by all the objects of a class.

To define a class method, @classmethod decorator is used before the function definition. We will read more about decorators later.

Class methods can be called by the objects of the class as well as by the class in which they are defined. So unlike instance methods, we can call class methods directly with class (without making any object).

class Student():
    name = "John"
		
    @classmethod
    def create(cls):
        return cls.name

print(Student.create())
Output
John

In this example, create() is a class method because it is defined following the @classmethod decorator. This method is called by the Student class by writing Student.create() and so it takes the class Student as its first parameter cls.

It accesses the class attribute name by writing cls.name. Writing cls.name is the same as writing Student.name.

Let’s look at another example in which a class method is used to call the constructor when an object of the class is created.

class Student():
    def __init__(self, name, age):
        self.name = name
        self.age = age
		
    @classmethod	
    def create(cls, name, age):
        return cls(name, age + 1)

st1 = Student("John", 20)
st2 = Student.create("Johny", 30)

print(st1.age)
print(st2.age)
Output
20
31

In this example, the first object st1 is created normally using constructor and the second object st2 is created using the create() class method.

In the create method, return cls(name, age + 1) is similar to return Student(name, age + 1).

The create() method takes the Student class as its first parameter cls, and name and age as the other two parameters. Then it increases the age by 1 and finally returns the constructor by calling cls(name, age + 1) (Writing cls(name, age + 1) is the same as writing Student(name, age + 1)) .This returned constructor creates a new instance with the passed name and age.

Python Static Methods


Static methods, like class methods, are bound to a class and not its objects. A static method doesn’t know anything about the attributes or other definitions of the class in which it is defined. These are mostly used as independent utility functions which don’t access or interfere with the state or attributes of the class.

To define a static method, @staticmethod decorator is used before the function definition.

Static methods can be called by the objects of the class as well as by the class itself in which they are defined.

class Number():
		
    @staticmethod
    def even(x):
        if x % 2 == 0:
            return True
        else:
            return False

print(Number.even(40))
Output
True

In this example, even() is a static method because it is defined following the @staticmethod decorator. And yes, as we said, it is just a normal function defined inside a class and doesn’t interfere with the class members. It returns True if its parameter is even, and returns False otherwise.

Let’s see an example where class method and static method are used together.

class Person():
    def __init__(self, name, age, can_vote):
        self.name = name
        self.age = age
        self.can_vote = can_vote
	
    @staticmethod
    def is_adult(age):
        if age >= 18:
            return True
        else:
            return False
		
    @classmethod	
    def create(cls, name, age):
        if cls.is_adult(age) == True:
            return cls(name, age, "Yes")
        else:
            return cls(name, age, "No")

st1 = Person.create("John", 15)
st2 = Person.create("Johny", 20)

print("Can", st1.name, "vote?", st1.can_vote)
print("Can", st2.name, "vote?", st2.can_vote)
Output
Can John vote? No
Can Johny vote? Yes

In the above example, is_adult() is a static method which returns True if the age passed to it is greater than or equal to 18, and returns False otherwise. 

create() is a class method which calls the constructor with suitable arguments. 

st1 = Person.create("John", 15) - While creating an object st1, the Person class calls the create() method passing the name and age parameters. 

The create() method internally calls the is_adult() method which returns True or False depending on whether the age passed to it is greater than 18 or not. If it returns True, then the create() method calls the constructor with the third argument as “Yes”, otherwise calls it with the third argument as “No”. The constructor then assigns the passed values to the name, age and can_vote attributes of the current object st1.

Similarly, the other object st2 is created.

We read about the three types of methods we can deal with in OOP, but mostly we use instance methods.

To learn from simple videos, you can always look at our Python video course on CodesDope Pro. It has over 500 practice questions and over 20 projects.
All our dreams can come true, if we have the courage to pursue them.
- Walt Disney


Ask Yours
Recent Posts
asds
asds
jasd
jasd
as
as
Post Yours
Doubt? Ask question