Python @classmethod vs @staticmethod Explained for Beginners

By the end of this page, you will understand the difference between instance methods, class methods, and static methods in Python. You will learn what self and cls mean, why @classmethod and @staticmethod exist, when to use each one, and how these choices affect inheritance, object creation, and code organization.

In Python, methods inside a class are not all the same. The main difference is what gets passed automatically as the first argument.

There are three common method types:

1. Instance methods

   • Defined normally.
   • Receive the current object as the first argument, usually named self.
   • Used when the method needs to read or change data stored in a specific object.

2. Class methods

   • Marked with @classmethod.
   • Receive the class itself as the first argument, usually named cls.
   • Used when the method needs to work with class-level data or create objects in an alternative way.

3. Static methods

   • Marked with @staticmethod.
   • Do not receive self or cls automatically.
   • Used when the function logically belongs inside the class, but does not need instance data or class data.

Why decorators are needed

Python needs a way to know how a method should behave when it is called.

• A normal method becomes an instance method.
• @classmethod tells Python: "Pass the class as the first argument."
• @staticmethod tells Python: "Do not pass anything automatically."

Think of a class like a blueprint for making objects.

• An instance method is like talking to one specific product made from the blueprint.
  • Example: "What is this user's email?"
• A class method is like talking to the blueprint itself.
  • Example: "Make a new user from this CSV row."
• A static method is like a tool stored in the blueprint's toolbox.
  • It belongs near the class because it is related, but it does not need the blueprint or any specific product.

Another way to remember it:

• self = this object
• cls = this class
• @staticmethod = no automatic object or class argument

Core syntax

class Example:
    class_value = 10

    def instance_method(self):
        return f"Instance method: {self}"

    @classmethod
    def class_method(cls):
        return f"Class method: {cls.class_value}"

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

Example with all three

class User:
    default_role = "member"

    def __init__(self, name, role=None):
        self.name = name
        self.role = role or User.default_role

    def describe(self):
        return f"{self.name} is a {self.role}"


     ():
         cls(name, role=)


     ():
         (name, )  (name.strip()) > 

Consider this code:

class Counter:
    total_created = 0

    def __init__(self):
        Counter.total_created += 1

    @classmethod
    def how_many(cls):
        return cls.total_created

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

Now run:

c1 = Counter()
c2 = Counter()
print(Counter.how_many())
print(Counter.add(3, 4))

Step by step

1. c1 = Counter()

• Python creates a new Counter object.
• __init__ runs.
• Counter.total_created becomes 1.

2. c2 = Counter()

When instance methods are used

• Updating a shopping cart item
• Changing a user's password
• Formatting data from a specific record
• Reading or modifying object state

When class methods are used

• Alternative constructors
  • Create an object from JSON, CSV, environment variables, or database rows
• Working with class-level configuration
  • Access shared settings or counters
• Inheritance-friendly factories
  • Return the correct subclass automatically using cls(...)

Example:

class Config:
    def __init__(self, host, port):
        self.host = host
        self.port = port

    @classmethod
    def from_dict(cls, data):
        return cls(data["host"], data["port"])

When static methods are used

• Validation helpers
• Formatting helpers
• Conversion logic closely related to a class
• Utility functions that make sense to keep near the class

Example:

In real projects, developers often choose between these method types based on what the method depends on.

Common patterns

Instance methods for object behavior

class Order:
    def __init__(self, items):
        self.items = items

    def total(self):
        return sum(item["price"] for item in self.items)

This uses self.items, so it should be an instance method.

Class methods as alternative constructors

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    @classmethod
    def from_string(cls, text):
        name, price = text.split(",")
        return cls(name, float(price))

1. Using @staticmethod when you need class access

Broken code:

class Report:
    format_type = "PDF"

    @staticmethod
    def default_format():
        return cls.format_type

Problem:

• cls does not exist in a static method.

Fix:

class Report:
    format_type = "PDF"

    @classmethod
    def default_format(cls):
        return cls.format_type

2. Forgetting self in an instance method

Broken code:

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

Problem:

• Instance methods automatically receive the object.

Method types compared

Quick reference

Instance method

class A:
    def method(self):
        pass

• Default method type
• Receives self
• Use for object-specific behavior

Class method

class A:
    @classmethod
    def method(cls):
        pass

• Receives cls
• Use for class-level logic
• Great for alternative constructors
• Prefer cls(...) over hardcoding the class name

Static method

class A:
    @staticmethod
    def method(x, y):
        pass

• Receives no automatic first argument
• Use for helper logic related to the class

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

A class method receives the class as cls. A static method receives no automatic argument at all. Use a class method when the logic depends on the class; use a static method when it does not.

Why use @classmethod instead of a normal method?

Use @classmethod when the method should work with the class itself rather than with one object instance. This is common for alternative constructors such as from_dict() or from_string().

Why use @staticmethod at all?

It helps group related helper logic inside a class. This can improve code organization when the function is clearly tied to the class concept.

Can a class method access instance variables?

Not directly. It receives cls, not self. It can only access class-level data unless you pass an instance manually.

Can a static method access class variables?

Not automatically. A static method does not receive cls or self. It can still access a class by name, but that removes some flexibility.

Is inherited by subclasses?

Instance methods

These are the default methods in Python classes and are the baseline for understanding @classmethod and @staticmethod.

self in Python

Understanding self helps explain why normal methods behave differently from class and static methods.

Python decorators

@classmethod and @staticmethod are decorators, so knowing what decorators do helps make their syntax less mysterious.

Class attributes vs instance attributes

Class methods often work with class attributes, while instance methods usually work with instance attributes.

Inheritance in Python

Class methods are especially useful with inheritance because cls can refer to a subclass.

Alternative constructors

This is one of the most common real uses of @classmethod, such as from_dict() or from_string().