Unlock Python’s Special Classes: Iterators, Context Managers, Descriptors & Metaclasses

Iterators

Iterators are objects that allow you to traverse the contents of an iterable. An iterable is any collection that can be looped over, such as lists, sets, dictionaries, or tuples.

Python defines the iterator protocol, which consists of three steps:

Calling iter on an iterable returns an iterator.

Calling next on the iterator returns the next element, or raises StopIteration when exhausted.

Calling iter on the iterator returns the iterator itself.

Based on this, we can simulate a for loop:

iterable = {'foo', 'bar', 'baz'}
iterator = iter(iterable)
while True:
    try:
        element = next(iterator)
        # process element
    except StopIteration:
        break

This is functionally equivalent to:

for element in iterable:
    # process element

How to build your own iterator?

To create a custom iterator class you need to implement:

A method named __iter__ that returns self.

A method named __next__ that returns the next value or raises StopIteration.

Example with a Tree class:

class Tree:
    def __init__(self):
        ...
    def get_node(self):
        ...
    def __iter__(self):
        return self
    def __next__(self):
        next_node = self.get_node()
        if next_node is None:
            raise StopIteration
        else:
            return next_node

Usage:

tree1 = Tree()
...
for node in tree1:
    # do something useful
...

tree2 = Tree()
...
calculation = [my_func(node) for node in tree2]

When you want to build your own collection type, use an iterator.

Before creating a custom collection, check the built‑in collections module to see if it already provides the needed functionality.

Context Managers

The context manager protocol underlies the with <resource> as <value> syntax, commonly used for safely opening files, but it can manage any resource.

The with statement runs setup code before the block and cleanup code after, guaranteeing that cleanup runs even if an exception occurs.

How to build your own context manager?

You need two magic methods in your class: __enter__ – runs when entering the context and can return a value. __exit__ – runs after the block, receives any exception information, and performs cleanup.

Example for a database connection:

class DatabaseConn:
    def __init__(self, user, password, database):
        self.database = database
        self.user = user
        self.password = password
    def __enter__(self):
        self.connection = self.database.connect(self.user, self.password)
        return self.connection
    def __exit__(self, exception_type, exception_value, traceback):
        if exception_type is not None:
            self.connection.rollback_last_transaction()
            print(traceback)
        else:
            self.connection.commit_last_transaction()
        self.connection.close()
# Usage:
with DatabaseConn('user', 'password', database_instance) as conn:
    conn.query(table='foo', field='bar', value='baz')
    ...

Consider using the built‑in tinydb or sqlite3 modules for small to medium databases, and explore contextlib for ready‑made context manager utilities.

Warning: The code in this article may contain errors and is not suitable for production use.

Descriptors

Descriptor classes let you intercept attribute access on objects.

Example of a simple descriptor used for validation:

class Keyword:
    # descriptor implementation
    ...

class Foo:
    begin_keyword = Keyword()
    end_keyword = Keyword()
    init_keyword = Keyword()
    ...

How to build your own descriptor?

A descriptor must implement at least one of __get__ or __set__. Optionally, __set_name__ can capture the attribute name.

class Keyword:
    valid_keywords = {'begin', 'end', 'continue', 'break', 'def'}
    def __set_name__(self, owner, name):
        self.private_var = '_' + name
        self.public_var = name
    def __get__(self, obj, objtype):
        return getattr(obj, self.private_var)
    def __set__(self, obj, value):
        if value not in self.valid_keywords:
            raise ValueError(f"Can't set attribute {self.public_var} to a value that is not one of {self.valid_keywords}. Got {value}")
        else:
            setattr(obj, self.private_var, value)

When you need to customize how a class attribute is retrieved or set, use a descriptor.

Abstract Base Classes

Abstract base classes (ABCs) define a template that concrete subclasses must implement.

from abc import ABC, abstractmethod

class Animal(ABC):
    def __init__(self):
        pass
    def breathe(self):
        print("I'm breathing")
    @abstractmethod
    def make_sound(self):
        print("???")

class Dog(Animal):
    pass

d = Dog()  # raises TypeError because Dog does not implement make_sound

Correct implementation:

class Dog(Animal):
    def make_sound(self):
        print("Woof")
class Cat(Animal):
    def make_sound(self):
        print("Meow")

d = Dog()
c = Cat()
d.breathe()   # I'm breathing
c.breathe()   # I'm breathing
d.make_sound()  # Woof
c.make_sound()  # Meow

ABCs can also serve as virtual base classes; for example, registering built‑in types as virtual subclasses:

class MyIterable(ABC):
    ...

MyIterable.register(list)
MyIterable.register(tuple)
MyIterable.register(dict)

Now isinstance([1,2], MyIterable) and issubclass(list, MyIterable) both return True.

When you need to ensure a set of classes implements certain methods, use an abstract base class.

Metaclasses

Metaclasses are advanced constructs that control class creation. By inheriting from type you can define custom behavior executed whenever a class is instantiated.

class MyMetaClass(type):
    ...

class Foo(metaclass=MyMetaClass):
    ...

Use metaclasses only when no other mechanism can achieve the desired behavior.

Conclusion

Python provides many ways to customize class behavior through special classes and magic methods. In most cases, defining the appropriate magic method or importing the right module is sufficient.

Understanding these special class types helps you avoid reinventing the wheel and write cleaner, more powerful Python code.