Módulo de interfaz de Python

En lenguajes orientados a objetos como Python, la interfaz es una colección de firmas de métodos que debe proporcionar la clase implementadora. Implementar una interfaz es una forma de escribir un código organizado y lograr la abstracción.

El paquete zope.interface proporciona una implementación de «interfaces de objetos» para Python. Es mantenido por el proyecto Zope Toolkit. El paquete exporta dos objetos, ‘Interfaz’ y ‘Atributo’ directamente. También exporta varios métodos auxiliares. Su objetivo es proporcionar una semántica más estricta y mejores mensajes de error que el módulo abc integrado de Python.

Declaración de interfaz

En python, la interfaz se define mediante declaraciones de clase de python y es una subclase de interface.Interface, que es la interfaz principal para todas las interfaces.

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

Ejemplo

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

Producción :

<class zope.interface.interface.InterfaceClass>
__main__
MyInterface
<zope.interface.interface.Attribute object at 0x00000270A8C74358>
<class 'zope.interface.interface.Attribute'>

Interfaz de implementación

La interfaz actúa como modelo para el diseño de clases, por lo que las interfaces se implementan utilizando el decorador del implementador en la clase . Si una clase implementa una interfaz, las instancias de la clase proporcionan la interfaz. Los objetos pueden proporcionar interfaces directamente, además de lo que implementan sus clases.

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

Ejemplo

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"

Declaramos que MyClass implementa MyInterface. Esto significa que las instancias de MyClass proporcionan MyInterface.

Métodos

• implementado por (clase): devuelve un valor booleano, verdadero si la clase implementa la interfaz, de lo contrario, falso
• provideBy(objeto) – devuelve un valor booleano, Verdadero si el objeto proporciona la interfaz, de lo contrario Falso
• provideBy(class) – devuelve False ya que la clase no proporciona la interfaz pero la implementa
• list(zope.interface.implementedBy(class)) – devuelve la lista de interfaces implementadas por una clase
• list(zope.interface.providedBy(object)) – devuelve la lista de interfaces proporcionadas por un objeto.
• list(zope.interface.providedBy(class)) – devuelve una lista vacía ya que la clase no proporciona la interfaz pero
  la implementa.

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

Producción :

True
False
True
[<InterfaceClass __main__.MyInterface>]
[<InterfaceClass __main__.MyInterface>]
[]

Herencia de interfaz

Las interfaces pueden extender otras interfaces enumerando las otras interfaces como interfaces base.

Funciones

• extiende (interfaz): devuelve un valor booleano, ya sea que una interfaz extienda a otra.
• isOrExtends(interfaz) – devuelve un valor booleano, ya sea que las interfaces sean iguales o una extienda a otra.
• isEqualOrExtendedBy(interface) – devuelve un valor booleano, ya sea que las interfaces sean iguales o una se extienda por otra.

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

Producción :

(<InterfaceClass __main__.BaseI>, )
False
True
False
True