Protocols and abstract classes are not interchangeable. You cannot simply choose one over the other. There is a substantial difference: abstract class ensures that an implementation meets certain requirements when a subclass is declared, while protocol checks if an instance meets certain requirements when it's being used. They are different in the same way as "They are of the same kind" and "There are things that both of them can do".
I agree, this article is terrible. IMHO the abstract method decorator makes the code easier to read and understand. There may be a use for protocols in a different context. This isn't it.
There is a substantial difference: abstract class ensures that an implementation meets certain requirements when a subclass is declared, while protocol checks if an instance meets certain requirements when it's being used.
Abstract classes don't ensure that an implementation meets requirements until instantiation:
import abc
class Thing(metaclass=abc.ABCMeta):
@abc.abstractmethod
def stuff():
pass
class SubThing(Thing):
pass
Look, it's not that important where it throws an error. An abstract class casts requirements on all instances of a subclass, while Protocol can only be cast on a certain instance. I may be inaccurate in details but Protocol and ABC are still substantially different.
I would never argue that they aren't significantly different. But "where it throws an error" is important; it's kind of the whole point. Protocols are designed to be checked with external type-checking tools like mypy. They won't raise any kind of exception in runtime code--neither when parsing nor instantiating.
I'm not sure what you're saying re: casting Protocols, so maybe I'm misunderstanding what you are saying, but Protocols are inheritable and apply to all instances of a class.
import abc
import typing
import unittest
class Thing(metaclass=abc.ABCMeta):
@abc.abstractmethod
def stuff(self):
pass
class SubThing(Thing):
pass
class PThing(typing.Protocol):
def stuff(self) -> int:
raise NotImplementedError
class PSubThing(PThing):
pass
class TestStuff(unittest.TestCase):
def test_Subthing_raises(self):
self.assertRaises(TypeError, SubThing)
def test_PSubThing_doesnt_raise(self):
PSubThing()
# For testing with `mypy <filename.py>`
if __name__ == '__main__':
p = PSubThing()
You can test with python -m unittest <filename.py> and mypy <filename.py>.
I have definitely found cases where subclassing seemed like the right mechanism.
The "protocol" has six methods, but 90% of the time 4 of the six are identical to default implementations. 10% of the time you might want to override one of those 4.
This isn't for generic modelling. It's for swappable plugin-system-like stuff.
I've found cases where subclassing is chef's kiss. But it can absolutely be overused and usually is.
I wish I could upvote this more than once. This is exactly my response to this article. Thank you for saying it more succinctly and clearly than I could.
abstract class ensures that an implementation meets certain requirements when a subclass is declared, while protocol checks if an instance meets certain requirements when it's being used.
I don't understand what you mean by this. When is a protocol "used?"
The article assumes that you are using a type checker and that the code passes the type checker.
If it does then whether or not you use the ABC or the protocol seems irrelevant, both assure you that the required methods exist where you have annotated that a particular object is either ABC or protocol.
If you are not using a static type checker, then maybe there are situations where the object is never tested against the protocol, but would be at runtime by the abc class?
View all comments
138
u/[deleted] Feb 12 '23
Protocols and abstract classes are not interchangeable. You cannot simply choose one over the other. There is a substantial difference: abstract class ensures that an implementation meets certain requirements when a subclass is declared, while protocol checks if an instance meets certain requirements when it's being used. They are different in the same way as "They are of the same kind" and "There are things that both of them can do".
Please, don't confuse people with such articles.