Python classmethod()

Spread the love

The classmethod( ) returns a class method for a given function passed. Class methods can be created either with the decorator @classmethod or classmethod( ) function.

classmethod() Syntax

The syntax of classmethod( ) method is:


classmethod() Parameters

classmethod( ) method takes a single parameter:

function – Function that needs to be converted into a class method

classmethod() Return Value

classmethod( ) method returns a class method for the given function.

What is Python classmethod() ?

In Python, everything is an object—including classes themselves. This object-oriented nature lends Python the flexibility to define not just methods that operate on instances of classes, but also methods that operate on the classes themselves. One of the mechanisms Python offers to define such methods is the classmethod.

classmethod() is a built-in decorator in Python that transforms a method into a “class method.” Unlike standard methods, which have access to instance-specific data and take a reference to the instance (self) as their first parameter, class methods take a reference to the class (cls) itself as their first parameter.

Defining a Class Method in Python

The basic structure of defining a class method involves:

  1. The @classmethod decorator.
  2. A function defined within a class.
  3. The function’s first parameter is conventionally named cls, representing the class itself.
class MyClass:
    def my_class_method(cls, *args):
        # method body

Practical Example: A Simple Bank Account

Let’s say we want to design a basic BankAccount class. This class will hold an interest rate that applies to all bank accounts. Our goal is to use a class method to modify this shared interest rate.

Here’s how we could set that up:

class BankAccount:
    # A class-level attribute holding the interest rate for all accounts
    interest_rate = 0.05  # 5% interest rate

    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    # A class method to set a new interest rate for all accounts
    def set_interest_rate(cls, new_rate):
        if 0 <= new_rate <= 1:  # Ensuring the interest rate is between 0% and 100%
            cls.interest_rate = new_rate
            print(f"New interest rate set to: {new_rate * 100}%")
            print("Invalid interest rate. Please provide a rate between 0 and 1.")

    def display_balance(self):
        return f"{self.owner}'s balance: ${self.balance}"

# Usage:

# Create an account for Alice
alice_account = BankAccount("Alice", 1000)

# Display Alice's balance
print(alice_account.display_balance())  # Alice's balance: $1000

# Check the current interest rate
print(f"Current interest rate: {BankAccount.interest_rate * 100}%")  # 5%

# Set a new interest rate using our class method
BankAccount.set_interest_rate(0.07)  # New interest rate set to: 7.0%

# The interest rate is changed for all accounts
print(f"Current interest rate: {BankAccount.interest_rate * 100}%")  # 7%

In this example, the set_interest_rate method is defined as a class method using the @classmethod decorator. When we call this method on the BankAccount class, it adjusts the interest_rate attribute of the class. This change in interest rate applies to all instances of the BankAccount class because interest_rate is a class-level attribute, shared by all instances.

Class Method vs Static Method

Both class methods and static methods are types of methods that belong to the class as a whole, rather than specific instances of the class. However, they serve different purposes and have different characteristics. Let’s explore the differences between class methods and static methods in detail, accompanied by a practical example.

Class Method:

  • Defined using the @classmethod decorator.
  • Receives a reference to the class (cls) as its first parameter.
  • Can modify class-level attributes.
  • Commonly used for alternative constructors.

Static Method:

  • Defined using the @staticmethod decorator.
  • Doesn’t receive any special first parameter; it behaves like a regular function but belongs to the class’s namespace.
  • Cannot modify class-level attributes directly (unless explicitly passed the class or used with the class name).
  • Often used to perform utility functions that are related to the class but don’t need access to class-specific data.

Practical Example: Building a Book Class

Let’s design a simple Book class to illustrate the differences between class methods and static methods.

class Book:
    # Class-level attribute to keep track of the total number of books
    total_books = 0

    def __init__(self, title, author):
        self.title = title = author
        Book.total_books += 1

    def get_total_books(cls):
        """Class Method: Returns the total number of books created."""
        return cls.total_books

    def is_valid_title(title):
        """Static Method: Check if a given title is valid (non-empty and starts with a capital letter)."""
        return bool(title) and title[0].isupper()

# Usage:

# Creating some books
book1 = Book("Moby Dick", "Herman Melville")
book2 = Book("Pride and Prejudice", "Jane Austen")

# Using class method to get total books created
print(Book.get_total_books())  # Output: 2

# Using static method to validate a book title
print(Book.is_valid_title("Moby Dick"))  # Output: True
print(Book.is_valid_title("the Great Gatsby"))  # Output: False

In this example:

  • get_total_books is a class method. It operates on the class level attribute total_books. It doesn’t need any specific instance data and works directly with class data.
  • is_valid_title is a static method. It operates purely based on its inputs without the need for any class or instance data. It’s more like a utility function that’s related to books, so it makes sense to have it as part of the Book class. However, it doesn’t interact with the class or its instances in any way.

Key Takeaways:

  • Class methods operate on class-level data and are meant for operations that need to access or modify class attributes. They receive the class itself as their first parameter.
  • Static methods act as utility functions within the class’s namespace. They don’t receive any special first parameter, and they don’t have direct access to class or instance attributes unless explicitly provided. They’re beneficial when a particular utility function logically belongs to a class but doesn’t require access to the class or its instances.

Create class method using classmethod()

The classmethod() function is a built-in function in Python that’s used to convert a regular method into a class method. While the @classmethod decorator is the most common way to define class methods in modern Python code, the classmethod() function provides another way to achieve the same result. Let’s delve into how you can create a class method using the classmethod() function with an example.

Example: Building a car Class

Let’s say we want to build a simple Car class. This class will have a class-level attribute total_cars to keep track of the total number of car instances created. We’ll create a class method to update and fetch this count.


  1. Define the class and its attributes.
  2. Define a regular method that you want to convert into a class method.
  3. Convert the regular method to a class method using the classmethod() function.
class Car:
    # Class-level attribute to keep track of total cars created
    total_cars = 0

    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
        Car.total_cars += 1

    # Regular method definition
    def display_total_cars(regular_method):
        return f"Total cars created: {Car.total_cars}"

    # Convert the regular method into a class method using classmethod()
    display_total_cars = classmethod(display_total_cars)

# Usage:

# Creating some cars
car1 = Car("Toyota", "Camry")
car2 = Car("Honda", "Civic")

# Using class method to fetch the total cars created
print(Car.display_total_cars())  # Output: Total cars created: 2

In this example:

  • We first defined a regular method display_total_cars that does not take any special first parameter. It’s designed to operate on the class attribute total_cars.
  • Then, we used the classmethod() function to convert the regular method display_total_cars into a class method. After this conversion, the method can now be called on the class itself, as demonstrated in the usage.

Key Point:

While the classmethod() function provides a way to create class methods, the @classmethod decorator is the more idiomatic way to achieve this in modern Python. Both approaches provide the same functionality, but the decorator syntax is cleaner and more commonly used.

Factory method using a Class method

The factory method is a creational design pattern that provides an interface for creating objects in a super class but allows subclasses to alter the types of objects that will be created. One way to implement the factory method pattern in Python is through the use of class methods.

Example: Building a Pet Class Hierarchy

Let’s imagine we have a Pet superclass, with various subclasses like Dog, Cat, etc. We want a factory method in the Pet class that creates and returns an instance of a subclass based on a given string.


  1. Define the superclass and its attributes.
  2. Define the subclasses.
  3. Implement a class method in the superclass as the factory method.
class Pet:
    def __init__(self, name): = name

    def speak(self):

    def factory_method(cls, pet_type, name):
        if pet_type == "Dog":
            return Dog(name)
        elif pet_type == "Cat":
            return Cat(name)
            raise ValueError(f"Unknown pet type: {pet_type}")

class Dog(Pet):
    def speak(self):
        return f"{} says Woof!"

class Cat(Pet):
    def speak(self):
        return f"{} says Meow!"

# Usage:

# Creating pets using the factory method
dog_instance = Pet.factory_method("Dog", "Buddy")
cat_instance = Pet.factory_method("Cat", "Whiskers")

print(dog_instance.speak())  # Output: Buddy says Woof!
print(cat_instance.speak())  # Output: Whiskers says Meow!

In this example:

  • We have a superclass Pet with a class method factory_method which acts as our factory. Depending on the pet_type provided, it creates an instance of a corresponding subclass.
  • Dog and Cat are subclasses of Pet, each overriding the speak method to provide their own behavior.
  • In the usage section, we create instances of Dog and Cat using the factory_method of the Pet class. This way, the exact subclass to be instantiated can be determined at runtime based on the pet_type string.

Key Benefits:

  1. Flexibility: The factory method pattern promotes loose coupling by allowing subclassing to decide which class to instantiate. This makes the system more modular and easier to expand.
  2. Scalability: In the future, if we want to add more pet types, we only need to create new subclasses and update the factory method. The existing code remains unaffected.
  3. Unified Access Point: All instances are created through a single, unified access point (the factory method), making object creation more controlled and consistent.


The classmethod() in Python is a potent tool, offering developers the flexibility to interact with the class itself, rather than individual instances. Whether for factory methods, configuration, or advanced metaprogramming tasks, it’s essential to understand and use class methods properly to harness their full potential.

Leave a Reply