Advertisement

---

Top

< Prev

Next >

In the previous article, we have introduced you to the concept of a static method in Python and its features. In this article, we are going to explain the feature of a class method in Python i.e. how to define a class method in a class, how to call it and finally, the difference between a class method and a static method.

Features of a class method-

• A class method is a method which is bound to the class in which it is defined, and not to the object of the class. So, we can say that, a class method belongs to the class in which it is defined.


• Only one copy of a class method is shared by all the objects of its class and even by the subclasses of the class.


• A class method should be accessed by its class name with a dot operator, though in some cases it can even be accessed by an object of its class.


• Unlike the definition of a general method of a class, we do not have to specify the self keyword in the parameters of a class method, because a class method is bound to its class and it has got nothing to do with the objects of a class.


• A class method should rather be defined with a keyword cls in its parameters, where cls is used to access the class and its properties which has called the class method.

• Creating a class method using the @classmethod decorator


Within a class, we could create a class method by using the @classmethod decorator. This decorator is placed just before we are going to define the class method in a class.

Note : On calling such class method, it implicitly receives the class as its first argument, therefore, a class method should be defined with a keyword cls in its parameters, where cls is used to access the class which has called the class method. .



# Python - Creating a class method 

class Test:
    # Defining a class method using @classmethod decorator

    @classmethod
    def class_meth(cls):
        print('Hello from the class method')


In the example above, we have defined a class method named class_meth() which belongs to the class Test, by using the @classmethod decorator just above the class method definition.

Note : As you can see in the program above, unlike the definition of a general method of a class in Python, we have not specified the self keyword in the parameters of the class method, because self refers to the currently executing object, while a class method has got nothing to do with the objects of a class.

Now, let us see the ways to call a class method.






• Calling a class method using its class name.


A static method can be accessed by using its class name and a dot operator. Let us see an example.



# Python - Creating a class method 

class Test:
    # Defining a class method using @classmethod decorator

    @classmethod
    def class_meth(cls):
        print('Hello from the class method')
		
# Calling the class method by using the class name with the dot operator
Test.class_meth()





Output is :




Hello from the class method


We have called the class method class_meth() by using its class name i.e. Test with a dot operator.




Advertisement






• Accessing a class method using the object of its class.


A class method can also be accessed by using the object of its class with a dot operator, but, with a condition that after defining the class method, we must not have defined a general method with the same name as the class method, which could overshadow/replace the definition of the class method. Let us see an example.



# Python - Creating a class method 

class Test:
    # Defining a class method using @classmethod decorator

    @classmethod
    def class_meth(cls):
        print('Hello from the class method')
		
ob = Test()

# Calling the class method by using the object name with the dot operator
ob.class_meth()





Output is :




Hello from the class method








• Accessing a class method from within a general method of a class.


A class method can be accessed from within a general method of its class by two ways :
• By using its class name.
• By using the self keyword, which refers to the current object of its class and in this case, the compiler internally replaces the object name with its class name. Let us see an example.




# Python - A static method


class Test:
 
    # Defining a class method using @classmethod decorator

    @classmethod
    def stat(cls):
        print('Hello from the class method')



    # Defining a general method
    def method(self):
    
        #Calling the class method from within this general method by using self keyword i.e. current object.
        #In this case, an object name is internally replaced by its class name while calling a static method
        self.stat()

        
        #Calling the class method from within this general method using the class name
        Test.stat()


# Creating an object of class Test
ob = Test()

# Calling the method()
ob.method()





Output is :




Hello from the class method
Hello from the class method








• Instance method overshadowing class method.


A class method can be overshadowed by an instance method when we have defined an instance method after defining a class method with the same name.

In such a case, accessing a class method by using the object of its class(like in the previous example) will give us an access to the instance method and not the class method.



# Python - A general method overshadowing a class method


class Test:
 
    # Defining a class method using @classmethod decorator

    @classmethod
    def stat():
        print('Hello from a  class method')



    # Defining a general method with the same name as a class method
    # Hence, the definition of class method will be overshadowed i.e. replaced by this general method
    def stat(self):
          print('Hello from a general method')



# Creating an object of class Test
ob = Test()


# This will call the general method and not the class method
# because the general method definition has overshadowed i.e. replaced the class method definition
ob.stat()


# Calling the class method using its class name will only lead to an error because it doesn't exist anymore
Test.stat()





Output is :




Hello from a general method
Traceback (most recent call last):
  File "D:/Python Programs/class_method2.py", line 31, in <module>
    Test.stat()
TypeError: stat() missing 1 required positional argument: 'self'





Program Analysis



In the example above, the definition of class method named stat() has been replaced by the definition of a general method with the same name, therefore -
• Accessing the class method named stat() with the object of class has only given us access to the instance method of the class.
• Accessing a class method named stat() by using its class name has lead to an error because its definition has been overshadowed/replaced by the definition of a general method with the same name, stat().







• We could modify class/static variable within a class method


Within a class method, we could access and modify the class/static variable of the class by using the cls keyword, which refers to the class which has called the class method.



# Python - Creating a class method


class Test:

    # Defining a class variable
    message = 'Have a good day'
    num = 19
    
    # Defining a class method using @classmethod decorator
    
    @classmethod
    def class_meth(cls):
        print('message : ', cls.message)
        print('num : ', cls.num)
        cls.message= cls.message + ' and keep smiling :-)'
        cls.num = 5.5
        print('Updated message :', cls.message)
        print('Updated num : ',cls.num)



# Creating an object of Test class
ob = Test()

# Calling the class method by using the object name with the dot operator
ob.class_meth()





Output is :




message :  Have a good day
num :  19
Updated message : Have a good day and keep smiling :-)
Updated num :  5.5








• Incorrect access of a static variable.


A class method cannot be accessed directly.



# Python - A static method


class Test:
 
    # Defining a static method using @classmethod decorator

    @classmethod
    def stat():
        print('Hello from the static method')


# Incorrect direct access of a class method
stat()





Output is :




Traceback (most recent call last):
  File "D:/Python Programs/class_method3.py", line 15, in <module>
    stat()
NameError: name 'stat' is not defined


As you see in the last program, direct access of a class method leads to an error, therefore, a class method should only be accessed using its class name.






Static method v/s Class method



• When defining a static method, we do not have to specify anything in its parameters, but when a class method should rather be defined with a keyword cls in its parameters.


• A static method does not have any of its own mechanism to access and modify the class variable but a class method can access and modify the class variables by using the keyword cls declared in its parameters.


• Both the static method and the class method can be inherited but the behaviour of a static method remains the same, irrespective of it being called by the object of its own class or its child class, whereas, the behaviour of a class method may change according the object of the class which has called it. Let us explain this point by an example






• Behaviour of class method changes depending on the object of class which has called it.


Let us show you how the behaviour of a class method may change(due to the use of cls keyword), depending on the object of class which has called it, but, the behaviour of a static method remains the same irrespective of the object of class which has called it.



# Python - Behaviour of class method changes  depending on the object of class which has called it.


class Fruit:

  @staticmethod
  def name():
     print('It is a fruit')

  @classmethod
  def message(cls):
     if(cls.__name__=='Apple'):
        print('Apple')
     elif(cls.__name__=='Mango'):
        print('Mango')

		
		

# Creating a class Mango inherited from class Fruit
class Mango(Fruit):
    pass


# Creating a class Apple inherited from class Fruit
class Apple(Fruit):
    pass


# Creating an object of Apple
ob_apple = Apple()


# Calling the class method, message, using the object of Apple class, because it is inherited by Apple class
ob_apple.message()


# Creating an object of Mango
ob_mango = Mango()


# Calling the class method, message, using the object of Mango class, because it is inherited by Mango class
ob_mango.message()


# Calling the static method, message, using the object of Apple class, because it is inherited by Apple class
ob_apple.name()


# Calling the static method, message, using the object of Mango class, because it is inherited by Mango class
ob_mango.name()





Output




Apple
Mango
It is a fruit
It is a fruit








Please share this article -






< Prev
Next >
< Python static method
Python Inheritance



Advertisement