Class and Static Method in Python: Differences

Python Class Method vs Static Method

Class methods and static methods are two specialized classes whose similar syntaxes are often confused, yet their work differs from each other. Finding out what would distinguish the two is highly important in writing efficient and clear code. So down below we will be discussing in brief - the Python Class Method vs Static Method

Python Class Method: Definition and Use Case

A Python class method is a method that is defined within a class and that operates on all objects being an instance of the class. This also means that you can call the method directly on the class and the class is the first parameter of the method (often called cls). Class methods are used for operations for the whole class, for changing some class variables, or for making instances of the class using different constructors.

Key Characteristics of Python Class Method:

• Bound to the class: These are declared with the use of the @classmethod and normally they are allowed to work with the class variables.
• First parameter cls: Depending on whether it is an instance reference (self), class methods consider the class into which they are being called as the initial parameter of the method, traditionally named cls.
• Common use cases: Creating objects, encapsulation of data for the whole factory, implementing and encapsulation of methods that require the class reference (but not objects of the class).

Example of Python Class Method:

class Car:
	wheels = 4
	@classmethod
	def change_wheels(cls, new_wheels):
		cls.wheels = new_wheels
		print(f"Number of wheels set to {cls.wheels}")
Car.change_wheels(6)

In the case of the above example, change_wheels() is a class method used to change the value of the class-level wheels for all objects of the class.

Python Static Method: Definition and Use Case

A static method in Python means it is a method that belongs to the class. Static methods are class methods and do not have access to attributes on a class or instance of the class at their own instance or to other instances or class attributes. Unlike variables which are logically grouped inside the class, they work just like any normal functions.

Key Characteristics of Python Static Method:

• Not bound to the class or instance: They are used and created by the @staticmethod, and these methods are not associated with the object or class-specific data.
• No special first parameter: Static methods can be distinguished from instance or class methods by the fact that they do not first require either self or cls as a required argument.
• Common use cases: Functions that are associated with the class but do not write or read any class or instance variables.

Example of Python Static Method:

class Calculator:
	@staticmethod
	def add(a, b):
		return a + b
	@staticmethod
	def subtract(a, b):
		return a - b

Usage

print(Calculator.add(10, 5))  # Output: 15
print(Calculator.subtract(10, 5))  # Output: 5

In the example above we noted that add and subtract methods do the calculations without involving any class-level or instance-level variable making it suitable for a static method.

Python Class Method vs Static Method: Key Differences

At first glance, class methods and static methods may appear to have similar functionality, but they serve different purposes. Let’s explore the differences in greater detail:

When to Use a Python Class Method

Class methods can be used when you want to execute those operations with which you work directly on the class not on the object of this class. They are useful when you’d like to change the behavior or state of a class or have another constructor for the class.

1. Example Use Case: Factory Method

The other popular use of class methods is when defining a factory method. The latter can be used to create an object of the class other than by invoking the default constructor of the class.

class Person:
	def __init__(self, name, age):
		self.name = name
		self.age = age
	@classmethod
	def from_birth_year(cls, name, birth_year):
		age = 2024 - birth_year  # Assume the current year is 2024
		return cls(name, age)

Using the factory method

person = Person.from_birth_year("Alice", 1990)
print(person.name, person.age)  # Output: Alice 34

In the above example, the from_birth_year() is actually a class method that helps in creating an instance of the class Person using the first name of the person besides birth year.

2. Example Use Case: Singleton Pattern

Class methods are also applied in some design patterns for instance the Singleton design pattern where you want to limit the creation of the class to only one instance.

class Singleton:
	_instance = None
	def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            return cls._instance
            
	@classmethod
	def get_instance(cls):
		return cls._instance or cls()

Usage

singleton_1 = Singleton.get_instance()
singleton_2 = Singleton.get_instance()
print(singleton_1 is singleton_2)  # Output: True

In this case, the method get_instance() is used to control the instance of the singleton class to make sure that there is only an object.

When to Use a Static Method in Python

Static methods are ideal when you need a function that doesn't depend on the state of the class or its instances but is still logically related to the class. They are useful for utility functions that perform tasks independent of the class itself.

Example Use Case: Utility Functions

The static method is best used where you have utility or helper functions that are related to the class but don’t interact with the class or an instance of the class. For instance, you may have a method that checks whether data is null or required and such a method does not have to be dependent on any class type of data.

class StringHelper:
	@staticmethod
	def reverse_string(s):
		return s[::-1]
	@staticmethod
	def is_palindrome(s):
		return s == s[::-1]

Usage

print(StringHelper.reverse_string("hello"))  # Output: "olleh"
print(StringHelper.is_palindrome("madam"))  # Output: True

In this case, reverse_string, and is_palindrome are both static because neither requires class data to be altered, but are intimately connected with the string type.

Conclusion

Therefore it is important to have a clear understanding of the class methods in Python and the static methods in Python as well. The class method can be used to manipulate the class, and its data or to create objects of the class in a different manner, while the static method in Python should be used when we have a function that does not have to know about the class or object. If used correctly, the two methods make your code cleaner more organized, and less of a headache to maintain.

Wishing you all the best —Happy coding! 🚀