Understanding Class Attributes in Object‑Oriented Programming with Examples

In object‑oriented programming, class attributes belong to the class itself and are shared across all instances, unlike instance attributes which are specific to each object.

Table of Contents

Difference between class and instance attributes

Definition and access of class attributes

Accessing class attributes via an instance

Using class attributes to count instances

Implementing the Singleton pattern with a class attribute

Storing default values in class attributes

Modifying class attribute values

Modifying class attributes through an instance

Configuration management via class attributes

Factory pattern using class attributes

1. Difference between class and instance attributes

Class attributes are defined on the class and shared by all instances, while instance attributes are defined in __init__ and belong to each object.

class Person:
    species = "Homo sapiens"  # class attribute

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

person1 = Person("张三", 20)
person2 = Person("李四", 25)
print(f"{person1.name}的物种是：{Person.species}")  # 张三的物种是：Homo sapiens
print(f"{person2.name}的物种是：{Person.species}")  # 李四的物种是：Homo sapiens

Use case: when a property is identical for all instances, a class attribute avoids redundant storage.

2. Definition and access of class attributes

Class attributes can be accessed directly via the class name.

class Car:
    brand = "Toyota"  # class attribute

print(f"汽车品牌是：{Car.brand}")  # 输出：Toyota

Use case: storing static information such as a brand name.

3. Accessing class attributes via an instance

Instances can read class attributes, but modifying them through an instance creates a new instance attribute.

class Car:
    brand = "Toyota"

car = Car()
print(f"修改前的品牌：{Car.brand}")  # Toyota
car.brand = "Honda"  # creates an instance attribute
print(f"通过实例修改后的品牌：{car.brand}")  # Honda
print(f"类属性的实际值：{Car.brand}")  # Toyota

Use case: reading shared data without affecting the class.

4. Using class attributes to count instances

class Person:
    count = 0  # class attribute for instance count

    def __init__(self, name):
        self.name = name
        Person.count += 1

person1 = Person("张三")
person2 = Person("李四")
print(f"创建了{Person.count}个Person实例")  # 输出：2

Use case: tracking how many objects have been created.

5. Implementing the Singleton pattern

class Singleton:
    _instance = None  # class attribute storing the singleton

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2)  # True

Use case: ensuring only one instance of a class exists.

6. Storing default values in class attributes

class Car:
    default_color = "白色"

    def __init__(self, color=None):
        self.color = color or Car.default_color

car1 = Car()
car2 = Car("红色")
print(f"car1的颜色是：{car1.color}")  # 白色
print(f"car2的颜色是：{car2.color}")  # 红色

Use case: providing a fallback value for all instances.

7. Modifying class attribute values

class Car:
    brand = "Toyota"

print(f"修改前的品牌：{Car.brand}")  # Toyota
Car.brand = "Honda"
print(f"修改后的品牌：{Car.brand}")  # Honda

Use case: changing a global configuration that affects every instance.

8. Modifying class attributes through an instance

class Car:
    brand = "Toyota"

car = Car()
car.brand = "Honda"  # creates an instance attribute, does not change the class attribute
print(f"通过实例修改后的品牌：{car.brand}")  # Honda
print(f"类属性的实际值：{Car.brand}")  # Toyota

Use case: be aware that assigning via an instance shadows the class attribute.

9. Configuration management via class attributes

class AppConfig:
    debug = True  # class attribute for global config

def print_config():
    if AppConfig.debug:
        print("调试模式已开启")
    else:
        print("调试模式已关闭")

print_config()  # 调试模式已开启
AppConfig.debug = False
print_config()  # 调试模式已关闭

Use case: toggling application‑wide settings.

10. Factory pattern using class attributes

class Animal:
    types = {"dog": "狗", "cat": "猫"}  # class attribute mapping

    @classmethod
    def create(cls, animal_type):
        if animal_type in cls.types:
            return cls(cls.types[animal_type])
        raise ValueError("未知的动物类型")

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

dog = Animal.create("dog")
cat = Animal.create("cat")
print(f"创建的动物是：{dog.name}")  # 狗
print(f"创建的动物是：{cat.name}")  # 猫

Use case: selecting a concrete class based on a parameter.

Conclusion

Class attributes are a powerful tool in OOP for sharing data, implementing design patterns, and managing global configuration. Understanding when to use them versus instance attributes helps write cleaner, more maintainable code.