Explain Class method vs Static method in Python

In the world of programming with Python, methods are like special tools that help us work with information stored inside objects. Objects are like containers that hold data, and methods are the actions we can perform on that data. In this article, we’re going to explore two special kinds of methods in Python: Class methods and Static methods.

Methods in Python

Before we dive into the specifics of class and static methods, let’s take a moment to review the fundamentals of methods in Python. Imagine methods as specialized functions closely connected to an object. They empower the object to perform actions on its own data. In other words, methods are like the set of instructions an object follows to do things.

For instance, consider a Car object. A method associated with it might be start_engine(). This method instructs the car to initiate its engine. Another method, drive(speed), could instruct the car to move at a specified speed.

In Python, methods are the mechanisms that enable these kinds of actions within objects, making them crucial for defining how objects behave in classes.

Class Methods

Definition

Class methods are like special tools attached to the class itself, not to a particular object of the class. You can recognize them because they are defined using the @classmethod decorator. The first parameter, conventionally named cls, refers to the class itself.

Decorators

class MyClass:
class_variable = 0
@classmethod
def class_method(cls, parameter):
# Access class variables using cls
cls.class_variable += parameter

Access to Class Variables

One cool thing about class methods is their ability to handle information that belongs to the entire class, not just one instance. This means they can access and modify class-level variables. This makes them handy when you want to work with shared data across different objects of the same class.

Example

class MyClass:
class_variable = 0
@classmethod
def class_method(cls, parameter):
cls.class_variable += parameter
# Create two objects
obj1 = MyClass()
obj2 = MyClass()
# Use the class method
MyClass.class_method(5)
# Check the class variable for each object
print(obj1.class_variable) # Output: 5
print(obj2.class_variable) # Output: 5

In this example, class_method is like a command that updates a shared piece of information (class_variable) for the entire class. Even though we used the method on obj1 and obj2, the change is reflected in both instances because it’s affecting the class as a whole.

Static Methods

Definition

Static methods are like standalone helpers in a class, not tied to a specific instance or the class itself. You can spot them because they are defined using the @staticmethod decorator, and they don’t take the class or instance as their first parameter.

Decorators

class MyClass:
@staticmethod
def static_method(parameter):
# No access to class or instance variables
return parameter * 2

No Access to Class or Instance Variables

Unlike class methods, static methods don’t have access to information specific to a class or instance. They are usually employed for utility functions that don’t rely on the current state of the instance or class.

Example

class MyClass:
@staticmethod
def static_method(parameter):
return parameter * 2

Usage

result = MyClass.static_method(3)
print(result) # Output: 6

In this example, static_method is a versatile tool that simply doubles the provided value. Notice that we don’t need to create an instance of MyClass to use this method. It operates independently and is suitable for tasks that don’t involve the internal details of the class.

When to Use Class Methods vs. Static Methods

Use Class Methods

When the method needs access to or modifies class-level variables.

When the method needs to be invoked on the class itself, rather than an instance.

Use Static Methods

When the method does not require access to class or instance variables.

When the method is a utility function related to the class but doesn’t depend on the class state.

Class Method vs. Static Method

Example Class Method

class Employee:
total_employees = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.total_employees += 1
@classmethod
def get_total_employees(cls):
return cls.total_employees
@classmethod
def create_from_csv(cls, csv_data):
name, salary = csv_data.split(',')
return cls(name, int(salary))

Example Static Method

class MathOperations:
@staticmethod
def add(x, y):
return x + y
@staticmethod
def multiply(x, y):
return x * y
@staticmethod
def square_root(x):
return x ** 0.5

In this example, the class method create_from_csv in the Employee class acts as a factory method, creating an employee object from CSV data. On the other hand, the static methods in the MathOperations class perform utility tasks, such as addition, multiplication, and calculating square roots, without relying on any class-specific information.

Conclusion

Understanding the differences between class methods and static methods is essential for effective object-oriented programming in Python. Class methods provide access to class-level variables, making them suitable for operations that involve shared data. On the other hand, static methods are useful for utility functions that don’t depend on the
state of the class or its instances. By knowing when to use each, you can write more modular and maintainable code.