Jak zaimplementować interfejsy w Pythonie?

public interface IInterface
{
    void show();
}

 public class MyClass : IInterface
{

    #region IInterface Members

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

    #endregion
}

Jak zaimplementować w języku Python odpowiednik tego kodu 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!'

Czy to dobry pomysł? Podaj przykłady w swoich odpowiedziach.

Jak wspomniano tutaj:

Interfejsy nie są konieczne w Pythonie. Wynika to z faktu, że Python ma odpowiednie wielokrotne dziedziczenie, a także unikanie, co oznacza, że ​​w miejscach, w których musisz mieć interfejsy w Javie, nie musisz ich mieć w Pythonie.

To powiedziawszy, wciąż istnieje kilka zastosowań interfejsów. Niektóre z nich są objęte Pythons Abstract Base Classes, wprowadzonymi w Pythonie 2.6. Są one przydatne, jeśli chcesz tworzyć klasy podstawowe, których nie można utworzyć instancji, ale zapewniają określony interfejs lub część implementacji.

Innym zastosowaniem jest, jeśli chcesz w jakiś sposób określić, że obiekt implementuje określony interfejs, i możesz również użyć do tego ABC, podklasując je. Innym sposobem jest zope.interface, moduł będący częścią Zope Component Architecture, naprawdę niesamowicie fajnego frameworka komponentów. W tym przypadku nie można podklasować interfejsów, ale zamiast tego oznaczać klasy (lub nawet instancje) jako implementujące interfejs. Można to również wykorzystać do wyszukiwania komponentów z rejestru komponentów. Super fajne!

Wydaje się, że użycie modułu abc do abstrakcyjnych klas bazowych jest wystarczające.

from abc import ABCMeta, abstractmethod

class IInterface:
    __metaclass__ = ABCMeta

    @classmethod
    def version(self): return "1.0"
    @abstractmethod
    def show(self): raise NotImplementedError

class MyServer(IInterface):
    def show(self):
        print 'Hello, World 2!'

class MyBadServer(object):
    def show(self):
        print 'Damn you, world!'


class MyClient(object):

    def __init__(self, server):
        if not isinstance(server, IInterface): raise Exception('Bad interface')
        if not IInterface.version() == '1.0': raise Exception('Bad revision')

        self._server = server


    def client_show(self):
        self._server.show()


# This call will fail with an exception
try:
    x = MyClient(MyBadServer)
except Exception as exc:
    print 'Failed as it should!'

# This will pass with glory
MyClient(MyServer()).client_show()

interfejs obsługuje Python 2.7 i Python 3.4+.

Aby zainstalować interfejs, musisz

pip install python-interface

Przykładowy kod:

from interface import implements, Interface

class MyInterface(Interface):

    def method1(self, x):
        pass

    def method2(self, x, y):
        pass


class MyClass(implements(MyInterface)):

    def method1(self, x):
        return x * 2

    def method2(self, x, y):
        return x + y

Implementacja interfejsów z abstrakcyjnymi klasami podstawowymi jest znacznie prostsza we współczesnym Pythonie 3 i służą one jako umowa interfejsu dla rozszerzeń wtyczek.

Utwórz interfejs / abstrakcyjną klasę podstawową:

from abc import ABC, abstractmethod

class AccountingSystem(ABC):

    @abstractmethod
    def create_purchase_invoice(self, purchase):
        pass

    @abstractmethod
    def create_sale_invoice(self, sale):
        log.debug('Creating sale invoice', sale)

Utwórz normalną podklasę i zastąp wszystkie metody abstrakcyjne:

class GizmoAccountingSystem(AccountingSystem):

    def create_purchase_invoice(self, purchase):
        submit_to_gizmo_purchase_service(purchase)

    def create_sale_invoice(self, sale):
        super().create_sale_invoice(sale)
        submit_to_gizmo_sale_service(sale)

Opcjonalnie możesz mieć wspólną implementację metod abstrakcyjnych jak w create_sale_invoice(), wywołując ją super()jawnie w podklasie, jak wyżej.

Instancja podklasy, która nie implementuje wszystkich metod abstrakcyjnych, kończy się niepowodzeniem:

class IncompleteAccountingSystem(AccountingSystem):
    pass

>>> accounting = IncompleteAccountingSystem()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class IncompleteAccountingSystem with abstract methods
create_purchase_invoice, create_sale_invoice

Możesz także mieć właściwości abstrakcyjne, metody statyczne i klasy, łącząc odpowiednie adnotacje z @abstractmethod.

Abstrakcyjne klasy podstawowe świetnie nadają się do wdrażania systemów opartych na wtyczkach. Wszystkie zaimportowane podklasy klasy są dostępne przez __subclasses__(), więc jeśli załadujesz wszystkie klasy z katalogu wtyczek importlib.import_module()i jeśli podklasują one klasę podstawową, masz bezpośredni dostęp do nich przez __subclasses__()i możesz być pewien, że umowa interfejsu jest egzekwowana dla wszystkich je podczas tworzenia.

Oto implementacja ładowania wtyczki dla AccountingSystempowyższego przykładu:

...
from importlib import import_module

class AccountingSystem(ABC):

    ...
    _instance = None

    @classmethod
    def instance(cls):
        if not cls._instance:
            module_name = settings.ACCOUNTING_SYSTEM_MODULE_NAME
            import_module(module_name)
            subclasses = cls.__subclasses__()
            if len(subclasses) > 1:
                raise InvalidAccountingSystemError('More than one '
                        f'accounting module: {subclasses}')
            if not subclasses or module_name not in str(subclasses[0]):
                raise InvalidAccountingSystemError('Accounting module '
                        f'{module_name} does not exist or does not '
                        'subclass AccountingSystem')
            cls._instance = subclasses[0]()
        return cls._instance

Następnie możesz uzyskać dostęp do obiektu wtyczki systemu księgowego poprzez AccountingSystemklasę:

>>> accountingsystem = AccountingSystem.instance()

(Zainspirowany tym postem PyMOTW-3 .)

Istnieją implementacje interfejsów dla języka Python (najpopularniejsze to Zope , również używane w Twisted ), ale częściej kodery Python wolą używać bogatszej koncepcji znanej jako „Abstract Base Class” (ABC), która łączy interfejs z możliwość posiadania również niektórych aspektów wdrażania. ABC są szczególnie dobrze obsługiwane w Pythonie 2.6 i późniejszych, patrz PEP , ale nawet we wcześniejszych wersjach Pythona są zwykle postrzegane jako „droga do wyjścia” - wystarczy zdefiniować klasę, której niektóre metody wychowują NotImplementedError, aby podklasy były zauważając, że lepiej zastąpią te metody!)

Coś takiego (może nie działać, ponieważ nie mam w pobliżu Pythona):

class IInterface:
    def show(self): raise NotImplementedError

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

Rozumiem, że interfejsy nie są tak potrzebne w dynamicznych językach, takich jak Python. W Javie (lub C ++ z abstrakcyjną klasą podstawową) interfejsy są sposobem na zapewnienie, że np. Przekazujesz odpowiedni parametr, zdolny do wykonania zestawu zadań.

Np. Jeśli masz obserwatora i jest obserwowalny, obserwowalny jest zainteresowany subskrybowaniem obiektów obsługujących interfejs IObserver, który z kolei ma notifyakcję. Jest to sprawdzane podczas kompilacji.

W Pythonie nie ma czegoś takiego, compile timea wyszukiwanie metod odbywa się w czasie wykonywania. Ponadto można zastąpić wyszukiwanie za pomocą magicznych metod __getattr __ () lub __getattribute __ (). Innymi słowy, możesz przekazać, jako obserwator, dowolny obiekt, który może zwrócić wywoływalne żądanie dostępu notify.

To prowadzi mnie do wniosku, że interfejsy w Pythonie istnieją - po prostu ich egzekwowanie jest odroczone do momentu, w którym są faktycznie używane