Design Patterns — Structural - Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy

# Client wants this interface:
class MediaPlayer:           # Target
    def play(self, file): ...
 
# But we already have this incompatible class:
class LegacyMp4(object):     # Adaptee
    def start_mp4(self, path):
        print("playing", path)
 
# Bridge the gap by FORWARDING with a translated name:
class Mp4Adapter(MediaPlayer):
    def __init__(self, legacy):
        self._legacy = legacy        # composition: hold the adaptee
    def play(self, file):
        self._legacy.start_mp4(file) # translate play() -> start_mp4()

class Color:                      # Implementation side
    def fill(self): ...
class Red(Color):
    def fill(self): return "red"
 
class Shape:                      # Abstraction side
    def __init__(self, color):    # holds a reference -> the "bridge"
        self.color = color
    def draw(self): ...
class Circle(Shape):
    def draw(self):
        return "Circle in " + self.color.fill()

class Node:
    def size(self): raise NotImplementedError
class File(Node):                 # Leaf
    def __init__(self, kb): self.kb = kb
    def size(self): return self.kb
class Folder(Node):               # Composite
    def __init__(self): self.children = []
    def add(self, n): self.children.append(n)
    def size(self):
        return sum(c.size() for c in self.children)  # recurse uniformly

class Coffee:                     # Component
    def cost(self): return 2.0
class AddOn(Coffee):              # Decorator base: wraps a Coffee, IS a Coffee
    def __init__(self, drink): self.drink = drink
class Milk(AddOn):
    def cost(self): return self.drink.cost() + 0.5   # forward + add
class Sugar(AddOn):
    def cost(self): return self.drink.cost() + 0.2
 
order = Sugar(Milk(Coffee()))     # stackable: 2.0 + 0.5 + 0.2 = 2.7

class Facade:
    def __init__(self): self.cpu, self.mem, self.disk = CPU(), Mem(), Disk()
    def start(self):
        self.cpu.freeze(); self.mem.load(); self.disk.read(); self.cpu.jump()

class GlyphFactory:
    _pool = {}
    def get(self, char):
        if char not in self._pool:
            self._pool[char] = Glyph(char)   # create once, reuse forever
        return self._pool[char]              # SHARED instance
# extrinsic state (x,y) passed at draw time, not stored in Glyph

class RealImage:
    def __init__(self, f): self._load(f)      # expensive!
    def display(self): ...
class ProxyImage:
    def __init__(self, f): self.f, self.real = f, None
    def display(self):
        if self.real is None:                 # lazy: load only on first use
            self.real = RealImage(self.f)
        self.real.display()