Python 接口模块

在像Python这样的面向对象语言中，接口是方法签名的集合，应该由实现类提供。实现接口是一种编写有组织的代码并实现抽象的方法。

包zope.interface为Python提供了“对象接口”的实现。它由 Zope Toolkit 项目维护。该包直接导出两个对象，“接口”和“属性”。它还导出了几个辅助方法。它旨在提供比 Python 内置的 abc 模块更严格的语义和更好的错误消息。

声明接口

在Python中，接口是使用Python类语句定义的，是interface.Interface的子类，它是所有接口的父接口。

Syntax : 
class IMyInterface(zope.interface.Interface):
    # methods and attributes

例子

import zope.interface
  
  
class MyInterface(zope.interface.Interface):
    x = zope.interface.Attribute("foo")
    def method1(self, x):
        pass
    def method2(self):
        pass
      
print(type(MyInterface))
print(MyInterface.__module__)
print(MyInterface.__name__)
  
# get attribute
x = MyInterface['x']
print(x)
print(type(x))

输出：


__main__
MyInterface

实现接口

接口充当设计类的蓝图，因此接口是使用类上的实现器装饰器来实现的。如果一个类实现了一个接口，那么该类的实例提供该接口。除了类实现的功能之外，对象还可以直接提供接口。

Syntax : 
@zope.interface.implementer(*interfaces)
class Class_name:
    # methods

例子

import zope.interface
  
  
class MyInterface(zope.interface.Interface):
    x = zope.interface.Attribute("foo")
    def method1(self, x):
        pass
    def method2(self):
        pass
  
@zope.interface.implementer(MyInterface)
class MyClass:
    def method1(self, x):
        return x**2
    def method2(self):
        return "foo"

我们声明 MyClass 实现了 MyInterface。这意味着 MyClass 的实例提供了 MyInterface。

方法

implementedBy(class) –返回一个布尔值，如果类实现了接口则返回 True，否则返回 False
providedBy(object) –返回一个布尔值，如果对象提供接口则返回 True，否则返回 False
providedBy(class) –返回 False，因为类不提供接口但实现了它
list(zope.interface.implementedBy(class)) –返回一个类实现的接口列表
list(zope.interface.providedBy(object)) –返回对象提供的接口列表。
list(zope.interface.providedBy(class)) –返回空列表，因为类不提供接口但
实现它。

import zope.interface
  
  
class MyInterface(zope.interface.Interface):
    x = zope.interface.Attribute('foo')
    def method1(self, x, y, z):
        pass
    def method2(self):
        pass
  
@zope.interface.implementer(MyInterface)
class MyClass:
    def method1(self, x):
        return x**2
    def method2(self):
        return "foo"
obj = MyClass()
  
# ask an interface whether it 
# is implemented by a class:
print(MyInterface.implementedBy(MyClass))
  
# MyClass does not provide 
# MyInterface but implements it:
print(MyInterface.providedBy(MyClass))
  
# ask whether an interface
# is provided by an object:
print(MyInterface.providedBy(obj))
  
# ask what interfaces are 
# implemented by a class:
print(list(zope.interface.implementedBy(MyClass)))
  
# ask what interfaces are
# provided by an object:
print(list(zope.interface.providedBy(obj)))
  
# class does not provide interface
print(list(zope.interface.providedBy(MyClass)))

输出：

True
False
True
[]
[]
[]

接口继承

接口可以通过将其他接口列为基本接口来扩展其他接口。

职能

extends(interface) –返回布尔值，一个接口是否扩展另一个接口。
isOrExtends(interface) –返回布尔值，无论接口是相同的还是扩展另一个。
isEqualOrExtendedBy(interface) –返回布尔值，无论接口是相同的还是一个被另一个扩展。

import zope.interface
  
  
class BaseI(zope.interface.Interface):
    def m1(self, x):
        pass
    def m2(self):
        pass
  
class DerivedI(BaseI):
    def m3(self, x, y):
        pass
  
@zope.interface.implementer(DerivedI)
class cls:
    def m1(self, z):
        return z**3
    def m2(self):
        return 'foo'
    def m3(self, x, y):
        return x ^ y
      
# Get base interfaces
print(DerivedI.__bases__)
  
# Ask whether baseI extends 
# DerivedI
print(BaseI.extends(DerivedI))
  
# Ask whether baseI is equal to
# or is extended by DerivedI
print(BaseI.isEqualOrExtendedBy(DerivedI))
  
# Ask whether baseI is equal to
# or extends DerivedI
print(BaseI.isOrExtends(DerivedI))
  
# Ask whether DerivedI is equal
# to or extends BaseI
print(DerivedI.isOrExtends(DerivedI))

输出：

(, )
False
True
False
True