Difference between class property and instance variable in python

Class property and instance variable in Python are both used to store data within a class, but they have some key differences in terms of their scope, access, and usage. Here’s a comparison between class properties and instance variables:

Scope and Access:

Class Property: A class property is associated with the class itself rather than instances of the class. It is shared among all instances of the class. Class properties are accessed using the class name, and any changes made to the property are reflected across all instances.

Instance Variable: An instance variable is specific to each instance of the class. Each instance has its own copy of instance variables, and they are accessed through the instance itself. Changes made to instance variables are independent of other instances.

Declaration and Initialization:

Class Property: Class properties are typically defined within the class body using the @property decorator. They are usually associated with getter and setter methods that provide controlled access to the property.

Instance Variable: Instance variables are declared and initialized within the methods of the class, typically in the constructor (__init__() method) or other instance methods.

Usage:

Class Property: Class properties are often used to define attributes that are related to the class as a whole, rather than specific to instances. They can be used for computed or derived values, or to provide class-level configuration or settings.

Instance Variable: Instance variables are used to store data that is unique to each instance of the class. They represent the state or attributes of individual objects.

Access and Modification:

Class Property: Class properties can have customized getter and setter methods that control how the property is accessed and modified. This allows for additional validation or computation when getting or setting the value of the property.

Instance Variable: Instance variables can be directly accessed and modified by the instance itself or by other methods within the class. They can be freely assigned and modified without additional constraints.

Here’s an example to illustrate the difference:

class MyClass:
    class_property = 10  # Class Property

    def __init__(self, instance_variable):
        self.instance_variable = instance_variable  # Instance Variable

    def get_instance_variable(self):
        return self.instance_variable

    def set_instance_variable(self, new_value):
        self.instance_variable = new_value

# Accessing class property
print(MyClass.class_property)   # Output: 10

# Creating instances with different instance variables
obj1 = MyClass(20)
obj2 = MyClass(30)

# Accessing instance variables
print(obj1.get_instance_variable())   # Output: 20
print(obj2.get_instance_variable())   # Output: 30

# Modifying instance variable
obj1.set_instance_variable(40)
print(obj1.get_instance_variable())   # Output: 40
print(obj2.get_instance_variable())   # Output: 30 (unchanged)

# Modifying class property
MyClass.class_property = 50
print(obj1.class_property)   # Output: 50 (modified)
print(obj2.class_property)   # Output: 50 (modified)

In this example, class_property is a class property that is accessed through the class name MyClass. Each instance of MyClass has its own instance_variable, which is accessed and modified through instance methods or directly within the class.