Skip to content

Latest commit

 

History

History
111 lines (83 loc) · 3.97 KB

README.md

File metadata and controls

111 lines (83 loc) · 3.97 KB
Raw

@classmethod

Classes and Instances

A class in Python serves as a blueprint for creating objects (instances). Each object is an instance of a class and can have attributes (data) and methods (functions) that define its behavior.

class MyClass:
    def __init__(self, attribute):
        self.attribute = attribute

    def method(self):
        return f"Attribute value is {self.attribute}"

# Creating an instance of MyClass
instance = MyClass("example")
print(instance.method())  # Output: Attribute value is example

Class Methods

Class methods are methods that are bound to the class and not the instance of the class. They can be called on the class itself, rather than on instances of the class. Class methods are defined using the @classmethod decorator and take cls as the first parameter, which refers to the class itself.

Defining and Using Class Methods

To define a class method, use the @classmethod decorator above the method definition. The first parameter of a class method is cls, which represents the class that the method is called on.

class MyClass:
    class_attribute = "class value"

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

    @classmethod
    def class_method(cls):
        return f"Class attribute value is {cls.class_attribute}"

# Calling the class method
print(MyClass.class_method())  # Output: Class attribute value is class value

Use Cases for Class Methods

Class methods are useful in several scenarios:

  1. Factory Methods: Creating alternative constructors for the class.
  2. Accessing/Modifying Class State: Accessing or modifying class-level attributes that are shared across all instances.
  3. Polymorphism: Implementing polymorphic behavior where the method’s behavior can be customized by subclasses.

Factory Methods Example

Factory methods provide an alternative way to instantiate a class, which can be useful for creating objects with specific configurations.

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    @classmethod
    def from_string(cls, date_string):
        year, month, day = map(int, date_string.split('-'))
        return cls(year, month, day)

# Creating an instance using the factory method
date_instance = Date.from_string("2024-05-27")
print(date_instance.year, date_instance.month, date_instance.day)  # Output: 2024 5 27

Differences Between @classmethod, @staticmethod, and Instance Methods

  1. Instance Methods:

    • Bound to the instance of the class.
    • Can modify the object state and access the instance through self.
    • Example: 
      class MyClass:
    def instance_method(self):
        print("Instance method called")

  2. Class Methods:

    • Bound to the class and not the instance.
    • Cannot modify object instance state, but can modify class state affecting all instances.
    • Use the @classmethod decorator.
    • Example: 
      class MyClass:
    @classmethod
    def class_method(cls):
        print("Class method called")

  3. Static Methods:

    • Not bound to the class or the instance.
    • Do not modify class or instance state.
    • Use the @staticmethod decorator.
    • Example: 
      class MyClass:
    @staticmethod
    def static_method():
        print("Static method called")

Conclusion

Understanding the @classmethod decorator in Python is crucial for effective use of object-oriented programming techniques. Class methods provide a way to operate on the class itself rather than on instances, enabling functionalities like factory methods and class-level attribute management. This tutorial covered the basics of defining and using class methods, highlighting their use cases and differences from other types of methods in Python.