🔗 Class Variables — Shared State and Metaclass Patterns

Advanced class variable patterns involve metaclasses, class decorators, and sophisticated state management. These techniques control how classes themselves behave and interact.

🎯 Metaclasses

Metaclasses are classes that create classes. They control class creation and behavior. Most of the time you don't need them, but they enable powerful patterns.

class CountingMeta(type):
    """Metaclass that counts instances"""
    def __init__(cls, name, bases, dct):
        super().__init__(name, bases, dct)
        cls._instance_count = 0

    def __call__(cls, *args, **kwargs):
        cls._instance_count += 1
        return super().__call__(*args, **kwargs)

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

u1 = User("Alice")
u2 = User("Bob")
u3 = User("Charlie")

print(f"Users created: {User._instance_count}")
# Output: Users created: 3

🏭 Singleton with Metaclass

A more elegant singleton implementation using metaclasses.

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class ConfigManager(metaclass=SingletonMeta):
    def __init__(self):
        self.settings = {}

    def set(self, key, value):
        self.settings[key] = value

    def get(self, key):
        return self.settings.get(key)

config1 = ConfigManager()
config1.set("debug", True)

config2 = ConfigManager()
print(config2.get("debug"))  # Output: True
print(config1 is config2)    # Output: True

🔄 Class Decorators

Class decorators modify class behavior without using metaclasses.

def dataclass_like(cls):
    """Decorator that adds useful methods to classes"""
    original_init = cls.__init__

    def new_init(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)
        if hasattr(original_init, '__call__'):
            try:
                original_init(self)
            except TypeError:
                pass

    def __repr__(self):
        attrs = ', '.join(f"{k}={v!r}" for k, v in self.__dict__.items())
        return f"{cls.__name__}({attrs})"

    cls.__init__ = new_init
    cls.__repr__ = __repr__
    return cls

@dataclass_like
class Person:
    pass

p = Person(name="Alice", age=25)
print(repr(p))
# Output: Person(name='Alice', age=25)

📊 Class Registry with Metaclass

Use metaclasses to automatically register subclasses.

class RegisteredMeta(type):
    registry = {}

    def __new__(mcs, name, bases, namespace):
        cls = super().__new__(mcs, name, bases, namespace)
        if name != 'Registered':  # Don't register base class
            mcs.registry[name] = cls
        return cls

class Registered(metaclass=RegisteredMeta):
    @classmethod
    def get_class(cls, name):
        return RegisteredMeta.registry.get(name)

    @classmethod
    def list_classes(cls):
        return list(RegisteredMeta.registry.keys())

class Dog(Registered):
    pass

class Cat(Registered):
    pass

class Bird(Registered):
    pass

print(Registered.list_classes())
# Output: ['Dog', 'Cat', 'Bird']

dog = Registered.get_class('Dog')()

📚 Real-World Examples

ORM Model with Metaclass

class Field:
    def __init__(self, name, field_type):
        self.name = name
        self.field_type = field_type

class ModelMeta(type):
    def __new__(mcs, name, bases, dct):
        fields = {}
        for key, value in dct.items():
            if isinstance(value, Field):
                fields[key] = value

        dct['_fields'] = fields
        return super().__new__(mcs, name, bases, dct)

class Model(metaclass=ModelMeta):
    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

    def to_dict(self):
        return {f.name: getattr(self, f.name, None)
                for f in self._fields.values()}

class User(Model):
    name = Field('name', str)
    email = Field('email', str)
    age = Field('age', int)

user = User(name="Alice", email="alice@example.com", age=25)
print(user.to_dict())
# Output: {'name': 'Alice', 'email': 'alice@example.com', 'age': 25}

Configuration with Class Variables

class AppConfig:
    _env = "production"
    _debug = False
    _database_url = "postgresql://localhost/app"
    _cache_ttl = 3600
    _observers = []

    @classmethod
    def set_env(cls, env):
        cls._env = env

    @classmethod
    def get_env(cls):
        return cls._env

    @classmethod
    def toggle_debug(cls):
        cls._debug = not cls._debug

    @classmethod
    def subscribe(cls, callback):
        cls._observers.append(callback)

    @classmethod
    def notify_change(cls, key, value):
        for callback in cls._observers:
            callback(key, value)

def log_config_change(key, value):
    print(f"Config changed: {key}={value}")

AppConfig.subscribe(log_config_change)
AppConfig.set_env("development")
AppConfig.toggle_debug()

✅ Key Takeaways

🔗 What's Next?

Continue with more advanced OOP concepts.

Advanced: Constructors & Initialization →

Ready to practice? Try challenges or explore more concepts