What is Protocol and structural subtyping?

Question

Accepted Answer

**Protocol** enables **duck typing** with type safety — no inheritance required.

```python
from typing import Protocol, runtime_checkable

# Define protocol
@runtime_checkable
class Drawable(Protocol):
    def draw(self) -> str: ...

class Circle:
    def draw(self) -> str:
        return "Drawing circle"

class Square:
    def draw(self) -> str:
        return "Drawing square"

class Line:
    def draw(self) -> str:
        return "Drawing line"

# Any object with draw() works!
def render(shape: Drawable) -> str:
    return shape.draw()

render(Circle())   # OK — has draw()
render(Square())   # OK — has draw()
render(Line())     # OK — has draw()

# Runtime check
print(isinstance(Circle(), Drawable))  # True

# Protocol with properties
@runtime_checkable
class Closeable(Protocol):
    def close(self) -> None: ...
    @property
    def is_closed(self) -> bool: ...
```

**Benefits:**
- No inheritance needed.
- Works with existing classes.
- Type-safe duck typing.

Python: What is Protocol and structural subtyping?