Différence entre une classe abstraite et une interface en Python

Quelle est la différence entre une classe abstraite et une interface en Python?

Une interface, d'un objet, est un ensemble de méthodes et d'attributs de cet objet.

En Python, on peut utiliser une classe de base abstraite pour définir et d'appliquer une interface.

À l'aide d'une Classe de Base Abstraite

Par exemple, disons que nous voulons utiliser l'une des classes de base abstraites de la collections module:

import collections
class MySet(collections.Set):
    pass

Si nous essayons de l'utiliser, nous obtenons un TypeError parce que la classe que nous avons créé ne supporte pas le comportement attendu de jeux:

>>> MySet()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class MySet with abstract methods
__contains__, __iter__, __len__

Nous sommes donc tenus de mettre en œuvre au moins __contains__, __iter__, et __len__. Profitons de cet exemple de mise en œuvre de la la 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

Mise en œuvre: la Création d'une Classe de Base Abstraite

Nous pouvons créer notre propre Classe de Base Abstraite par la définition de la métaclasse à abc.ABCMeta et à l'aide de la abc.abstractmethod décorateur sur les méthodes pertinentes. La métaclasse seront ajouter la décorées fonctions à la __abstractmethods__ attribut, la prévention de l'instanciation jusqu'à ce que ceux-ci sont définis.

import abc

Par exemple, "effable" est défini comme quelque chose qui peut être exprimée en mots. Disons que nous voulons définir une classe de base abstraite qui est effable, en Python 2:

class Effable(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def __str__(self):
        raise NotImplementedError('users must define __str__ to use this base class')

Ou en Python 3, avec le léger changement dans la métaclasse déclaration:

class Effable(object, metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def __str__(self):
        raise NotImplementedError('users must define __str__ to use this base class')

Maintenant, si nous essayons de créer un effable objet sans la mise en œuvre de l'interface:

class MyEffable(Effable): 
    pass

et tenter de les instancier:

>>> MyEffable()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class MyEffable with abstract methods __str__

On nous dit que nous n'avons pas fini le travail.

Maintenant, si nous nous conformons en fournissant l'interface attendue:

class MyEffable(Effable): 
    def __str__(self):
        return 'expressable!'

nous sommes alors en mesure d'utiliser la version concrète de la classe dérivée à partir de l'abstrait:

>>> me = MyEffable()
>>> print(me)
expressable!

Il y a d'autres choses qu'on pourrait faire avec cela, comme registre virtuel des sous-classes qui mettent déjà en œuvre ces interfaces, mais je pense que c'est au-delà de la portée de cette question. Les autres méthodes ont démontré ici aurait l'adaptation de cette méthode à l'aide de la abc module de le faire, cependant.

Conclusion

Nous avons démontré que la création d'une Classe de Base Abstraite définit les interfaces des objets personnalisés en Python.

Python n'a pas vraiment de concept soit.

Il utilise duck-typing, qui a supprimé la nécessité pour les interfaces (au moins pour l'ordinateur :-))

Python <= 2.5:
Les classes de Base existent bien sûr, mais il n'y a pas de façon explicite à marquer d'une méthode comme "virtuelle pure", de sorte que la classe n'est pas vraiment abstrait.

Python >= 2.6:
Les classes de base abstraites ne existe (http://docs.python.org/library/abc.html). Et vous permettent de spécifier les méthodes qui doivent être mises en œuvre dans les sous-classes. Je n'aime pas beaucoup la syntaxe, mais la fonctionnalité est là. La plupart du temps, il est probablement préférable d'utiliser duck tape à partir de la "utilise" côté client.

En général, les interfaces sont utilisées que dans les langues qui utilisent l'unique héritage de la classe de modèle. Dans ces seul héritage langues, les interfaces sont généralement utilisés si une classe peut utiliser une méthode particulière ou d'un ensemble de méthodes. Aussi dans ces seul héritage langues, les classes abstraites sont utilisées pour avez défini les variables de classe en plus de aucun ou plusieurs méthodes, ou d'exploiter le seul modèle d'héritage de limiter la portée des classes qui pourrait utiliser un ensemble de méthodes.

Langages qui prennent en charge le multi-héritage du modèle ont tendance à utiliser uniquement des classes ou des classes de base abstraites et non des interfaces. Depuis Python supporte l'héritage multiple, il n'est pas utiliser les interfaces et que vous voulez utiliser les classes de base ou les classes de base abstraites.

http://docs.python.org/library/abc.html