InterfacesInPython

PythonLanguage doesn't have interfaces like JavaInterfaces. If it's for MultipleInheritance, Python already has it, but for "contract compliance" it hasn't.

---

Not built-in, but ZopeApplicationServer has an 'interfaces' module that does pretty much everything you could want. The Twisted framework for AsynchronousProgramming also has a usable implementation of interfaces as regards contract compliance. -- MoeAboulkheir

---

There is a PEP for implementing Interface Syntax in Python. It's PEP-245 at http://www.python.org/peps/pep-0245.html.

It would be very nice when it's implemented, but it still can't guarantee the semantics (pre/post-conditions, and invariants) even if it's implemented. Yes, you should follow the documentation very carefully. If you are a good programmer it won't be any problem but if you are a rogue or novice programmer, what happens? If you're a rogue programmer, your code is going to stink anyway. If you're a novice, what are you doing bungling around with interfaces?

I do use UnitTests extensively when programming and apply them to interfaces compliance checking as well.

You know interfaces sometimes can deceive you -- it could be fictitious without semantic guarantee. With UnitTests, however, the interfaces can guarantee semantics as well.

The following code will tell, (If the client implements StackInterface with ListStack, she'll make a unittest module for that and name it "test_StackList". In the test, she just imports all the tests from StackInterface so that interface compliances are guaranteed. She might add some ListStack-specific test cases in the same module test_StackList.)

        #------------------------------------------------
        #StackInterface.py
        import unittest

        class StackInterface:  #or put this whole class as a doc string
            '''Anything that implements this should pass the unittests in
               StackInterface with its own MyImpl
            '''
            def push(self, anObject):
                raise NotImplementedError
            def pop(self):
                raise NotImplementedError
            def isEmpty(self):
                raise NotImplementedError

        class _Object: #helper object representing _anything_
            pass

        class TestStackInterface(unittest.TestCase):
            def setUp(self):
                self.stack=MyImpl()
            def testPushAndPop(self):
                o=_Object()
                self.stack.push(o)
                self.assertEqual(o, self.stack.pop())
            def testPopOnEmpty(self):
                self.assert_(self.stack.isEmpty())
                self.assertRaises(IndexError,self.stack.pop)
            def testPushAllAndPopAll(self):
                oList=[_Object() for i in range(10)]
                for each in oList:
                    self.stack.push(each)
                oList.reverse()
                for each in oList:
                    self.assertEqual(each, self.stack.pop())

        MyImpl=StackInterface #please override this with the real implementation

        if __name__=='__main__':  # you won't run this module directly though
            unittest.main()

        #------------------------------------------------
        #ListStack.py
        from StackInterface import StackInterface
        class ListStack(StackInterface):
            def __init__(self):
                self._s=[]
            def push(self, anObject):
                self._s.append(anObject)
            def pop(self):
                return self._s.pop()
            def isEmpty(self):
                return len(self._s)==0

        #------------------------------------------------
        #test_ListStack.py
        import unittest

        import StackInterface
        from ListStack import ListStack
        StackInterface.MyImpl=ListStack

        from StackInterface import *  #if you want to implement several
                                      #interfaces just import all of them here
        if __name__=='__main__':
            unittest.main()

-- JuneKim

---

CategoryInterface CategoryPython