@staticmethod vs @classmethod in Python

python

class-methods

static-methods

inheritance

byAlex Kataev·Nov 5, 2024

@staticmethod is your choice when you need a utility function that doesn't access class or instance data. It works like a standalone function well-organized within a class's namespace:

# Notice: No 'self' or 'cls' in arguments
class MyClass:
    @staticmethod
    def calculate_sum(a, b):
        # Even mathematicians use this method to avoid 1 + 1 errors!
        return a + b

Choose @classmethod if the method should have access to class objects, perfect for factory patterns or alternative constructors. It receives the class itself as the first argument (cls):

class MyClass:
    @classmethod
    def from_string(cls, date_str):
        # Because '2021-09-28' is too mainstream for a date!
        year, month, day = map(int, date_str.split('-'))
        return cls(year, month, day)

Use these effectively to build robust and maintainable code!

Class and Static Method Anatomy

The @classmethod Digest:

Needed when methods must access or change the class state.
Suitable for factory patterns and alternate constructors.
Primed for when your method logic entwines with the class rather than a single instance.

The @staticmethod Breakdown:

For functional autonomy—when the method doesn't need to know if it's inside a class (cls) or an object (self).
Oven made for utility functions that group logically with the class but don't tweak class or instance state.
To dodge those mystic side effects as it barricades class context.

Inheritance Intricacies

Class Methods:

@classmethods team up with inheritance and handle subclass method calls in the stride, retaining the subclass context.

class Parent:
    @classmethod
    def print_cls(cls):
        # Papa, can you hear me?
        print(cls.__name__)

class Child(Parent):
    pass

# "I am Child!" screams the child class
Child.print_cls()

Static Methods:

@staticmethods emphasize equality across all subclasses just like a democratic global function would do.

class Parent:
    @staticmethod
    def static_method():
        # "I'm static regardless of my DNA", it said with pride!
        print('I am static!')

class Child(Parent):
    pass

# "I am static!" yells the child class, sing-songing merrily with its parent
Child.static_method()

Refactoring Riddles and Reasons

Class Methods: Flexible Refactoring Magnets:

They scoff at hardcoding class names, piloting towards more maintainable and flexible code.
Having inherited class context, they remain unfazed by class renaming, without changes in methods using class names.

Static Methods: Crystal Clear API Architects:

They craft a clean API, relieving users of your class from the tension of creating an object just to use a utility function.
Their concept alone eases understanding as it is clear they won't fiddle with instance state.

Invocation Syntax: The How

Making Invocation a Breeze:

@staticmethod and @classmethod can be called on the class directly or on an instance of the class with the same results.

# Assuming the class and methods defined above
MyClass.calculate_sum(2, 3)  # Static method called directly on the class
my_instance = MyClass()
my_instance.calculate_sum(2, 3)  # Static method called on an instance
MyClass.from_string('2021-09-28')  # Class method called directly on the class