Python'da arayüzleri nasıl uygularım?

public interface IInterface
{
    void show();
}

 public class MyClass : IInterface
{

    #region IInterface Members

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

    #endregion
}

Bu C # kodunun Python eşdeğerini nasıl uygulayabilirim?

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

Bu iyi bir fikir mi ?? Lütfen yanıtlarınızda örnekler verin.

Burada başkaları tarafından belirtildiği gibi:

Python'da arayüzler gerekli değildir. Bunun nedeni, Python'un uygun çoklu mirasa ve aynı zamanda ducktyping'e sahip olmasıdır, bu da Java'da arayüzlere sahip olmanız gereken yerlerin Python'da olması gerekmediği anlamına gelir .

Bununla birlikte, arayüzler için hala birkaç kullanım alanı vardır. Bazıları Python 2.6'da tanıtılan Pythons Abstract Base Classes kapsamındadır. Örneklenemeyecek temel sınıflar yapmak, ancak belirli bir arabirim veya uygulamanın bir parçası sağlamak istiyorsanız bunlar yararlıdır.

Başka bir kullanım, bir şekilde bir nesnenin belirli bir arabirimi uyguladığını belirtmek istiyorsanız ve bunun için ABC'yi de onlardan alt sınıflar kullanarak kullanabilirsiniz. Başka bir yol da, gerçekten harika bir bileşen çerçevesi olan Zope Bileşen Mimarisinin bir parçası olan zope.interface'dir. Burada arabirimlerden alt sınıf oluşturmazsınız, bunun yerine sınıfları (hatta örnekleri) bir arabirimi uygularken işaretleyin. Bu, bileşen kaydından bileşenleri aramak için de kullanılabilir. Süper havalı!

Soyut temel sınıflar için abc modülünü kullanmak hile yapıyor gibi görünüyor.

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

arayüzü Python 2.7 ve Python 3.4+ destekler.

To yüklemek Mecbur arayüz

pip install python-interface

Örnek Kod:

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

Soyut temel sınıflarla arayüzler uygulamak modern Python 3'te çok daha basittir ve eklenti uzantıları için bir arayüz sözleşmesi olarak bir amaca hizmet ederler.

Interface / abstract base sınıfını oluşturun:

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)

Normal bir alt sınıf oluşturun ve tüm soyut yöntemleri geçersiz kılın:

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)

İsteğe bağlı olarak, yukarıdaki gibi alt sınıfta açıkça create_sale_invoice()çağırarak soyut yöntemlerde olduğu gibi ortak uygulamaya sahip olabilirsiniz super().

Tüm soyut yöntemleri uygulamayan bir alt sınıfın oluşturulması başarısız olur:

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

İlgili ek açıklamaları bir araya getirerek soyut özelliklere, statik ve sınıf yöntemlerine de sahip olabilirsiniz @abstractmethod.

Soyut temel sınıflar eklenti tabanlı sistemleri uygulamak için mükemmeldir. Bir sınıfın tüm içe aktarılan alt sınıflarına şu yolla erişilebilir __subclasses__(); bu nedenle, tüm sınıfları bir eklenti dizininden importlib.import_module()yüklerseniz ve temel sınıfın alt sınıflarına girerseniz, bunlara doğrudan erişebilirsiniz __subclasses__()ve arabirim sözleşmesinin tümü için uygulandığından emin olabilirsiniz. onları örnekleme sırasında.

AccountingSystemYukarıdaki örnek için eklenti yükleme uygulaması şöyledir:

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

Daha sonra muhasebe sistemi eklentisi nesnesine AccountingSystemsınıf üzerinden erişebilirsiniz :

>>> accountingsystem = AccountingSystem.instance()

( Bu PyMOTW-3 yayınından esinlenilmiştir .)

Python için arayüzlerin üçüncü taraf uygulamaları vardır (en popüler olanı, Twisted'da da kullanılan Zope'dir ), ancak daha yaygın olarak Python kodlayıcıları, bir arayüzü bir araya getiren "Abstract Base Class" (ABC) olarak bilinen daha zengin konsepti kullanmayı tercih eder. orada da bazı uygulama yönlerine sahip olma olasılığı. ABC'si özellikle Python 2.6 desteklenen ve daha sonra, bkz edilir PEP ancak onlar bile normalde "gitmek için yol" olarak görülen konum Python önceki sürümlerinde, - sadece kimin yöntemler bazı yükseltmek bir sınıf tanımlamak NotImplementedErroralt sınıfları olacak şekilde bu yöntemleri geçersiz kılmaları daha iyi olur! -)

Böyle bir şey (etrafında Python yok gibi çalışmayabilir):

class IInterface:
    def show(self): raise NotImplementedError

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

Anladığım kadarıyla, arayüzler Python gibi dinamik dillerde gerekli değildir. Java (veya soyut temel sınıfıyla C ++) arayüzleri, örneğin doğru parametreyi geçtiğinizi, görevler kümesini gerçekleştirebilmenizi sağlayan araçlardır.

Gözlemciniz ve gözlemlenebilir durumunuz varsa, gözlemlenebilir olan IObserver arayüzünü destekleyen nesnelere abone olmakla ilgilenir. notify eylem içerir. Bu derleme zamanında kontrol edilir.

Python'da böyle bir şey yoktur compile timeve yöntem aramaları çalışma zamanında gerçekleştirilir. Ayrıca, __getattr __ () veya __getattribute __ () sihirli yöntemleriyle aramayı geçersiz kılabilir. Başka bir deyişle, gözlemci olarak, erişilirken çağrılabilir olarak geri dönebilen herhangi bir nesneyi iletebilirsiniz.notify özniteliğe .

Sonuca Bu potansiyel müşteriler beni, Python arabirimler bu mevcut olamayacağı - bu sadece onların icra aslında kullanıldıkları an ertelendi mi