Python `@classmethod` decorator explained

A class method is a method defined in Python through the @classmethod decorator. Its first parameter is the class itself (cls), which is used to access or modify the class state. It can be called through a class or instance, which affects the entire class rather than a specific instance; for example, in the Person class, the show_count() method counts the number of objects created; when defining a class method, you need to use the @classmethod decorator and name the first parameter cls, such as the change_var(new_value) method to modify class variables; the class method is different from the instance method (self parameter) and static method (no automatic parameters), and is suitable for factory methods, alternative constructors, and management of class variables. Common uses include creating objects from different initialization methods, unified management of subclass configurations, etc.

@classmethod is a very practical decorator in Python that defines class methods. Unlike ordinary instance methods, the first parameter of a class method is the class itself (usually written as cls ), not the instance ( self ). This means you can call it through a class or instance and you can operate on the class without creating an object.

What is a class method?

A class method is a method associated with a class, not a specific instance of a class. @classmethod is suitable when you want this method to access or modify the state of a class instead of a specific instance.

Let's give a simple example:

 class Person:
    count = 0

    def __init__(self):
        Person.count = 1

    @classmethod
    def show_count(cls):
        print(f"Total people: {cls.count}")

In this example, show_count is a class method. Whether you call it through the class name Person.show_count() or through an instance, it outputs how many Person objects are currently created.

How to define and use class methods?

Defining a class method is very simple. You just need to add an @classmethod decorator before the method and name the first parameter cls (this is a conventional way of writing).

 class MyClass:
    class_var = "Hello"

    @classmethod
    def change_var(cls, new_value):
        cls.class_var = new_value

It is also very flexible to use:

• MyClass.change_var("World")
• The instance can also call: my_instance = MyClass(); my_instance.change_var("Hi")

Note: Although class methods can be called through an instance, it affects the state of the entire class, not the state unique to the instance.

Class method vs Static method vs Instance method

These three are easy to confuse. Let’s briefly distinguish their uses:

• Example method : The most common method, the first parameter is self , used to process data at the object level.
• Class method ( @classmethod ) : The first parameter is cls , suitable for scenarios where class-level attributes need to be accessed or modified.
• Static method ( @staticmethod ) : There are no self or cls parameters passed in automatically, but it is more like "normal functions belonging to the class".

Give an example to illustrate the difference:

 class User:
    role = "member"

    def instance_method(self):
        print("This is an instance method")

    @classmethod
    def class_method(cls):
        print(f"This is a class method from {cls.role}")

    @staticmethod
    def static_method():
        print("This is a static method")

• instance_method() can only be called by instance.
• Both class_method() and static_method() can be called through classes or instances.
• static_method() does not depend on the state of a class or instance at all.

What are the common usage scenarios?

1. Factory Method
   Class methods are very suitable for "factory methods", that is, to return different instances of the class.

    class Point:
       def __init__(self, x, y):
           self.x = x
           self.y = y
   
       @classmethod
       def from_polar(cls, r, theta):
           # Convert polar coordinates to Cartesian coordinates import math
           return cls(r * math.cos(theta), r * math.sin(theta))

2. Modify class variables
   If you have a set of subclasses inherited from the same parent class, and each subclass has its own configuration items, you can use class methods to manage these configurations uniformly.

3. Alternative constructor
   For example, you have multiple ways to initialize an object, and you can use multiple class methods to represent different construction logic.

Basically that's it. The key to understanding @classmethod is to figure out that it acts on classes rather than instances and can be inherited and overridden. If you use it more, you will find that it is more useful than it looks.

The above is the detailed content of Python `@classmethod` decorator explained. For more information, please follow other related articles on the PHP Chinese website!