ฉันจะใช้อินเทอร์เฟซในหลามได้อย่างไร

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 Abstract ซึ่งแนะนำใน Python 2.6 มันมีประโยชน์ถ้าคุณต้องการสร้างคลาสพื้นฐานที่ไม่สามารถสร้างอินสแตนซ์ได้ แต่มีส่วนติดต่อเฉพาะหรือส่วนหนึ่งของการนำไปใช้

การใช้งานอื่นคือถ้าคุณต้องการระบุว่าวัตถุนั้นใช้อินเทอร์เฟซเฉพาะและคุณสามารถใช้ ABC สำหรับสิ่งนั้นได้โดยการทำคลาสย่อยจากพวกมัน อีกวิธีหนึ่งคือ zope.interface โมดูลที่เป็นส่วนหนึ่งของ Zope Component Architecture ซึ่งเป็นเฟรมเวิร์กคอมโพเนนต์ที่ยอดเยี่ยมจริงๆ ที่นี่คุณไม่ได้คลาสย่อยจากอินเตอร์เฟส แต่ทำเครื่องหมายคลาส (หรืออินสแตนซ์) แทนเป็นการใช้อินเทอร์เฟซแทน สิ่งนี้สามารถใช้เพื่อค้นหาส่วนประกอบจากการลงทะเบียนส่วนประกอบ Supercool!

การใช้โมดูล 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)

สร้างคลาสย่อยปกติและแทนที่เมธอด abstract ทั้งหมด:

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)

คุณสามารถเลือกที่จะมีการนำไปใช้ทั่วไปในเมธอด abstract ดังเช่นในcreate_sale_invoice()เรียกมันsuper()อย่างชัดเจนในคลาสย่อยดังกล่าวข้างต้น

การสร้างอินสแตนซ์ของคลาสย่อยที่ไม่ใช้เมธอด abstract ทั้งหมดล้มเหลว:

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's , ใช้ในTwisted ), แต่โดยทั่วไปแล้ว Python coders ชอบที่จะใช้แนวคิดยิ่งขึ้นที่รู้จักกันในชื่อ "Abstract Base Class" (ABC) ซึ่งรวมอินเตอร์เฟสกับ ความเป็นไปได้ที่จะมีแง่มุมในการนำไปปฏิบัติบางอย่างเช่นกัน ABCs ได้รับการสนับสนุนเป็นอย่างดีใน 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 __ () วิธีการเวทย์มนตร์ กล่าวอีกนัยหนึ่งคุณสามารถส่งผ่านเป็นผู้สังเกตการณ์วัตถุใด ๆ ที่สามารถส่งคืน callable ในการเข้าถึงnotifyคุณลักษณะ

นี่ทำให้ฉันสรุปได้ว่าอินเตอร์เฟสใน Python มีอยู่จริง - มันเป็นเพียงการบังคับใช้ของพวกเขาถูกเลื่อนออกไปเป็นช่วงเวลาที่พวกเขาใช้งานจริง