Як мені реалізувати інтерфейси в python?

public interface IInterface
{
    void show();
}

 public class MyClass : IInterface
{

    #region IInterface Members

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

    #endregion
}

Як мені реалізувати еквівалент Python цього коду 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!'

Це гарна ідея ?? Наведіть приклади у своїх відповідях.

Як згадують інші тут:

Інтерфейси не потрібні в Python. Це тому, що Python має належне багаторазове успадкування, а також ducktyping, це означає, що місця, де у вас повинні бути інтерфейси на Java, вам не потрібно мати їх у Python.

Однак, інтерфейсів все ще існує декілька. Деякі з них охоплені абстрактними базовими класами Pythons, представленими в Python 2.6. Вони корисні, якщо ви хочете створити базові класи, які неможливо створити, а надавати певний інтерфейс або частину реалізації.

Інше використання - якщо ви хочете якось вказати, що об’єкт реалізує певний інтерфейс, і ви можете використовувати ABC і для цього, підкласируючи з них. Інший спосіб - zope.interface, модуль, який є частиною Zope Component Architecture, справді надзвичайно крутим компонентним каркасом. Тут ви не підклас з інтерфейсів, а натомість позначаєте класи (або навіть екземпляри) як реалізацію інтерфейсу. Це також можна використовувати для пошуку компонентів з реєстру компонентів. Суперхолоди!

Використання модуля 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 , також використовується в Twisted ), але частіше кодери 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 ++ з його абстрактним базовим класом) інтерфейси - це засоби для забезпечення того, що, наприклад, ви передаєте потрібний параметр, здатний виконувати набір завдань.

Наприклад, якщо у вас спостерігач і спостережуваний, спостережуваний зацікавлений у підписці об’єктів, що підтримують інтерфейс IObserver, який, у свою чергу, notifyдіє. Це перевіряється під час компіляції.

У Python немає такого поняття, як compile timeі пошук способів виконується під час виконання. Крім того, можна перекрити пошук за допомогою магічних методів __getattr __ () або __getattribute __ (). Іншими словами, ви можете передати, як спостерігач, будь-який об'єкт, який може повернути дзвінок, що отримує доступ до notifyатрибута.

Це підводить мене до висновку, що інтерфейси в Python існують - це просто їхнє перенесення відкладається до моменту, коли вони фактично використовуються