In Python, methods within a class can be categorized into instance methods, class methods, and static methods. Each serves a unique purpose and provides different levels of access to the class and its instances. In this blog, we'll explore class methods and static methods, how to use them, and common interview questions you might encounter.

Instance Methods

Before diving into class methods and static methods, let's briefly recap instance methods:

• Instance Methods: These are the most common methods in a class and are used to access or modify the object's state. They take self as the first parameter, which represents the instance of the class.

class Car:
    def __init__(self, model, year):
        self.model = model
        self.year = year

    def display_info(self):
        print(f"Car Model: {self.model}, Year: {self.year}")

# Usage
my_car = Car("Toyota", 2020)
my_car.display_info()  # Output: Car Model: Toyota, Year: 2020

Class Methods

Class methods are methods that have access to the class itself, not just instances of the class. They take cls as the first parameter, which represents the class. They are defined using the @classmethod decorator.

Why Use Class Methods?

• To create alternative constructors.

• To access or modify class-level attributes.

Example: Alternative Constructor

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

    @classmethod
    def from_birth_year(cls, name, birth_year):
        current_year = 2024
        age = current_year - birth_year
        return cls(name, age)

# Usage
person1 = Person("Alice", 30)  # Using the primary constructor
person2 = Person.from_birth_year("Bob", 1990)  # Using the alternative constructor

print(person1.name, person1.age)  # Output: Alice 30
print(person2.name, person2.age)  # Output: Bob 34

In this example, from_birth_year is an alternative constructor that calculates the age from the birth year and creates a Person instance.

Example: Modifying Class Attributes

class Employee:
    company_name = "TechCorp"

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

    @classmethod
    def change_company(cls, new_name):
        cls.company_name = new_name

# Usage
Employee.change_company("NewTechCorp")
print(Employee.company_name)  # Output: NewTechCorp

In this example, change_company is a class method that changes the class attribute company_name.

Static Methods

Static methods do not access or modify class or instance-specific data. They are utility methods that belong to the class and are defined using the @staticmethod decorator.

Why Use Static Methods?

• To define utility functions that operate independently of class and instance data.

• To keep code organized within the class namespace.

Example: Utility Function

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

# Usage
print(MathUtils.add(5, 7))  # Output: 12

In this example, add is a static method that performs addition independently of any class or instance data.

Comparison of Methods

• Instance Methods: Operate on an instance of the class (self).

• Class Methods: Operate on the class itself (cls).

• Static Methods: Do not operate on class or instance-specific data.

Interview Questions on Class Methods and Static Methods

Question 1: Explain the difference between class methods and static methods.

• Class Methods: Operate on the class itself, using cls as the first parameter. They can modify class-level data.

• Static Methods: Are independent of class and instance-specific data. They do not take cls or self as the first parameter.

Question 2: Implement a class Book with class methods and static methods.

class Book:
    def __init__(self, title, author, publication_year):
        self.title = title
        self.author = author
        self.publication_year = publication_year

    @classmethod
    def from_string(cls, book_str):
        title, author, publication_year = book_str.split(', ')
        return cls(title, author, int(publication_year))

    @staticmethod
    def is_valid_year(year):
        return year > 0

# Usage
book1 = Book("Python Basics", "John Doe", 2020)
book2 = Book.from_string("Advanced Python, Jane Smith, 2018")

print(book1.title, book1.author, book1.publication_year)  # Output: Python Basics John Doe 2020
print(book2.title, book2.author, book2.publication_year)  # Output: Advanced Python Jane Smith 2018
print(Book.is_valid_year(2024))  # Output: True

In this example, from_string is an alternative constructor (class method) that creates a Book object from a string, and is_valid_year is a static method that checks if a year is valid.

Question 3: Why would you use a class method as an alternative constructor?

Class methods as alternative constructors provide flexibility in creating instances from different kinds of input or scenarios, making code more readable and maintaining a single place for object creation logic.

Summary

• Instance Methods: Operate on class instances and can modify instance-specific data.

• Class Methods: Operate on the class itself, using cls as the first parameter, and can modify class-level data.

• Static Methods: Do not operate on class or instance-specific data and are used for utility functions.

By understanding and utilizing these methods effectively, you can write more organized and flexible object-oriented code in Python.