How do I implement interfaces in python

Question

public interface IInterface       void show        public class MyClass   IInterface         region IInterface Members      public void show                 Console WriteLine  Hello World                 endregion     How do I implement Python equivalent of this C  code    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     Is this a good idea   Please give examples in your answers

User · Answer

I invite you to explore what Python 3 8 has to offer for the subject matter in form of Structural subtyping  static duck typing   PEP 544  See the short description https   docs python org 3 library typing html typing Protocol For the simple example here it goes like this  from typing import Protocol  class MyShowProto Protocol       def show self                 class MyClass      def show self           print  Hello World      class MyOtherClass      pass   def foo o  MyShowProto       return o show    foo MyClass       ok foo MyOtherClass       fails  foo MyOtherClass    will fail static type checks    mypy proto-experiment py  proto-experiment py 21  error  Argument 1 to  quot foo quot  has incompatible type  quot MyOtherClass quot   expected  quot MyShowProto quot  Found 1 error in 1 file  checked 1 source file    In addition  you can specify the base class explicitly  for instance  class MyOtherClass MyShowProto    but note that this makes methods of the base class actually available on the subclass  and thus the static checker will not report that a method definition is missing on the MyOtherClass  So in this case  in order to get a useful type-checking  all the methods that we want to be explicitly implemented should be decorated with  abstractmethod  from typing import Protocol from abc import abstractmethod  class MyShowProto Protocol        abstractmethod     def show self   raise NotImplementedError   class MyOtherClass MyShowProto       pass   MyOtherClass      error in type checker

User · Answer

My understanding is that interfaces are not that necessary in dynamic languages like Python  In Java  or C   with its abstract base class  interfaces are means for ensuring that e g  you re passing the right parameter  able to perform set of tasks    E g  if you have observer and observable  observable is interested in subscribing objects that supports IObserver interface  which in turn has notify action  This is checked at compile time   In Python  there is no such thing as compile time and method lookups are performed at runtime  Moreover  one can override lookup with   getattr     or   getattribute     magic methods  In other words  you can pass  as observer  any object that can return callable on accessing notify attribute    This leads me to the conclusion  that interfaces in Python do exist - it s just their enforcement is postponed to the moment in which they are actually used

User · Answer

As mentioned by other here   Interfaces are not necessary in Python  This is because Python has proper multiple inheritance  and also ducktyping  which means that the places where you must have interfaces in Java  you don t have to have them in Python   That said  there are still several uses for interfaces  Some of them are covered by Pythons Abstract Base Classes  introduced in Python 2 6  They are useful  if you want to make base classes that cannot be instantiated  but provide a specific interface or part of an implementation   Another usage is if you somehow want to specify that an object implements a specific interface  and you can use ABC s for that too by subclassing from them  Another way is zope interface  a module that is a part of the Zope Component Architecture  a really awesomely cool component framework  Here you don t subclass from the interfaces  but instead mark classes  or even instances  as implementing an interface  This can also be used to look up components from a component registry  Supercool

User · Answer

Something like this  might not work as I don t have Python around    class IInterface      def show self   raise NotImplementedError  class MyClass IInterface       def show self   print  Hello World

User · Answer

interface supports Python 2 7 and Python 3 4    To install interface you have to  pip install python-interface   Example Code   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

User · Answer

Using the abc module for abstract base classes seems to do the trick   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

User · Answer

There are third-party implementations of interfaces for Python  most popular is Zope s  also used in Twisted   but more commonly Python coders prefer to use the richer concept known as an  Abstract Base Class   ABC   which combines an interface with the possibility of having some implementation aspects there too   ABCs are particularly well supported in Python 2 6 and later  see the PEP  but even in earlier versions of Python they re normally seen as  the way to go  -- just define a class some of whose methods raise NotImplementedError so that subclasses will be on notice that they d better override those methods -

User · Answer

Implementing interfaces with abstract base classes is much simpler in modern Python 3 and they serve a purpose as an interface contract for plug-in extensions   Create the interface abstract base class   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    Create a normal subclass and override all abstract methods   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    You can optionally have common implementation in the abstract methods as in create sale invoice    calling it with super   explicitly in the subclass as above   Instantiation of a subclass that does not implement all the abstract methods fails   class IncompleteAccountingSystem AccountingSystem       pass   gt  gt  gt  accounting   IncompleteAccountingSystem   Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  TypeError  Can t instantiate abstract class IncompleteAccountingSystem with abstract methods create purchase invoice  create sale invoice   You can also have abstract properties  static and class methods by combining corresponding annotations with  abstractmethod   Abstract base classes are great for implementing plugin-based systems  All imported subclasses of a class are accessible via   subclasses      so if you load all classes from a plugin directory with importlib import module   and if they subclass the base class  you have direct access to them via   subclasses     and you can be sure that the interface contract is enforced for all of them during instantiation   Here s the plugin loading implementation for the AccountingSystem example above       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   gt  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   Then you can access the accounting system plugin object through the AccountingSystem class    gt  gt  gt  accountingsystem   AccountingSystem instance      Inspired by this PyMOTW-3 post

[python] How do I implement interfaces in python?

Examples related to python

Examples related to oop