Python Class Methods and Static Methods

3Python Class Methods: explained step by step

So far every method you have written starts with self, which means it works on one particular object. That covers most needs, but two situations keep coming up:

• You want a method that belongs to the class as a whole, such as a new way to create objects or an update to a class-level counter. At that moment there may be no object to call it on.
• You have a helper function that is clearly about the class but never touches any object's data.

Python has a kind of method for each: class methods and static methods. You create them with a decorator, a line starting with @ placed directly above the def, which tells Python to treat the method differently.

Three kinds of method

The diagram above compares them. The real difference is what Python passes in automatically as the first argument: the object (instance method), the class (class method), or nothing (static method). That decides what data each kind can reach.

Class methods and cls

Put @classmethod above a method and name its first parameter cls. Python then passes the class itself instead of an object. With cls you can read class attributes and, most usefully, create objects: cls(...) does the same as calling the class by name.

class Pizza:
    def __init__(self, inches, toppings):
        self.inches = inches
        self.toppings = toppings

    @classmethod
    def from_string(cls, text):
        inches, toppings = text.split(":")
        return cls(int(inches), toppings.split(","))

    def describe(self):
        return f"{self.inches}-inch pizza with {', '.join(self.toppings)}"

order = Pizza.from_string("12:ham,olives,corn")
print(order.describe())

You call it on the class, Pizza.from_string(...), and no pizza has to exist yet. Inside, cls is Pizza, so cls(...) builds a new pizza. Writing cls instead of the literal class name keeps the method correct if the class is renamed or extended later.

Alternative constructors

A class gets only one __init__. Class methods fill the gap: each one is a named "door" into creating an object, usually called from_something. The caller picks the door that matches the data they have.

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

    @classmethod
    def from_string(cls, text):        # build from text like "2024-12-25"
        year, month, day = text.split("-")
        return cls(int(year), int(month), int(day))

    @classmethod
    def new_year(cls, year):           # build from fixed data: always 1 January
        return cls(year, 1, 1)

    def __str__(self):
        return f"{self.day:02d}/{self.month:02d}/{self.year}"

print(Date(2025, 3, 14))
print(Date.from_string("2024-12-25"))
print(Date.new_year(2026))

Every door ends in cls(...), so all objects are still set up by the same __init__. That keeps the rules for a valid object in one place.

Class methods and class-level state

Because cls is the class, cls.count = 0 changes the class attribute that every object shares. (Doing the same through self would only create an instance attribute that hides it, as you saw in the previous lesson.)

class Player:
    count = 0

    def __init__(self, name):
        self.name = name
        Player.count += 1

    @classmethod
    def how_many(cls):
        return f"{cls.count} players created"

    @classmethod
    def reset_count(cls):
        cls.count = 0

Player("Asha")
Player("Ben")
print(Player.how_many())
Player.reset_count()
print(Player.how_many())

Static methods

Sometimes a function is closely related to a class but needs neither an object nor the class itself. @staticmethod stores such a function inside the class. Python passes no automatic first argument, so you write exactly the parameters you want. A static method is a plain function that happens to live in the class's namespace, which keeps related code together and ties the name to the class.

class Temperature:
    @staticmethod
    def celsius_to_fahrenheit(celsius):
        return celsius * 9 / 5 + 32

print(Temperature.celsius_to_fahrenheit(100))
reading = Temperature()
print(reading.celsius_to_fahrenheit(0))

Calling all three kinds

Each kind can be called through the class or through an object, but they do not behave identically. An instance method called through the class needs the object handed over by hand. Class and static methods work the same either way.

class Cafe:
    drinks_sold = 0

    def __init__(self, name):
        self.name = name

    def sell(self):                    # instance method: needs one cafe
        Cafe.drinks_sold += 1
        return f"{self.name} sold a drink"

    @classmethod
    def total_sold(cls):               # class method: receives the class
        return cls.drinks_sold

    @staticmethod
    def is_open(hour):                 # static method: receives nothing extra
        return 8 <= hour < 18

harbor = Cafe("Harbor Cafe")
print(harbor.sell())
print(Cafe.sell(harbor))               # through the class: pass the object yourself
print(Cafe.total_sold(), harbor.total_sold())
print(Cafe.is_open(9), harbor.is_open(20))

Cafe.sell(harbor) is exactly what harbor.sell() does behind the scenes.

Which kind do I need?

• It uses the data of one object (self.something)? Write an instance method.
• It needs the class, either to create objects or to read and change class attributes, but not one particular object? Write a class method.
• It needs neither? It might be a static method, but read the next section first.

When not to use a static method

In Python a function does not have to live inside a class. If it needs neither an object nor the class, a plain module-level function is often the simplest choice:

def celsius_to_fahrenheit(celsius):
    return celsius * 9 / 5 + 32

Choose a static method when the function is really part of the class's idea and you want it found next to the related code, like Pizza.inches_to_cm(12). A class that holds nothing but static methods and is never instantiated is just a module in disguise.