Python classmethod vs staticmethod: Key Differences
Learn how Python's classmethod and staticmethod decorators differ: what each receives when called, how inheritance affects the class argument, and when to use each pattern.

When you define a method inside a Python class, the @classmethod and @staticmethod decorators change what the method receives when it is called. The difference is simple at the syntax level but has real consequences for inheritance, factory methods, and how much state the method can access. Understanding python classmethod vs staticmethod comes down to one question: does the method need the class itself, or does it need nothing at all?
The Syntax Difference Between classmethod and staticmethod
class Order:
tax_rate = 0.08
def __init__(self, items):
self.items = items
@classmethod
def from_quantity(cls, item_price, quantity):
return cls([item_price] * quantity)
@staticmethod
def format_price(value):
return f"${value:.2f}"A classmethod receives the class as its first argument, conventionally named cls. A staticmethod receives no implicit first argument at all. The instance method __init__ receives the instance as self.
When you call Order.from_quantity(10, 3), Python passes Order as cls. When you call Order.format_price(10), Python passes only 10; the method behaves like a plain function that happens to live inside the class body.
What cls Actually Is and Why It Matters
The cls argument is not a fixed reference to the class where the method was defined. It is the class that the method was called on. That distinction becomes visible with inheritance:
class DiscountedOrder(Order):
discount = 0.1
def total(self):
return sum(self.items) * (1 - self.discount)Calling DiscountedOrder.from_quantity(10, 3) passes DiscountedOrder as cls, so the factory creates a DiscountedOrder instance. If the method had been written as a staticmethod returning Order(...), the subclass would never be used.
This is the main reason classmethods exist: they let a factory or alternative constructor build the correct class even when called through a subclass.
A staticmethod has no such awareness. DiscountedOrder.format_price(10) runs the same function with no reference to DiscountedOrder. If the formatting logic ever needed to depend on class-level configuration, a staticmethod would be the wrong choice.
Using classmethod for Alternative Constructors
The most common use of classmethod is an alternative constructor. Python's built-in dict.fromkeys is a classmethod: it creates a dict from an iterable of keys. The pattern is the same in your own classes.
class Temperature:
def __init__(self, celsius):
self.celsius = celsius
@classmethod
def from_fahrenheit(cls, fahrenheit):
return cls((fahrenheit - 32) * 5 / 9)Temperature.from_fahrenheit(212) creates a Temperature instance with celsius == 100.0. The factory converts the input format and delegates construction to cls, so any subclass of Temperature that calls from_fahrenheit receives an instance of that subclass.
The alternative—a staticmethod that returns Temperature(...)—would hard-code the base class and break subclass behavior.
Using staticmethod for Namespaced Utility Functions
A staticmethod is appropriate when the function is conceptually tied to the class but does not need class or instance state. Formatting, validation, and conversion helpers are typical candidates.
class Order:
def __init__(self, items):
self.items = items
@staticmethod
def format_price(value):
return f"${value:.2f}"Order.format_price(19.5) returns "$19.50". The method does not read self or cls. It exists inside the Order namespace so that callers can find it next to the class that uses it.
A staticmethod can always be moved to a module-level function without changing its behavior. Keeping it in the class is a namespacing decision. If the helper is only used by one class, placing it as a staticmethod keeps the module namespace cleaner. If the helper is shared across many classes, a module-level function is usually better.
Runtime Behavior: What Python Passes to Each
The decorators change how the descriptor protocol binds the function to the class or instance.
- A plain method is bound to the instance: calling
order.total()passesorderasself. - A classmethod is bound to the class: calling
Order.from_quantity(...)ororder.from_quantity(...)passes the class ascls. - A staticmethod is not bound at all: calling
Order.format_price(...)ororder.format_price(...)passes only the explicit arguments.
Note that a classmethod can be called on an instance too. order.from_quantity(10, 3) still receives Order as cls, not order. The instance is ignored. This is a common source of confusion, but the behavior is consistent: classmethods always receive the class, never the instance.
Choosing Between classmethod and staticmethod
Use a classmethod when the method needs to:
- create an instance of the class, especially through a subclass
- read or modify class-level attributes
- provide an alternative constructor
Use a staticmethod when the method:
- does not need class or instance state
- is a pure function of its arguments
- exists in the class namespace only for organizational reasons
The decision usually comes down to whether the method would behave differently if called through a subclass. If it would, use classmethod. If it would not, staticmethod is sufficient and simpler.
A common mistake is reaching for staticmethod for an alternative constructor. That works until a subclass needs the same factory, at which point the hard-coded base class reference becomes a bug. Writing the factory as a classmethod from the start avoids that failure mode.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.