The @staticmethod decorator
Python @staticmethod decorator is used to label a class method as a static method, which means that it can be called without instantiating the class first. It simply defines a normal function that is logically contained in the class for readability purposes. Here, we do not need to pass the class instance as the first argument via self
, unlike other class functions.
class Student():
def __init__(self, mark):
self.mark = mark
@staticmethod
def find_min(mark):
return min(mark, 100)
print(Student.find_min(20))
Output
20
Accessing via Class Instances
Static methods can also be accessed via class instances or objects. For example :
class Bank():
def __init__(self, balance):
self.balance = balance
@staticmethod
def find_interest(loan_money, interest_rate):
return loan_money * (1 + interest_rate)
bank = Bank(1000)
print(bank.find_interest(bank.balance, 0.3))
Output:
1300
Overriding static methods
Static method definitions are unchanged even after any inheritance, which means that it can be overridden, similar to other class methods.
class ATM(Bank):
def __init__(self, balance):
super().__init__(balance)
@staticmethod
def find_interest(loan_money):
return loan_money * 1.4
atm = ATM(1000)
print(atm.find_interest(atm.balance))
Output
1400
@staticmethod vs @classmethod
Class methods are called via the Class containing it, rather than from an instance. Which is why a classmethod is defined as class_method(cls, param1, param2)
, which does not contain self
, which means that it cannot be called using a class instance. Static methods can be called from both a class instance as well as from a Class.
@staticmethod vs instance methods
Instance methods can only be called from a class instance, which is why any instance method is of the forminstance_method(self, param1, param2)
, where the self
keyword signifies the class instance calling the method. @staticmethod
can be called from both a class instance as well as from a Class.

Here is an example to put it all together.
class Bank():
def __init__(self, balance):
self.balance = balance
@staticmethod
def find_interest(loan_money, interest_rate):
return loan_money * (1 + interest_rate)
@classmethod
def find_interest_classmethod(cls, loan_money):
return loan_money * 1.4
def find_interest_instancemethod(self, loan_money):
if self.balance <= 100:
return loan_money * 1.2
else:
return loan_money * 1.5
class ATM(Bank):
def __init__(self, balance):
super().__init__(balance)
@staticmethod
def find_interest(loan_money):
return loan_money * 1.3
atm = ATM(1000)
print('Using staticmethod ->', atm.find_interest(atm.balance))
print('Using classmethod from the parent class ->', Bank.find_interest_classmethod(atm.balance))
print('Using classmethod from the inherited subclass ->', ATM.find_interest_classmethod(atm.balance))
print('Using a regular instance method ->', atm.find_interest_instancemethod(atm.balance))
Output:
Using staticmethod -> 1300.0
Using classmethod from the parent class -> 1400.0
Using classmethod from the inherited subclass -> 1400.0
Using a regular instance method -> 1500.0
Conclusion
Python static methods belong to the class. They are useful in creating functions that don’t need instance variables to work. This article showed us the use cases of @staticmethod, and how they compare with other such decorators, namely the @classmethod decorator. We also gave a comparison between static methods, class methods, and regular instance methods, and showed how they can be used to make the class code easier to maintain.
References
Python Official Documentation: https://docs.python.org/3/library/functions.html#staticmethod