Adventures in Machine Learning

Mastering Static Class and Instance Methods in Python

The @staticmethod Decorator in Python

In the realm of programming, methods play a crucial role within classes, empowering developers to execute a series of instructions, thereby altering the state of an object. Python offers two primary method types: Instance methods and Static methods. This article delves into the intricacies of Static methods.

Definition and Purpose

A static method is intrinsically tied to a class rather than its individual instances. Unlike instance methods, which necessitate an instance of the class for invocation, static methods can be called without the need to create an instance. This autonomy stems from their independence from the class object’s state.

To distinguish static methods from other class members, Python provides a built-in decorator named “@staticmethod.” This decorator serves as a clear marker, signifying a method’s static nature.

The primary objective of defining a static method in Python is to encapsulate functionality inherently belonging to the class, devoid of any reliance on instance data. It fosters code organization and optimizes performance by eliminating the overhead of object creation for each invocation.

Example of Implementation

Let’s illustrate the usage of the @staticmethod decorator with a simple example:

class Calculator:
def add(a, b):
return a + b

In this code snippet, we define a Calculator class containing a static method named “add.” The @staticmethod decorator precedes the method definition, declaring its static nature.

Now, we can invoke the “add” method without instantiating the Calculator class:

Calculator.add(2, 3)

This call will yield the value 5, the sum of 2 and 3. As evident, instance creation is not required to utilize the add method.

Accessing and Overriding Static Methods

Accessing Static Methods via Class Instances

Although not mandatory, static methods can be accessed through class instances, potentially aiding in encapsulation. This approach allows for static method invocation without exposing them directly to the module or external code.

class Car:
def make():
return "Car is being made"

def main():
car = Car()

if __name__ == '__main__':

Output: “Car is being made”

As demonstrated in the code above, we first instantiate the Car class and then invoke the “make” static method via the instance. The static nature of “make” permits access through the instance.

Overriding Static Methods using Inheritance

When inheriting from a class, it becomes necessary to override certain class methods, such as constructors, instance methods, or static methods. The process mirrors overriding base class methods.

Simply define the method with the same name in the derived class.

class Animal:
def run():
return "Animal is running"

class Cat(Animal):
def run():
return "Cat is running"

def main():
animal = Animal()
cat = Cat()

if __name__ == '__main__':


Animal is running
Cat is running

In this code, we have two classes: Animal and Cat. Animal possesses a static method called “run,” which is overridden in the “Cat” subclass to return “Cat is running” instead of “Animal is running.” The “@staticmethod” decorator, followed by the method definition, facilitates the overriding of the static method.


In conclusion, we have explored the utilization of the @staticmethod decorator in Python. It serves as a mechanism for code organization, enabling functionality associated with the class while eliminating the need for instance data. We have also examined accessing static methods through class instances and overriding them through inheritance.

Understanding static methods and their nuances is crucial for writing efficient and maintainable Python code, irrespective of your programming experience level.

Comparison of @staticmethod with @classmethod and Instance Methods

Python offers three distinct methods for interacting with objects: Instance Methods, Class Methods, and Static Methods. We have already discussed Static Methods (@staticmethod).

In this section, we delve into Class Methods (@classmethod) and Instance Methods.

Explanation of @classmethod Decorator

@classmethod is another Python decorator, operating similarly to @staticmethod. The primary distinction lies in the first argument; instead of receiving the object instance, it receives the class itself. Class Methods work on properties belonging to the class.

Here’s an illustrative example:

class Person:
age = 25

def printAge(cls):
print('The age is:', cls.age)


In the above code, we define a Person class with an attribute named “age.” We also define a class method called “printAge” using the “@classmethod” decorator. Invoking this method prints the “age” attribute associated with the class.

Explanation of Instance Methods

Instance Methods, also known as regular methods, are the most prevalent and default method type in Python. Defined within a class, they take “self” as the first parameter, indicating their operation on a specific instance of the class. Instance methods require an object of a class to be created for access.

Inside instance methods, you have full access to all properties of the instance or object. Here’s an example:

class Dog:
def __init__(self, name, age): = name
self.age = age

def bark(self):
return f"{} is barking"

dog = Dog("Bingo", 3)

In this code, we define a Dog class with an instance method called “bark.” The method takes “self” as its first parameter, representing the class instance. We then instantiate the Dog class and call the “bark” method, resulting in a string output.

Example of Using All Three Types of Methods in a Class

Having covered Static Methods, Class Methods, and Instance Methods, let’s examine a class that utilizes all three types.

class Laptop:
tax_percentage = 0.15

def __init__(self, brand, model, price):
self.brand = brand
self.model = model
self.price = price

def get_price(self):
return self.price

def calculate_price_with_tax(cls, price):
return price + (price * cls.tax_percentage)

def is_expensive(price):
return price > 1000

In this code, we define a Laptop class encompassing an instance method called “get_price,” a class method named “calculate_price_with_tax,” and a static method named “is_expensive.” The “get_price” instance method simply returns the price of the laptop object.

The “calculate_price_with_tax” class method calculates the price of the laptop inclusive of tax, while the “is_expensive” static method checks if the laptop is considered expensive. We can utilize these methods as follows:

laptop = Laptop("Apple", "Macbook Pro", 1500)
laptop.get_price() # Returns 1500
Laptop.calculate_price_with_tax(1500) # Returns 1725.0
Laptop.is_expensive(1500) # Returns True

Summary of Main Points

In this article, we explored three distinct method types in Python: Static Methods, Class Methods, and Instance Methods. Static Methods, defined using the “@staticmethod” decorator, operate on properties belonging to the class. Class Methods, defined using the “@classmethod” decorator, work on properties associated with the class, while Instance Methods operate on specific instances of the class and are defined using the “self” keyword.

We have witnessed how all three types of methods can coexist within a class, contributing to more efficient and organized code. These method types provide flexibility in structuring and utilizing classes. Mastering these method types is essential for developing proficient Python programming skills, allowing for the creation of readable and extendable code.

This article provided a comprehensive discussion of the three method types in Python: Static Methods, Class Methods, and Instance Methods. Definitions and examples were provided for each, highlighting their purposes and differences. We also showcased an example that effectively employs all three method types.

Understanding these methods is paramount for writing efficient, maintainable, and well-organized Python code. Utilizing the appropriate methods for specific tasks leads to more readable and extensible code. As you progress in your Python journey, mastering these method types and their correct implementation becomes crucial.

Popular Posts