Tukukkk

Python 2.7

There is an @abstractproperty decorator for this:

from abc import ABCMeta, abstractmethod, abstractproperty





class A:

    __metaclass__ = ABCMeta



    def __init__(self):

        # ...

        pass



    @abstractproperty

    def a(self):

        pass



    @abstractmethod

    def b(self):

        pass





class B(A):

    a = 1



    def b(self):

        pass

Failure to declare a or b in the derived class B will raise a TypeError such as:

TypeError: Can't instantiate abstract class B with abstract methods a

Python 3.3+

From the documentation:

Deprecated since version 3.3: It is now possible to use property, property.getter(), property.setter() and property.deleter() with abstractmethod(), making this decorator redundant.

The above example essentialy becomes:

from abc import ABCMeta, abstractmethod





class A(metaclass=ABCMeta):

    def __init__(self):

        # ...

        pass



    @property

    @abstractmethod

    def a(self):

        pass



    @abstractmethod

    def b(self):

        pass





class B(A):

    a = 1



    def b(self):

        pass

You could create an attribute in the abc.ABC abstract base class with a value such as NotImplemented so that if the attribute is not overriden and then used, an error is shown at run time.

The following code uses a PEP 484 type hint to help PyCharm correctly statically analyze the type of the path attribute as well.

import abc





class Controller(abc.ABC):

    path = NotImplemented  # type: str





class MyController(Controller):

    path = '/home'

Have a look at the abc (Abtract Base Class) module: http://docs.python.org/library/abc.html

However, in my opinion the simplest and most common solution is to raise an exception when an instance of the base class is created, or when its property is accessed.

Your base class could implement a __new__ method that check for class attribute:

class Controller(object):

    def __new__(cls, *args, **kargs):

        if not hasattr(cls,'path'): 

            raise NotImplementedError("'Controller' subclasses should have a 'path' attribute")

        return object.__new__(cls,*args,**kargs)



class C1(Controller):

    path = 42



class C2(Controller):

    pass





c1 = C1() 

# ok



c2 = C2()  

# NotImplementedError: 'Controller' subclasses should have a 'path' attribute

This way the error raise at instantiation

Bastien Léonard's answer mentions the abstract base class module and Brendan Abel's answer deals with non-implemented attributes raising errors. To ensure that the class is not implemented outside of the module, you could prefix the base name with an underscore which denotes it as private to the module (i.e. it is not imported).

i.e.

class _Controller(object):

    path = '' # There are better ways to declare attributes - see other answers



class MyController(_Controller):

    path = '/Home'

Python3.6 implementation might looks like this:

In [20]: class X:

    ...:     def __init_subclass__(cls):

    ...:         if not hasattr(cls, 'required'):

    ...:             raise NotImplementedError



In [21]: class Y(X):

    ...:     required =5

    ...:     



In [22]: Y()

Out[22]: <__main__.Y at 0x7f08408c9a20>

class AbstractStuff:

    @property

    @abc.abstractmethod

    def some_property(self):

        pass

As of 3.3 abc.abstractproperty is deprecated, I think.

Since this question was originally asked, python has changed how abstract classes are implemented. I have used a slightly different approach using the abc.ABC formalism in python 3.6. Here I define the constant as a property which must be defined in each subclass.

from abc import ABC, abstractmethod





class Base(ABC):



    @property

    @classmethod

    @abstractmethod

    def CONSTANT(cls):

        return NotImplementedError



    def print_constant(self):

        print(type(self).CONSTANT)





class Derived(Base):

    CONSTANT = 42

This forces the derived class to define the constant, or else a runtime error will occur when you try to instantiate the subclass. When you want to use the constant for any functionality implemented in the abstract class, you must access the subclass constant by type(self).CONSTANT instead of just CONSTANT, since the value is undefined in the base class.

There are other ways to implement this, but I like this syntax as it seems to me the most plain and obvious for the reader.

The previous answers all touched useful points, but I feel the accepted answer does not directly answer the question because

• The question asks for implementation in an abstract class, but the accepted answer does not follow the abstract formalism.


• The question asks that implementation is enforced. I would argue that enforcement is stricter in this answer because it causes a runtime error when the subclass is instantiated if CONSTANT is not defined. The accepted answer allows the object to be instantiated and only throws an error when CONSTANT is accessed, making the enforcement less strict.

This is not to fault the original answers. Major changes to the abstract class syntax have occurred since they were posted, which in this case allow a neater and more functional implementation.