Cover Page

6. Metaclasses and Attributes

Metaclasses are often mentioned in lists of Python’s features, but few understand what they accomplish in practice. The name metaclass vaguely implies a concept above and beyond a class. Simply put, metaclasses let you intercept Python’s class statement and provide special behavior each time a class is defined.

Similarly mysterious and powerful are Python’s built-in features for dynamically customizing attribute accesses. Along with Python’s object-oriented constructs, these facilities provide wonderful tools to ease the transition from simple classes to complex ones.

However, with these powers come many pitfalls. Dynamic attributes enable you to override objects and cause unexpected side effects. Metaclasses can create extremely bizarre behaviors that are unapproachable to newcomers. It’s important that you follow the rule of least surprise and only use these mechanisms to implement well-understood idioms.

Item 44: Use Plain Attributes Instead of Setter and Getter Methods

Programmers coming to Python from other languages may naturally try to implement explicit getter and setter methods in their classes:

class OldResistor:
    def __init__(self, ohms):
        self._ohms = ohms

    def get_ohms(self):
        return self._ohms

    def set_ohms(self, ohms):
        self._ohms = ohms

Using these setters and getters is simple, but it’s not Pythonic:

r0 = OldResistor(50e3)
print('Before:', r0.get_ohms())
r0.set_ohms(10e3)
print('After: ', r0.get_ohms())

>>>
Before: 50000.0
After:  10000.0

Such methods are especially clumsy for operations like incrementing in place:

r0.set_ohms(r0.get_ohms() - 4e3)
assert r0.get_ohms() == 6e3

These utility methods do, however, help define the interface for a class, making it easier to encapsulate functionality, validate usage, and define boundaries. Those are important goals when designing a class to ensure that you don’t break callers as the class evolves over time.

In Python, however, you never need to implement explicit setter or getter methods. Instead, you should always start your implementations with simple public attributes, as I do here:

class Resistor:
    def __init__(self, ohms):
        self.ohms = ohms
        self.voltage = 0
        self.current = 0

r1 = Resistor(50e3)
r1.ohms = 10e3

These attributes make operations like incrementing in place natural and clear:

r1.ohms += 5e3

Later, if I decide I need special behavior when an attribute is set, I can migrate to the @property decorator (see Item 26: “Define Function Decorators with functools.wraps” for background) and its corresponding setter attribute. Here, I define a new subclass of Resistor that lets me vary the current by assigning the voltage property. Note that in order for this code to work properly, the names of both the setter and the getter methods must match the intended property name:

Table of Contents for Effective Python: 90 Specific Ways to Write Better Python, 2nd Edition

6. Metaclasses and Attributes

Item 44: Use Plain Attributes Instead of Setter and Getter Methods

Item 45: Consider @property Instead of Refactoring Attributes

Item 46: Use Descriptors for Reusable @property Methods

Item 47: Use __getattr__, __getattribute__, and __setattr__ for Lazy Attributes

Item 48: Validate Subclasses with __init_subclass__

Item 49: Register Class Existence with __init_subclass__

Item 50: Annotate Class Attributes with __set_name__

Item 51: Prefer Class Decorators Over Metaclasses for Composable Class Extensions

Highlight

Highlight

Table of Contents for
Effective Python: 90 Specific Ways to Write Better Python, 2nd Edition

Item 45: Consider `@property` Instead of Refactoring Attributes

Item 46: Use Descriptors for Reusable `@property` Methods

Item 47: Use `getattr`, `getattribute`, and `setattr` for Lazy Attributes

Item 48: Validate Subclasses with `__init_subclass__`

Item 49: Register Class Existence with `__init_subclass__`

Item 50: Annotate Class Attributes with `__set_name__`