Python classmethod is the way to define a function for the python class.
Table of Contents
Python classmethod
In this post on Python, we will see how we can define and use class methods. We will see ways in which we can create class methods and call them in our program.
Type of methods in Python
In Python, there are two types of functions which can be created in a program. They are:
- Static methods
- Class methods
On how to create and use static methods, read this post.
In this lesson, we will focus on class methods.
Making python class methods
A class method is the one which can be called only with the instance of an Object. These methods usually define the behavior of an object and modify the object’s properties or instance variables.
There are two ways to create class methods in Python:
- Using classmethod(function)
- Using @classmethod annotation
Using classmethod()
look non-Pythonic and hence, in newer Python versions, we can use the @classmethod annotation decorator for making class methods.
Providing Boilerplate
In this section, we will try to establish an understanding with class methods. Here is a sample program to start with:
class DateTime(object):
def __init__(self, day=10, month=10, year=2000):
self.day = day
self.month = month
self.year = year
This is just a simple class definition to start with. We will build our example on this. We included an __init__
function to initialize the instance of the object for this class.
Including class methods
Now, we will enhance the boilerplate code in the last section and include a class method in it which can receive a date as a String
and return a real Date
instance. Let’s look at a code snippet:
@classmethod
def from_string(cls, string_date):
day, month, year = map(int, string_date.split('-'))
myDate = cls(day, month, year)
return myDate
Notice that this method will act as a constructor for this class as well due to the reason that this method takes in class as its reference. Also, it actually constructs the class instance from a String.
Let’s look at a code snippet on how this constructor can be put to use:
dateObj = DateTime.from_string('20-05-1994')
How does it differ from static method?
Static methods are the one which belongs to a class rather than a particular instance of that class. Here is a sample static method for the DateTime
class we defined::
@staticmethod
def is_valid_date(date_as_string):
day, month, year = map(int, date_as_string.split('-'))
return day <= 31 and month <= 12 and year <= 3999
This can be put to use like:
is_valid_date = Date.is_date_valid('20-05-1994')
Here, we don’t do anything with any instance of the class and just check if something is appropriate to be converted to the instance of that class.
Our complete class code looks like:
class DateTime(object):
def __init__(self, day=10, month=10, year=2000):
self.day = day
self.month = month
self.year = year
@classmethod
def from_string(cls, string_date):
day, month, year = map(int, string_date.split('-'))
myDate = cls(day, month, year)
return myDate
@staticmethod
def is_valid_date(date_as_string):
day, month, year = map(int, date_as_string.split('-'))
return day <= 31 and month <= 12 and year <= 3999
dateObj = DateTime.from_string('20-05-1994')
is_valid_date = DateTime.is_valid_date('20-05-1994')
print(is_valid_date)
Output will look simply:
Conclusion
The @classmethod
annotation decorator is used to create factory methods as they can take any input and provide a class object based on the parameters and processing. Using this decorator, it is possible to create as many constructors for a class which behaves as factory constructors.
why not write like this ?
def from_string(string_date):
day, month, year = map(int, string_date.split(‘-‘))
myDate = DateTime(day, month, year)
return myDate
Shouldn’t it be
dateObj = DateTime.from_string(’20-05-1994′) instead of dateObj = Date.from_string(’20-05-1994′)
Really good blog! Thanks
Yes, you are right. I have fixed the typo error.
what is factory method?
how to create packages in python using modules