Làm cách nào để triển khai giao diện trong python?

public interface IInterface
{
    void show();
}

 public class MyClass : IInterface
{

    #region IInterface Members

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

    #endregion
}

Làm cách nào để triển khai Python tương đương với mã C # này?

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

Đây có phải là một ý tưởng tốt?? Hãy cho ví dụ trong câu trả lời của bạn.

Như được đề cập bởi khác ở đây:

Các giao diện không cần thiết trong Python. Điều này là do Python có nhiều kế thừa thích hợp và cả vịt con, điều đó có nghĩa là những nơi bạn phải có giao diện trong Java, bạn không cần phải có chúng trong Python.

Điều đó nói rằng, vẫn còn một số sử dụng cho giao diện. Một số trong số chúng được bao phủ bởi các lớp cơ sở trừu tượng của Pythons, được giới thiệu trong Python 2.6. Chúng rất hữu ích, nếu bạn muốn tạo các lớp cơ sở không thể khởi tạo được, nhưng cung cấp một giao diện cụ thể hoặc một phần của việc triển khai.

Một cách sử dụng khác là nếu bạn bằng cách nào đó muốn xác định rằng một đối tượng thực hiện một giao diện cụ thể và bạn cũng có thể sử dụng ABC cho điều đó bằng cách phân lớp từ chúng. Một cách khác là zope.interface, một mô-đun là một phần của Kiến trúc thành phần Zope, một khung thành phần thực sự tuyệt vời. Ở đây bạn không phân lớp từ các giao diện, mà thay vào đó đánh dấu các lớp (hoặc thậm chí là các thể hiện) là thực hiện giao diện. Điều này cũng có thể được sử dụng để tra cứu các thành phần từ sổ đăng ký thành phần. Siêu mát!

Sử dụng mô-đun abc cho các lớp cơ sở trừu tượng dường như thực hiện thủ thuật.

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

giao diện hỗ trợ Python 2.7 và Python 3.4+.

Để cài đặt giao diện, bạn phải

pip install python-interface

Mã ví dụ:

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

Việc triển khai các giao diện với các lớp cơ sở trừu tượng đơn giản hơn nhiều trong Python 3 hiện đại và chúng phục vụ mục đích như một hợp đồng giao diện cho các tiện ích mở rộng của trình cắm thêm.

Tạo giao diện / lớp cơ sở trừu tượng:

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)

Tạo một lớp con bình thường và ghi đè tất cả các phương thức trừu tượng:

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)

Bạn có thể tùy chọn có triển khai chung trong các phương thức trừu tượng như trong create_sale_invoice(), gọi nó super()một cách rõ ràng trong lớp con như trên.

Khởi tạo một lớp con không thực hiện tất cả các phương thức trừu tượng đều thất bại:

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

Bạn cũng có thể có các thuộc tính trừu tượng, phương thức tĩnh và lớp bằng cách kết hợp các chú thích tương ứng với @abstractmethod.

Các lớp cơ sở trừu tượng là tuyệt vời để thực hiện các hệ thống dựa trên plugin. Tất cả các lớp con được nhập của một lớp đều có thể truy cập thông qua __subclasses__(), vì vậy nếu bạn tải tất cả các lớp từ thư mục plugin importlib.import_module()và nếu chúng phân lớp lớp cơ sở, bạn có quyền truy cập trực tiếp vào chúng thông qua __subclasses__()và bạn có thể chắc chắn rằng hợp đồng giao diện được thi hành cho tất cả chúng trong thời gian khởi tạo.

Đây là cách thực hiện tải plugin cho AccountingSystemví dụ trên:

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

Sau đó, bạn có thể truy cập đối tượng plugin hệ thống kế toán thông qua AccountingSystemlớp:

>>> accountingsystem = AccountingSystem.instance()

(Lấy cảm hứng từ bài đăng PyMOTW-3 này .)

Có các triển khai giao diện của bên thứ ba cho Python (phổ biến nhất là Zope , cũng được sử dụng trong Twisted ), nhưng thông thường hơn, các lập trình viên Python thích sử dụng khái niệm phong phú hơn được gọi là "Lớp cơ sở trừu tượng" (ABC), kết hợp giao diện với khả năng có một số khía cạnh thực hiện ở đó quá. Các ABC được hỗ trợ đặc biệt tốt trong Python 2.6 trở lên, hãy xem PEP , nhưng ngay cả trong các phiên bản trước của Python, chúng thường được xem là "con đường để đi" - chỉ cần định nghĩa một lớp mà một số phương thức của chúng sẽ nâng lên NotImplementedErrorđể các lớp con sẽ lưu ý rằng họ sẽ ghi đè tốt hơn các phương thức đó! -)

Một cái gì đó như thế này (có thể không hoạt động vì tôi không có Python xung quanh):

class IInterface:
    def show(self): raise NotImplementedError

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

Tôi hiểu rằng các giao diện không cần thiết trong các ngôn ngữ động như Python. Trong Java (hoặc C ++ với các lớp cơ sở trừu tượng) là các phương tiện để đảm bảo rằng ví dụ: bạn đang truyền đúng tham số, có thể thực hiện tập hợp các tác vụ.

Ví dụ: nếu bạn có người quan sát và có thể quan sát, có thể quan sát được việc đăng ký các đối tượng hỗ trợ giao diện IObserver, từ đó có notifyhành động. Điều này được kiểm tra tại thời gian biên dịch.

Trong Python, không có điều gì như compile timevà tra cứu phương thức được thực hiện trong thời gian chạy. Hơn nữa, người ta có thể ghi đè tra cứu bằng các phương thức ma thuật __getattr __ () hoặc __getattribution __ (). Nói cách khác, bạn có thể vượt qua, với tư cách là người quan sát, bất kỳ đối tượng nào có thể trả về có thể gọi được khi truy cập notifythuộc tính.

Điều này dẫn tôi đến kết luận rằng các giao diện trong Python tồn tại - chỉ là việc thực thi của chúng bị hoãn lại cho đến thời điểm chúng thực sự được sử dụng