Python Class Methods: Complete Guide, Usage & Examples

1. What Is a Python Class Method? A Clear Explanation from the Basics

1.1 What Is a Python Class Method?

1.2 Features of Class Methods

1. Can be called without creating an instance

• Regular instance methods cannot be called unless you create an instance of the class. However, class methods can be called directly from the class without creating an instance.

1. Can manipulate class variables

• Class methods can directly manipulate variables that belong to the class (class variables), making it easier to manage data common to all instances.

1. Used as factory methods

• Class methods are often used as factory methods that create class instances based on specific data.

1.3 Benefits of Learning Class Methods

1.4 Prerequisite Knowledge for Understanding Class Methods

1.4.1 Python Classes and Objects

class Car:
    def __init__(self, brand):
        self.brand = brand  # instance variable

my_car = Car("Toyota")
print(my_car.brand)  # Toyota

1.4.2 Difference Between self and cls

class Example:
    class_variable = "Class variable"

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

    @classmethod
    def class_method(cls):
        return f"Class variable value: {cls.class_variable}"

# Class method can be called without creating an instance
print(Example.class_method())  # Class variable value: Class variable

# Instance method cannot be called without creating an instance
example_instance = Example()
print(example_instance.instance_method())  # This is an instance method

1.5 Summary

• Class methods act on the class itself
• Defined using the @classmethod decorator and receive cls as the first argument
• Can be called without creating an instance
• Can be used for managing class variables and as factory methods
• self references the instance, and cls references the class

2. Defining and Using Python Class Methods

2.1 Basic Syntax of Class Methods

class ClassName:
    @classmethod
    def method_name(cls, arg1, arg2, ...):
        # method processing
        return result

Key Points for Defining Class Methods

1. @classmethod decorator placed immediately before the method
2. Accept cls as the first argument (cls refers to the class itself)
3. Can access class variables and other class methods
4. Can be called directly from the class (no instance needed)

2.2 Example Implementation of a Class Method

class Sample:
    class_variable = "Class variable"

    @classmethod
    def class_method(cls):
        print(f"Class method was called. Class variable value: {cls.class_variable}")

# Call the class method
Sample.class_method()

Output

Class method was called. Class variable value: Class variable

Code Explanation

• class_variable is defined as a class variable.
• class_method() has the @classmethod decorator and uses cls to access class_variable.
• Calling Sample.class_method() demonstrates that you can invoke the method directly without creating an instance.

2.3 How to Call a Class Method

① Call Directly from the Class Name

Sample.class_method()

② Call Through an Instance

sample_instance = Sample()
sample_instance.class_method()

2.4 Class Methods that Manipulate Class Variables

class Config:
    version = "1.0"

    @classmethod
    def update_version(cls, new_version):
        cls.version = new_version  # modify class variable

# Update version using class method
Config.update_version("2.0")
print(Config.version)  # 2.0

Explanation

• update_version() uses cls.version to modify the class variable.
• Calling Config.update_version("2.0") updates the version for all instances.

2.5 Creating Instances with Class Methods (Factory Methods)

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

    @classmethod
    def from_string(cls, name_str):
        return cls(name_str)  # create a new instance using cls

# Create an instance using the class method
user = User.from_string("Sato")
print(user.name)  # Sato

Explanation

• from_string() calls cls(name_str) to create a new instance.
• Thus it yields the same result as direct instantiation like User("Sato"), but allows preprocessing of the data.

2.6 Differences from Instance Methods

2.7 When to Use Class Methods

• Updating configuration values or counters
• Example: Config.update_version()

• Creating instances from specific formats
• Example: User.from_string()

• Using cls allows it to work with derived classes

class Base:
    @classmethod
    def show_class_name(cls):
        print(f"Class name: {cls.__name__}")

class Derived(Base):
    pass

Derived.show_class_name()  # Class name: Derived

2.8 Summary

• Define a class method using @classmethod
• Using cls enables access to class variables and class operations
• Class methods can be called directly without creating an instance
• They can also be used as factory methods for instance creation
• Class methods are ideal for logic that affects the entire class

3. Python Class Method Use Cases (Practical Use Cases)

3.1 Typical Use Patterns for Class Methods

1. Use as a factory method
2. Management of configuration values and shared data
3. Methods that modify the class state
4. Dynamic use of classes leveraging inheritance
5. Simplifying database connections and management

3.2 Use Case 1: Using as a Factory Method

Create an instance of the User class from string data

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

    @classmethod
    def from_string(cls, user_info):
        name, age = user_info.split(",")  # Split comma-separated string
        return cls(name, int(age))  # Create a new instance

# Create an instance using the class method
user = User.from_string("Sato,30")
print(user.name)  # Sato
print(user.age)   # 30

Benefits of this approach

• Centralized data preprocessing can be performed
• Improved code readability, enabling flexible instance creation
• Easily adaptable to different data formats

3.3 Use Case 2: Managing configuration values and shared data

class Config:
    default_language = "Japanese"
    default_theme = "Light"

    @classmethod
    def update_language(cls, new_language):
        cls.default_language = new_language  # Update class variable

    @classmethod
    def update_theme(cls, new_theme):
        cls.default_theme = new_theme

# Change settings using class methods
Config.update_language("English")
Config.update_theme("Dark")

print(Config.default_language)  # English
print(Config.default_theme)     # Dark

Benefits of this approach

• Maintain consistent settings across the entire app
• Apply changes at the class level rather than per individual instance

3.4 Use Case 3: Methods that modify class state

class Counter:
    count = 0  # Class variable (shared by all instances)

    def __init__(self):
        Counter.increment_count()

    @classmethod
    def increment_count(cls):
        cls.count += 1  # Modify class variable

# Counter increments when an instance is created
c1 = Counter()
c2 = Counter()
c3 = Counter()

print(Counter.count)  # 3

Benefits of this approach

• Manage uniform data across all instances
• By using class methods, you can monitor the creation of new instances

3.5 Use Case 4: Dynamic use of classes leveraging inheritance

class Animal:
    species = "Unknown"

    @classmethod
    def set_species(cls, new_species):
        cls.species = new_species

class Dog(Animal):
    pass

class Cat(Animal):
    pass

# Different settings can be applied per class
Dog.set_species("Canine")
Cat.set_species("Feline")

print(Dog.species)  # Canine
print(Cat.species)  # Feline
print(Animal.species)  # Unknown (parent class value remains unchanged)

Benefits of this approach

• Flexible data management that respects inheritance relationships
• Allows direct reuse of parent class methods, preventing code duplication

3.6 Use Case 5: Simplifying database connections and management

class Database:
    connection = None

    @classmethod
    def connect(cls, db_url):
        if cls.connection is None:
            cls.connection = f"Connected to {db_url}"
        return cls.connection

# Connect to the database
db1 = Database.connect("mysql://localhost:3306/mydb")
db2 = Database.connect("mysql://localhost:3306/mydb")

print(db1)  # Connected to mysql://localhost:3306/mydb
print(db1 is db2)  # True (reusing the same connection)

Benefits of this approach

• Unified management of database connections
• Allows multiple instances to share the same connection (Singleton pattern)

3.7 Summary

Main Points

• Use as a factory method to streamline data preprocessing and instance creation
• Manage configuration values and shared data as class variables for easy modification
• Use class methods that modify class state to simplify management of instance counts, etc.
• Leverage inheritance to dynamically apply parent class methods
• Applicable to use cases such as database connection management

4. Differences Between Class Methods and Other Methods (With Comparison Table)

4.1 The Three Types of Methods in Python

4.2 What Is an Instance Method?

Example of an Instance Method

class Dog:
    def __init__(self, name):
        self.name = name  # instance variable

    def bark(self):
        return f"{self.name} is barking!"

# create instances
dog1 = Dog("Pochi")
dog2 = Dog("Shiro")

print(dog1.bark())  # Pochi is barking!
print(dog2.bark())  # Shiro is barking!

Key Points

4.3 What Is a Class Method?

Example of a Class Method

class Cat:
    species = "Felidae"

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

    @classmethod
    def set_species(cls, new_species):
        cls.species = new_species  # modify class variable

# use class method to modify class variable
Cat.set_species("Felidae")

# change is reflected in all instances
cat1 = Cat("Mickey")
cat2 = Cat("Tama")

print(cat1.species)  # Felidae
print(cat2.species)  # Felidae
print(Cat.species)   # Felidae

Key Points

4.4 What Is a Static Method?

Example of a Static Method

class MathHelper:
    @staticmethod
    def add(x, y):
        return x + y

    @staticmethod
    def multiply(x, y):
        return x * y

# static methods can be called without creating an instance
print(MathHelper.add(3, 5))  # 8
print(MathHelper.multiply(4, 6))  # 24

Key Points

4.5 Which Method Should You Use?

4.6 Summary

Review of Key Points

• Instance Method
• self is taken as the first argument and manipulates instance variables
• Suitable when managing data that differs per instance
• Class Method
• cls is taken as the first argument and manipulates class variables
• Suitable for managing or changing settings that affect the entire class
• Static Method
• Does not receive self or cls and performs operations independent of the class or instances
• Suitable for functions related to the class but that do not affect specific instances or class variables

5. Frequently Asked Questions about Python Class Methods

5.1 Questions about the basics of class methods

Q1. When should you use a class method?

Q2. What is the difference between a class method and an instance method?

class Sample:
    class_variable = "Class variable"

    def __init__(self, name):
        self.name = name  # instance variable

    def instance_method(self):
        return f"Instance variable: {self.name}"

    @classmethod
    def class_method(cls):
        return f"Class variable: {cls.class_variable}"

# Instance method is called via an instance
s = Sample("Taro")
print(s.instance_method())  # Instance variable: Taro

# Class method can be called directly from the class
print(Sample.class_method())  # Class variable: Class variable

Q3. Can a class method access instance variables?

5.2 Questions about class methods and static methods

Q4. What is the difference between a class method and a static method?

class Example:
    class_variable = "Class variable"

    @classmethod
    def class_method(cls):
        return f"Class variable value: {cls.class_variable}"

    @staticmethod
    def static_method():
        return "Static methods cannot handle class variables"

# Class method
print(Example.class_method())  # Class variable value: Class variable

# Static method
print(Example.static_method())  # Static methods cannot handle class variables

Q5. When should you use a static method?

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

print(MathUtils.add(3, 7))  # 10

5.3 Practical questions about class methods

Q6. Can you create an instance using a class method?

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

    @classmethod
    def from_string(cls, user_data):
        name, age = user_data.split(",")
        return cls(name, int(age))

# Create instance from string
user = User.from_string("Sato,30")
print(user.name)  # Sato
print(user.age)   # 30

Q7. Does the usage of class methods change with different Python versions?

class Sample:
    class_variable: str = "Class variable"

    @classmethod
    def get_class_variable(cls) -> str:
        return cls.class_variable

5.4 Summary

Key points

• Class methods are suitable for managing the entire class
• Class methods cannot access instance variables
• Understand the difference between class methods and static methods and use them appropriately
• As factory methods, they can create instances from data
• The basic usage does not change across Python versions, but type hinting can be utilized

6. Summary (Deepening Your Understanding of Class Methods)

6.1 Key Takeaways for Class Methods

✅ Basics of Class Methods

• @classmethod Define using the decorator
• Accepts cls as the first argument, allowing you to reference and modify the entire class
• Can be called with Class.method() without creating an instance

✅ Practical Uses of Class Methods

• Used as a factory method → Generate instances from strings or JSON data
• Managing configuration values and class variables → Change application-wide settings, e.g., Config.update_language()
• Managing overall class state → Used for tracking total instance count or versioning
• Dynamic class design leveraging inheritance → Provide different behavior for each subclass

✅ Differences from Instance and Static Methods

6.2 When to Use Class Methods

6.3 Deepening Your Understanding of Class Methods

6.4 Summary