@staticmethod & @classmethod

By the end of this lesson you can:

• Use @staticmethod for methods that don't need self or cls — utility functions that belong inside a class for organisational reasons.
• Use @classmethod for methods that take the class itself — typically alternate constructors.
• Tell them apart from regular instance methods at a glance.
• Decide which of the three method types fits a given job.

Flavour              First parameter         Use when
instance method      self                    needs to read/write instance data
classmethod          cls                     needs the class itself (e.g. alt constructor)
staticmethod         nothing                 a utility related to the class but using neither

You've been using instance methods for 18 lessons. Today we meet the other two.

@staticmethod — no self, no cls

A static method is a regular function that happens to live in a class's namespace. It takes no automatic first argument.

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

print(Math.add(3, 4))     # → 7  -- called on the CLASS
print(Math().add(3, 4))   # → 7  -- also works on an instance, but unusual

Why bother putting it in a class then? Organisation. If add, subtract, multiply all belong with Math conceptually, they live there. Static methods don't use self; they don't need a class either — but grouping them inside one keeps related utilities together.

When to reach for @staticmethod

• The method's logic doesn't reference any instance or class state.
• It still belongs conceptually to the class (e.g. a helper used internally).
• Otherwise, just write a module-level function instead.

@classmethod — first parameter is cls

A class method takes the class itself as the first argument, conventionally named cls. Mostly used for alternate constructors.

class Hero:
    def __init__(self, name, hp, attack_power):
        self.name = name
        self.hp = hp
        self.attack_power = attack_power

    @classmethod
    def warrior(cls, name):
        """Alternate constructor — pre-set stats for a warrior."""
        return cls(name, hp=150, attack_power=15)

    @classmethod
    def mage(cls, name):
        return cls(name, hp=80, attack_power=22)

    @classmethod
    def from_csv(cls, line):
        """Build from a 'name,hp,atk' string."""
        name, hp, atk = line.split(",")
        return cls(name.strip(), int(hp), int(atk))


# Three ways to make a Hero
h1 = Hero("Aisyah", 100, 12)          # normal constructor
h2 = Hero.warrior("Wei Jie")          # alt — pre-set warrior stats
h3 = Hero.from_csv("Priya, 80, 18")   # alt — parse a CSV line

Notice all three return cls(...) — that's why cls matters. If a child class inherits these methods, cls is the child, and the alt constructor builds the right type automatically.

The inheritance benefit of cls

class PaladinHero(Hero):
    pass

h = PaladinHero.warrior("Iman")     # uses Hero.warrior, but cls = PaladinHero
print(type(h))                       # → PaladinHero  -- not Hero!

If warrior had hard-coded return Hero(...), it would build a Hero even when called on PaladinHero. cls(...) uses whatever class the call started from. That's the whole reason classmethods exist.

Reading data on the class itself

Sometimes you want to read class-level constants:

class Pizza:
    BASE_PRICE = 8.0           # class attribute

    @classmethod
    def menu_price(cls, toppings):
        return cls.BASE_PRICE + len(toppings) * 1.50

print(Pizza.menu_price(["cheese", "mushroom"]))  # 11.0

The classmethod can read cls.BASE_PRICE — and if a child class overrides it (e.g. LuxuryPizza.BASE_PRICE = 20), the same code uses the new value.

How to choose

Does the method use self?      → instance method  (def m(self, ...):)
Does it need to know cls?      → @classmethod     (def m(cls, ...):)
Neither, but conceptually
groups with the class?         → @staticmethod    (def m(...):)
Neither, and standalone?       → module function  (just def m(): outside any class)

Build a tiny Date class that demonstrates all three method flavours. Save as date_ish.py:

# date_ish.py — Date with @classmethod and @staticmethod

class Date:
    def __init__(self, year, month, day):
        if not Date.is_valid(year, month, day):
            raise ValueError(f"Invalid date: {year}-{month}-{day}")
        self.year  = year
        self.month = month
        self.day   = day

    # --- alternate constructors (@classmethod) ---

    @classmethod
    def from_iso(cls, text):
        """Build from 'YYYY-MM-DD' string."""
        year, month, day = text.split("-")
        return cls(int(year), int(month), int(day))

    @classmethod
    def from_uk(cls, text):
        """Build from 'DD/MM/YYYY' string."""
        day, month, year = text.split("/")
        return cls(int(year), int(month), int(day))

    @classmethod
    def today(cls):
        """Build today's date."""
        from datetime import date
        d = date.today()
        return cls(d.year, d.month, d.day)

    # --- pure utility (@staticmethod) ---

    @staticmethod
    def is_valid(year, month, day):
        if not (1 <= month <= 12): return False
        days_in_month = [31, 29 if Date.is_leap(year) else 28,
                         31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
        return 1 <= day <= days_in_month[month - 1]

    @staticmethod
    def is_leap(year):
        return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)

    # --- instance method (regular self) ---

    def iso(self):
        return f"{self.year:04d}-{self.month:02d}-{self.day:02d}"

    def __repr__(self):
        return f"Date({self.year}, {self.month}, {self.day})"


# Build dates four different ways
d1 = Date(2026, 5, 27)
d2 = Date.from_iso("2026-12-31")
d3 = Date.from_uk("27/05/2026")
d4 = Date.today()

for d in (d1, d2, d3, d4):
    print(d.iso(), d)

# Static helpers — callable without an instance
print(Date.is_leap(2024))     # True
print(Date.is_leap(2025))     # False
print(Date.is_valid(2026, 2, 30))   # False — Feb 30 doesn't exist

Read the diff

Three classmethod constructors (from_iso, from_uk, today) — each parses or sources different data, all funnel through cls(year, month, day). Two staticmethods (is_valid, is_leap) — pure calendar logic that doesn't need a Date instance. One instance method (iso) — uses self to read this date's fields. The class organises all of them in one place.

Three method flavours. Instance methods (the default) take self. Class methods (@classmethod) take cls and are perfect for alternate constructors. Static methods (@staticmethod) take neither and group utility logic with the class. Classmethods using cls stay correct under inheritance — they build the right type automatically. Reach for the simplest flavour the job allows.