Comment implémenter des interfaces en python ?

Question

public interface IInterface
{
    void show();
}

 public class MyClass : IInterface
{

    #region IInterface Members

    public void show()
    {
        Console.WriteLine("Hello World!");
    }

    #endregion
}

Comment puis-je implémenter l'équivalent Python de ce code C# ?

class IInterface(object):
    def __init__(self):
        pass

    def show(self):
        raise Exception("NotImplementedException")

class MyClass(IInterface):
   def __init__(self):
       IInterface.__init__(self)

   def show(self):
       print 'Hello World!'

Est-ce une bonne idée ? Veuillez donner des exemples dans vos réponses.

Answer 1

Il existe des implémentations tierces d'interfaces pour Python (la plus populaire est la suivante Zope également utilisé dans Torsadé ), mais le plus souvent les codeurs Python préfèrent utiliser le concept plus riche connu sous le nom de "classe de base abstraite" (ABC), qui combine une interface avec la possibilité d'avoir certains aspects de mise en œuvre également. Les ABC sont particulièrement bien supportées dans Python 2.6 et les versions ultérieures. le PEP mais, même dans les versions antérieures de Python, elles sont généralement considérées comme "la voie à suivre" - il suffit de définir une classe dont certaines méthodes lèvent la valeur NotImplementedError afin que les sous-classes sachent qu'elles ont intérêt à surcharger ces méthodes !-)

Answer 2

Quelque chose comme ceci (il se peut que cela ne fonctionne pas car je n'ai pas Python sous la main) :

class IInterface:
    def show(self): raise NotImplementedError

class MyClass(IInterface):
    def show(self): print "Hello World!"

Answer 3

Je crois savoir que les interfaces ne sont pas si nécessaires dans les langages dynamiques comme Python. En Java (ou en C++ avec sa classe de base abstraite), les interfaces sont des moyens de s'assurer, par exemple, que l'on passe le bon paramètre, capable d'exécuter un ensemble de tâches.

Par exemple, si vous avez un observateur et un observable, l'observable est intéressé par l'abonnement à des objets qui supportent l'interface IObserver, qui à son tour possède l'interface notify action. Ceci est vérifié au moment de la compilation.

En Python, l'option compile time et les recherches de méthodes sont effectuées au moment de l'exécution. En outre, il est possible de remplacer la recherche par les méthodes magiques __getattr__() ou __getattribute__(). En d'autres termes, vous pouvez passer, en tant qu'observateur, n'importe quel objet qui peut retourner un appel lors de l'accès à notify attribut.

Cela me mène à la conclusion que les interfaces en Python existent - c'est juste que leur application est reportée au moment où ils sont effectivement utilisés.