Are there interfaces in python?

Question

In languages like PHP and Java, there are interfaces, which, when implemented in a class, requires it to contain the methods of this interface in the same way as they were declared.

Example in PHP:

<?php

interace UserInterface
{
   public function getName();
}


class User implements UserInterface
{
    // Se eu adiconar um parâmetro, vai gerar um erro
    public function getName()
    {
        return $this->name;
    }
}

class Scholl
{
     protected $users = array();
     /*
       Obriga a implementação de uma classe que implemente a 
        interface UserInterface
     */
     public function addUser(UserInterface $user)
     {
            $this->users[] = $user;
     }
}

In Python, there is an interface or there is some standard for this?

If there are no interfaces, there is some way to "force" a method to exist in a class?

There is a type induction in Python?

Answer 1

In python is used Duck Typing, but if you need to force someone to implement certain methods if they inherit from your base classes you can use the ABC (Abstract base classes), but this is not very common (it is more common for those who write frameworks). Example:

import abc


class Shape(object):
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def method_to_implement(self, input):
        return

If a class were made that inherited from Shape but did not implement the method method_to_implement would have a TypeError for example:

class Foo(Shape):
    pass

foo = Foo()

The above code would go up the following exception TypeError: Can't instantiate abstract class Foo with abstract methods method_to_implement

Note: in python 3.x the way to declare the metaclass of a class changes a bit:

import abc


class Shape(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def method_to_implement(self, input):
        return

Another way is to do as @Pablo Palaces suggested, work with Exception NotImplementedError (what is most common in enterprise applications).

class Shape(object):

    def method_to_implement(self, input):
        raise NotImplementedError()

However, in that case, the error would only go up when the method method_to_implement were called.

class Foo(Shape):
    pass


foo = Foo()
foo.method_to_implement('bar')

Another difference is that the mistake would be a NotImplementedError and not a TypeError.

Answer 2

Python does not have a unique syntax for determining an interface. What you can do is build an object that works like one, because, after all, interface is a concept and can be implemented anyway.

A simple and quick way is to use the exception NotImplementedError in a parent class:

class Animal:

    def andar(self):
        raise NotImplementedError("Animais precisam implementar andar")

Thus, so that the exception does not occur, all child classes of Animal will need to implement their own method andar():

>>> class Cachorro(Animal):
...     pass
... 
>>> c = Cachorro()
>>> c.andar()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in andar
NotImplementedError: Animais precisam implementar andar

Note that Animal is a class like any other (without any extra syntax) and therefore you can do whatever you want with it, including putting non-abstractive methods, constants, etc... This can be good to avoid a very pharaonic architecture (interfaces + abstract classes in java) if your problem is simple, such as grouping in a single place all the logic/values/details common to a given group of classes. Remember, simple is better than complex.

Answer 3

Many Python programmers claim that others didn’t need Python interfaces - until they find someone who makes them use interfaces anyway (yes, there are people who will force you to use something you didn’t want, the great chiefs).

The above solutions solves in part, if you need your software components to be easily pluggable and extensible, there is a set of packages called ZCA (Zope Component Architecture) that basically use the packets zope.interface and zope., that facilitate the use of Python interfaces.

Here are some interesting links to their use:

• http://muthukadan.net/docs/zca.html#Marker-interfaces
• http://wiki.python.org.br/ArquiteturaDeComponentes