Difference between abstract class and interface in Python
What you'll see sometimes is the following:
class Abstract1: """Some description that tells you it's abstract, often listing the methods you're expected to supply.""" def aMethod(self): raise NotImplementedError("Should have implemented this")
Because Python doesn't have (and doesn't need) a formal Interface contract, the Java-style distinction between abstraction and interface doesn't exist. If someone goes through the effort to define a formal interface, it will also be an abstract class. The only differences would be in the stated intent in the docstring.
And the difference between abstract and interface is a hairsplitting thing when you have duck typing.
Java uses interfaces because it doesn't have multiple inheritance.
Because Python has multiple inheritance, you may also see something like this
class SomeAbstraction: pass # lots of stuff - but missing somethingclass Mixin1: def something(self): pass # one implementationclass Mixin2: def something(self): pass # anotherclass Concrete1(SomeAbstraction, Mixin1): passclass Concrete2(SomeAbstraction, Mixin2): pass
This uses a kind of abstract superclass with mixins to create concrete subclasses that are disjoint.
What is the difference between abstract class and interface in Python?
An interface, for an object, is a set of methods and attributes on that object.
In Python, we can use an abstract base class to define and enforce an interface.
Using an Abstract Base Class
For example, say we want to use one of the abstract base classes from the
import collectionsclass MySet(collections.Set): pass
If we try to use it, we get an
TypeError because the class we created does not support the expected behavior of sets:
"<stdin>", line 1, in <module>TypeError: Can't instantiate abstract class MySet with abstract methods__contains__, __iter__, __len__MySet()Traceback (most recent call last): File
So we are required to implement at least
__len__. Let's use this implementation example from the documentation:
class ListBasedSet(collections.Set): """Alternate set implementation favoring space over speed and not requiring the set elements to be hashable. """ def __init__(self, iterable): self.elements = lst =  for value in iterable: if value not in lst: lst.append(value) def __iter__(self): return iter(self.elements) def __contains__(self, value): return value in self.elements def __len__(self): return len(self.elements)s1 = ListBasedSet('abcdef')s2 = ListBasedSet('defghi')overlap = s1 & s2
Implementation: Creating an Abstract Base Class
We can create our own Abstract Base Class by setting the metaclass to
abc.ABCMeta and using the
abc.abstractmethod decorator on relevant methods. The metaclass will be add the decorated functions to the
__abstractmethods__ attribute, preventing instantiation until those are defined.
For example, "effable" is defined as something that can be expressed in words. Say we wanted to define an abstract base class that is effable, in Python 2:
class Effable(object): __metaclass__ = abc.ABCMeta def __str__(self): raise NotImplementedError('users must define __str__ to use this base class')
Or in Python 3, with the slight change in metaclass declaration:
class Effable(object, metaclass=abc.ABCMeta): def __str__(self): raise NotImplementedError('users must define __str__ to use this base class')
Now if we try to create an effable object without implementing the interface:
class MyEffable(Effable): pass
and attempt to instantiate it:
"<stdin>", line 1, in <module>TypeError: Can't instantiate abstract class MyEffable with abstract methods __str__MyEffable()Traceback (most recent call last): File
We are told that we haven't finished the job.
Now if we comply by providing the expected interface:
class MyEffable(Effable): def __str__(self): return 'expressable!'
we are then able to use the concrete version of the class derived from the abstract one:
print(me)expressable!me = MyEffable()
There are other things we could do with this, like register virtual subclasses that already implement these interfaces, but I think that is beyond the scope of this question. The other methods demonstrated here would have to adapt this method using the
abc module to do so, however.
We have demonstrated that the creation of an Abstract Base Class defines interfaces for custom objects in Python.
Python >= 2.6 has Abstract Base Classes.
Abstract Base Classes (abbreviated ABCs) complement duck-typing by providing a way to define interfaces when other techniques like hasattr() would be clumsy. Python comes with many builtin ABCs for data structures (in the collections module), numbers (in the numbers module), and streams (in the io module). You can create your own ABC with the abc module.
In general, you don't need the concept of abstract classes, or interfaces in python (edited - see S.Lott's answer for details).