Pythonでインターフェイスを実装するにはどうすればよいですか？

public interface IInterface
{
    void show();
}

 public class MyClass : IInterface
{

    #region IInterface Members

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

    #endregion
}

このC＃コードに相当するPythonを実装するにはどうすればよいですか？

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!'

これは良いアイデアですか？回答に例を挙げてください。

ここで他の人が述べたように：

Pythonではインターフェイスは必要ありません。これは、Pythonに適切な多重継承とダックタイピングがあるためです。つまり、Javaでインターフェースを用意する必要がある場所で、Pythonにインターフェースを用意する必要はありません。

とは言っても、インターフェースにはまだいくつかの用途があります。それらのいくつかは、Python 2.6で導入されたPython抽象基本クラスでカバーされています。インスタンス化できない基本クラスを作成したいが、特定のインターフェースまたは実装の一部を提供する場合に、これらは役立ちます。

別の使用法は、オブジェクトが特定のインターフェースを実装することをどういうわけか指定したい場合で、それらからサブクラス化することによってそのためにもABCを使用できます。もう1つの方法は、Zopeコンポーネントインターフェースの一部であるモジュールであるzope.interfaceです。これは、非常に優れたコンポーネントフレームワークです。ここでは、インターフェイスからサブクラス化するのではなく、クラス（またはインスタンス）をインターフェイスの実装としてマークします。これは、コンポーネントレジストリからコンポーネントを検索するためにも使用できます。超クール！

抽象基本クラスにabcモジュールを使用すると、うまくいくようです。

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()

インターフェースは、Python 2.7およびPython 3.4以降をサポートし。

あなたがしなければならないインターフェイスをインストールするには

pip install python-interface

コード例：

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

抽象基本クラスを使用したインターフェースの実装は、最新のPython 3でははるかに簡単であり、プラグイン拡張のインターフェースコントラクトとしての目的を果たします。

インターフェース/抽象基本クラスを作成します。

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)

通常のサブクラスを作成し、すべての抽象メソッドをオーバーライドします。

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)

オプションで、のように抽象メソッドに共通の実装を持たせ、上記のようにサブクラスcreate_sale_invoice()でsuper()明示的に呼び出すことができます。

すべての抽象メソッドを実装していないサブクラスのインスタンス化は失敗します。

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

また、対応するアノテーションを次のように組み合わせることで、抽象プロパティ、静的メソッド、およびクラスメソッドを持つことができます。 @abstractmethodます。

抽象基本クラスは、プラグインベースのシステムを実装するのに最適です。クラスのインポートされたすべてのサブクラスにはを介してアクセスできる__subclasses__()ため、プラグインディレクトリからすべてのクラスをロードしimportlib.import_module()、それらが基本クラスをサブクラス化する場合は、それらを介して直接アクセスでき、すべてのクラス__subclasses__()に対してインターフェイスコントラクトが適用されていることを確認できます。インスタンス化中にそれら。

AccountingSystem上記の例のプラグイン読み込み実装は次のとおりです。

...
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

次に、AccountingSystemクラスを通じて会計システムプラグインオブジェクトにアクセスできます。

>>> accountingsystem = AccountingSystem.instance()

（このPyMOTW-3投稿に触発されました。）

そこPython用のインターフェイスのサードパーティ製の実装は（最も人気がありますZopeのもで使用される、ツイスト）が、より一般的にPythonのプログラマーは、とのインタフェースを組み合わせた「抽象基本クラス」（ABC）、として知られている豊かな概念を使用することを好みますそこにもいくつかの実装面がある可能性。いろはは特によくはPython 2.6以降でサポートさ、参照されているPEPを、それでも以前のバージョンのPythonで、彼らは通常、「進むべき道」と見られている-ちょうどその方法のいくつかは、調達クラス定義NotImplementedErrorサブクラスがされるようにしますこれらのメソッドをオーバーライドした方がよいことに注意してください！-）

このようなもの（私がPythonを持っていないので機能しないかもしれません）：

class IInterface:
    def show(self): raise NotImplementedError

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

私の理解では、Pythonのような動的言語ではインターフェースは必要ありません。Java（またはその抽象基本クラスを備えたC ++）のインターフェースは、たとえば、一連のタスクを実行できる適切なパラメーターを渡していることを確認するための手段です。

たとえば、observerとobservableがある場合、observableはIObserverインターフェイスをサポートするオブジェクトのサブスクライブに関心があり、次にそれが notifyアクションをます。これはコンパイル時にチェックされます。

Pythonでは、compile time実行時にメソッド検索が実行されるようなものはありません。さらに、__ getattr __（）または__getattribute __（）マジックメソッドでルックアップをオーバーライドできます。言い換えると、オブザーバーとして、アクセス時にcallableを返すことができる任意のオブジェクトを渡すことができますnotify属性ます。

これは私に結論を導きます、Pythonのインターフェースは実際に存在します -それはそれらの施行がそれらが実際に使用される瞬間に延期されるだけです