如何在python中实现接口？

Question

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

这是个好主意吗？请在你的回答中举例说明。

Answer 1

Python 接口有第三方实现（最流行的是Zope's，也用于Twisted），但更常见的 Python 编码人员更喜欢使用更丰富的概念，即“抽象基类”（ABC )，它将接口与那里也有一些实现方面的可能性结合在一起。 ABC 在 Python 2.6 及更高版本中得到特别好的支持，请参阅 the PEP，但即使在早期版本的 Python 中，它们通常也被视为“可行的方法”——只需定义一个类，其中一些方法引发 NotImplementedError 所以子类会注意到它们最好覆盖这些方法！-)

Answer 2

这样的事情（可能无法正常工作，因为我没有 Python）：

class IInterface:
    def show(self): raise NotImplementedError

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

Answer 3

我的理解是，在 Python 等动态语言中，接口并不是必需的。在 Java（或带有抽象基类的 C++）中，接口是确保例如您传递了正确的参数，能够执行一组任务。

例如如果你有观察者和可观察者，可观察者有兴趣订阅支持 IObserver 接口的对象，而后者又具有notify 动作。这是在编译时检查的。

在 Python 中，没有 compile time 这样的东西，方法查找是在运行时执行的。此外，可以使用 __getattr__() 或 __getattribute__() 魔术方法覆盖查找。换句话说，您可以作为观察者传递任何可以在访问notify 属性时返回可调用的对象。

这使我得出结论，Python 中的接口确实存在 - 只是它们的执行被推迟到它们实际使用的那一刻

Answer 4

正如其他人在这里提到的：

Python 中不需要接口。这是因为 Python 有适当的多重继承，还有鸭式，这意味着在 Java 中你必须有接口的地方，你不必在 Python 中有它们。

也就是说，接口仍有多种用途。其中一些包含在 Python 2.6 中引入的 Python 抽象基类中。如果您想创建无法实例化但提供特定接口或实现的一部分的基类，它们很有用。

另一种用法是，如果你想以某种方式指定一个对象实现一个特定的接口，你也可以通过从它们继承来使用 ABC。另一种方法是 zope.interface，它是 Zope 组件架构的一部分，一个非常酷的组件框架。在这里，您不是从接口子类化，而是将类（甚至实例）标记为实现接口。这也可用于从组件注册表中查找组件。超酷！

Answer 5

对抽象基类使用 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()

Answer 6

在现代 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()

（灵感来自this PyMOTW-3 post。）

Answer 7

interface 支持 Python 2.7 和 Python 3.4+。

到install接口你必须

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

Answer 8

我邀请您以Structural subtyping (static duck typing)(PEP 544) 的形式探索 Python 3.8 为主题提供的内容

查看简短描述https://docs.python.org/3/library/typing.html#typing.Protocol

这里的简单例子是这样的：

from typing import Protocol

class MyShowProto(Protocol):
    def show(self):
        ...


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


class MyOtherClass:
    pass


def foo(o: MyShowProto):
    return o.show()

foo(MyClass())  # ok
foo(MyOtherClass())  # fails

foo(MyOtherClass()) 将无法通过静态类型检查：

$ mypy proto-experiment.py 
proto-experiment.py:21: error: Argument 1 to "foo" has incompatible type "MyOtherClass"; expected "MyShowProto"
Found 1 error in 1 file (checked 1 source file)

另外，你可以明确指定基类，例如：

class MyOtherClass(MyShowProto):

但请注意，这使得基类的方法实际上在子类上可用，因此静态检查器不会报告MyOtherClass 上缺少方法定义。 所以在这种情况下，为了获得有用的类型检查，我们想要显式实现的所有方法都应该用@abstractmethod装饰：

from typing import Protocol
from abc import abstractmethod

class MyShowProto(Protocol):
    @abstractmethod
    def show(self): raise NotImplementedError


class MyOtherClass(MyShowProto):
    pass


MyOtherClass()  # error in type checker