I think the answer is on PEP-0544 :

"To explicitly declare that a certain class implements a given protocol, it can be used as a regular base class."

https://peps.python.org/pep-0544/#explicitly-declaring-implementation

Personally I do subclass from protocol often because:

• my IDE is able to automatically complete method signature when I type them (the one defined inside the Protocol)
• my IDE can rename all method classes if I rename them from the Protocol
• I can implement deprecated methods (which call another method) in the Protocol class and not into all subclasses:

class DataGetter(Protocol):
    def get_data(self):
        ... 
    def get(self):
        warn('get method is deprecated use get_data instead', DeprecationWarning)
        return self.get_data()

class Image(DataGetter):
    def get_data(self):
        return "some image data"

When talking about static type checking, it helps to understand the notion of a subtype as distinct from a subclass. (In Python, type and class are synonymous; not so in the type system implemented by tools like mypy.)

A type T is a nominal subtype of type S if we explicitly say it is. Subclassing is a form of nominal subtyping: T is a subtype of S if (but not only if) T is a subclass of S.

A type T is a structural subtype of type S if it something about T itself is compatible with S. Protocols are Python's implementation of structure subtyping. Shape does not not need to be a nominal subtype of IShape (via subclassing) in order to be a structural subtype of IShape (via having an x attribute).

So the point of defining IShape as a Protocol rather than just a superclass of Shape is to support structural subtyping and avoid the need for nominal subtyping (and all the problems that inheritance can introduce).

class IShape(Protocol):
    x: float


# A structural subtype of IShape
# Not a nominal subtype of IShape
class Shape:
    def __init__(self):
        self.x = 3

# Not a structural subtype of IShape
class Unshapely:
    def __init__(self):
        pass


def foo(v: IShape):
    pass

foo(Shape())  # OK
foo(Unshapely())  # Not OK

So is structural subtyping a replacement for nominal subtyping? Not at all. Inheritance has its uses, but when it's your only method of subtyping, it gets used inappropriately. Once you have a distinction between structural and nominal subtyping in your type system, you can use the one that is appropriate to your actual needs.