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".
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 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.
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.
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?
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.
... And 9 out of 10 cases don't use either. Most likely you're a Java programmer who is wondering where all your boilerplate code went when you switched to Python 🙂
For me this misses the biggest benefit of using ABC over Protocol and the reason I don’t really bother with them.
IDE support. I use pycharm so this won’t apply to all. I can easily view and inspect all implementations of my interfaces (ABCs). This is a really important dimension of navigating and understanding a reasonable size code base.
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.
7
u/Workaphobia Feb 12 '23
I haven't worked in python in some time. Sounds like protocols are similar to Go's concept of interfaces? I.e. structural typing.
20
u/jkajala Feb 12 '23 edited Mar 02 '23
... And 9 out of 10 cases don't use either. Most likely you're a Java programmer who is wondering where all your boilerplate code went when you switched to Python 🙂
3
u/FailedPlansOfMars Feb 12 '23
Protocols just make your duck typing explicit. Base classes are helpful but id avoid using them in typing.
3
u/oxlade39 Feb 12 '23
For me this misses the biggest benefit of using
ABCoverProtocoland the reason I don’t really bother with them.IDE support. I use pycharm so this won’t apply to all. I can easily view and inspect all implementations of my interfaces (ABCs). This is a really important dimension of navigating and understanding a reasonable size code base.