Structural Patterns

Structural patterns are about composing objects together — wrapping one object inside another to change or extend how it's used, without touching its original code. The Adapter pattern wraps an object whose interface doesn't match what you need, translating calls to match:

class OldRectangle:              # a class you can't (or don't want to) modify
    def __init__(self, w, h):
        self.w, self.h = w, h
    def compute_area(self):       # wrong method name for your codebase
        return self.w * self.h

class RectangleAdapter:
    def __init__(self, old_rect):
        self.old_rect = old_rect
    def area(self):               # the interface your code actually expects
        return self.old_rect.compute_area()

The Decorator pattern (a different thing from the @decorator syntax from the Python course, though conceptually related) wraps an object to ADD behavior, while keeping the SAME interface — callers can't tell the difference between the original object and the decorated one:

class LoggingShape:
    def __init__(self, shape):
        self.shape = shape
        self.call_count = 0

    def area(self):
        self.call_count += 1        # added behavior
        return self.shape.area()     # delegates to the wrapped object

logged = LoggingShape(Rectangle(3, 4))
print(logged.area())          # 12 -- works exactly like a normal shape
print(logged.call_count)       # 1 -- but now you can track usage

Unlike Adapter (which changes the interface), Decorator preserves it exactly — LoggingShape still has .area(), just like Rectangle does, so it can be used anywhere a Shape is expected.