@staticmethod vs @classmethod in Python Explained

By the end of this page, you will understand how @staticmethod and @classmethod work in Python, what each one receives automatically, when to use each, and how they differ from regular instance methods. You will also see practical examples, common mistakes, and a small project that makes the distinction easy to remember.

In Python, methods inside a class are not all the same. The main difference between @staticmethod and @classmethod is what Python passes to them automatically.

A quick reminder of the three common method types:

• Instance method: works with a specific object and receives self
• Class method: works with the class itself and receives cls
• Static method: receives nothing automatically

Instance method

A normal method inside a class usually looks like this:

class User:
    def greet(self):
        return "Hello"

When you call user.greet(), Python automatically passes the instance as the first argument. That first argument is usually named self.

Class method

A class method is defined with @classmethod:

class User:
    @classmethod
     ():
         cls()

Think of a class like a company.

• An instance method talks to one employee: it gets self
• A class method talks to the company itself: it gets cls
• A static method is just a tool kept in the company office: it does not get either one automatically

Simple analogy

• self = this specific object
• cls = this class
• @staticmethod = a helper function stored inside the class because it belongs there conceptually

For example:

• "What is this user's email?" → instance method
• "Create a user from a CSV row" → class method
• "Check whether an email format looks valid" → static method

A good question to ask is:

Does this method need the object, the class, or neither?

• Needs the object → instance method
• Needs the class → class method
• Needs neither → static method

Core syntax

class Example:
    def instance_method(self):
        return "instance"

    @classmethod
    def class_method(cls):
        return "class"

    @staticmethod
    def static_method():
        return "static"

Example: all three together

class Temperature:
    scale = "Celsius"

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

    def describe(self):
        return f"{self.value} degrees {self.scale}"

    @classmethod
    def freezing_point(cls):
        return cls(0)

    @staticmethod
     ():
         (celsius *  / ) + 


weather = Temperature()

(weather.describe())
(Temperature.freezing_point().describe())
(Temperature.celsius_to_fahrenheit())

Consider this example:

class Book:
    category = "General"

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

    @classmethod
    def default_book(cls):
        return cls("Untitled")

    @staticmethod
    def is_valid_title(title):
        return len(title.strip()) > 0

Now trace these calls:

book = Book.default_book()
valid = Book.is_valid_title("Python Basics")

Step by step

1. Python reads the class definition

It creates the Book class.

• category becomes a class attribute
• __init__ becomes an instance method
• default_book becomes a class method
• is_valid_title becomes a static method

Common uses for @classmethod

Alternative constructors

A class method is often used to create objects from different input formats.

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_dict(cls, data):
        return cls(data["name"], data["age"])

Useful when reading:

• JSON data from an API
• rows from a CSV file
• configuration files
• database records

Class-level configuration

class AppConfig:
    debug = False

    @classmethod
    def enable_debug(cls):
        cls.debug = True

This affects the class itself, not one specific object.

Common uses for @staticmethod

In real codebases, developers usually choose between these method types based on what the method needs to know.

Common @classmethod patterns

Alternative constructors

class Order:
    def __init__(self, order_id, total):
        self.order_id = order_id
        self.total = total

    @classmethod
    def from_api(cls, payload):
        return cls(payload["id"], payload["total"])

This keeps parsing logic close to the class.

Inheritance-friendly creation

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

    @classmethod
    def unnamed(cls):
        return cls("Unknown")

class Dog(Animal):
    

pet = Dog.unnamed()
((pet).__name__)

1. Using @staticmethod when cls is needed

Broken example:

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

    @staticmethod
    def create(name):
        return cls(name)

Problem:

• cls does not exist in a static method

Fix:

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

    @classmethod
    def create(cls, name):
        return cls(name)

2. Using @classmethod for logic that does not need the class

This works, but it is misleading:

Method type comparison

@classmethod vs @staticmethod

Quick rules

• Instance method: first parameter is self
• Class method: use @classmethod, first parameter is cls
• Static method: use @staticmethod, no automatic first parameter

Syntax

class Example:
    def instance_method(self):
        pass

    @classmethod
    def class_method(cls):
        pass

    @staticmethod
    def static_method(x, y):
        return x + y

When to use which

• Use instance methods for object-specific behavior
• Use class methods for class-level behavior or alternative constructors
• Use static methods for helper logic that belongs with the class

Memory tip

• self = this object
• cls = this class

What is the main difference between @staticmethod and @classmethod in Python?

@classmethod receives the class as the first argument, usually named cls. @staticmethod receives no automatic first argument.

When should I use @classmethod in Python?

Use it when the method needs the class itself, especially for alternative constructors like from_dict, from_json, or default.

When should I use @staticmethod in Python?

Use it for helper functions that belong to the class logically but do not need instance or class data.

Can I call a class method on an instance?

Yes. You can call both class methods and static methods from either the class or an instance.

Can a static method access class variables?

Not automatically. It does not receive cls, but it can still refer to the class by name directly if needed.

Is @staticmethod the same as a normal function?

Not exactly. It behaves similarly because it gets no automatic arguments, but it is stored inside the class namespace.

Instance methods

These are the default methods in Python classes and receive self. They help you compare object-level behavior with class-level and static behavior.

Class attributes

Class methods often read or update class attributes, so understanding shared class data is important.

Inheritance

@classmethod becomes especially useful with subclasses because cls points to the actual calling class.

Constructors and __init__

Class methods are often used as alternative constructors, so they are closely related to object creation.

Decorators

Both @staticmethod and @classmethod are decorators, so learning decorators helps explain how method behavior is changed.

Module-level functions

Static methods are often compared with normal functions outside the class to decide where helper logic should live.