staticmethod() built-in function returns a static method for a given function.
class Calculator: def add_numbers(num1, num2): return num1 + num2# convert add_numbers() to static method Calculator.add_numbers = staticmethod(Calculator.add_numbers)sum = Calculator.add_numbers(5, 7) print('Sum:', sum) # Output: Sum: 12
The syntax of
staticmethod() is considered a un-Pythonic way of creating a static function. Hence, in newer versions of Python, you can use the
@staticmethod def func(args, ...)
staticmethod() method takes a single parameter:
- function - function that needs to be converted to a static method
staticmethod() Return Type
staticmethod() returns a static method for a function passed as the parameter.
What is a static method?
Static methods, much like class methods, are methods that are bound to a class rather than its object.
They do not require a class instance creation. So, they are not dependent on the state of the object.
The difference between a static method and a class method is:
- Static method knows nothing about the class and just deals with the parameters.
- Class method works with the class since its parameter is always the class itself.
They can be called both by the class and its object.
Class.staticmethodFunc() or even Class().staticmethodFunc()
Example 1: Create a static method using staticmethod()
class Mathematics: def addNumbers(x, y): return x + y# create addNumbers static method Mathematics.addNumbers = staticmethod(Mathematics.addNumbers)print('The sum is:', Mathematics.addNumbers(5, 10))
The sum is: 15
When do you use static methods?
1. Grouping utility function to a class
Static methods have a limited use case because, like class methods or any other methods within a class, they cannot access the properties of the class itself.
However, when you need a utility function that doesn't access any properties of a class but makes sense that it belongs to the class, we use static functions.
Example 2: Create a utility function as a static method
class Dates: def __init__(self, date): self.date = date def getDate(self): return self.date@staticmethod def toDashDate(date): return date.replace("/", "-")date = Dates("15-12-2016") dateFromDB = "15/12/2016" dateWithDash = Dates.toDashDate(dateFromDB) if(date.getDate() == dateWithDash): print("Equal") else: print("Unequal")
Here, we have a
Dates class that only works with dates with dashes. However, in our previous database, all dates were present in slashes.
In order to convert the slash-dates to dash-dates, we have created a utility function
It is a static method because it doesn't need to access any properties of
Dates itself and only requires the parameters.
We can also create
toDashDate outside the class, but since it works only for dates, it's logical to keep it inside the
2. Having a single implementation
Static methods are used when we don't want subclasses of a class change/override a specific implementation of a method.
Example 3: How inheritance works with static method?
class Dates: def __init__(self, date): self.date = date def getDate(self): return self.date@staticmethod def toDashDate(date): return date.replace("/", "-")class DatesWithSlashes(Dates): def getDate(self): return Dates.toDashDate(self.date) date = Dates("15-12-2016") dateFromDB = DatesWithSlashes("15/12/2016") if(date.getDate() == dateFromDB.getDate()): print("Equal") else: print("Unequal")
Here, we wouldn't want the subclass
DatesWithSlashes to override the static utility method
toDashDate because it only has a single use, i.e. change date to dash-dates.
We could easily use the static method to our advantage by overriding
getDate() method in the subclass so that it works well with the