How to define a static method in Python ?

To define a static method in Python, use the @staticmethod decorator. Static methods belong to a class but do not access or modify the class or instance state (they don’t take self or cls as parameters). They are utility functions logically grouped under the class.

Step-by-Step Guide:

Use the @staticmethod decorator above the method definition.
Define the method without self or cls parameters.
Call the method via the class name or an instance.

Example: Basic Static Method

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

# Call directly via the class
print(MathUtils.add(2, 3))  # Output: 5

# Call via an instance (less common)
utils = MathUtils()
print(utils.add(5, 7))      # Output: 12

Example: Static Method in a `Date` Class

class Date:
    def __init__(self, day, month, year):
        self.day = day
        self.month = month
        self.year = year

    @staticmethod
    def is_leap_year(year):
        """Check if a year is a leap year."""
        return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

# Usage:
print(Date.is_leap_year(2020))  # Output: True
print(Date.is_leap_year(2021))  # Output: False

Key Points:

No Access to self or cls: Static methods operate only on their explicit arguments.
Utility Use Case: Ideal for helper functions related to the class’s purpose (e.g., validations, calculations).
Inheritance Behavior: Can be overridden in subclasses, but they don’t inherently interact with class hierarchies.

Comparison with Class Methods (`@classmethod`)

Feature	Static Method (`@staticmethod`)	Class Method (`@classmethod`)
Parameters	No implicit parameters	Takes `cls` (class reference)
Use Case	Utility functions	Factory methods, class-level logic
Access to Class	❌ No	✅ Yes (via `cls`)

When to Use Static Methods:

For logic that doesn’t depend on class/instance state.
To organize code by grouping related functions under a class.
Example: Formatting data, mathematical operations, validations.

Common Mistakes to Avoid:

Omitting the @staticmethod decorator:
Without it, Python treats the method as an instance method (expecting self).

   class BadExample:
       def utility():  # ❌ Missing decorator
           print("This will fail if called from an instance.")

   BadExample.utility()          # Works (called via class)
   obj = BadExample()
   obj.utility()                 # Error: TypeError (missing 1 positional arg: 'self')

Using self in a static method:
Static methods cannot access instance attributes.

   class AnotherExample:
       @staticmethod
       def bad_method(self):  # ❌ Redundant 'self'
           return self.value  # Fails (no instance context)

Advanced Example: Static Method in Inheritance

class Animal:
    @staticmethod
    def describe():
        return "A living organism."

class Dog(Animal):
    @staticmethod
    def describe():
        return "A domesticated carnivore."

print(Animal.describe())  # Output: "A living organism."
print(Dog.describe())     # Output: "A domesticated carnivore."

Summary:

Definition: Use @staticmethod and omit self/cls.
Purpose: Encapsulate class-related utilities without state dependency.
Usage: Call via ClassName.method() or an instance.