How to prevent a class from being instantiated in Python?

Question

I have a mother class and want to inherit it to a daughter class. But the mother class cannot be instantiated, only inherited. In other words, the mother class should be abstract.

Although Python’s POO does not support abstraction (yet), there is a standard library module called abc - having the class ABC and the function abstractmethod, to be used as a Decorator for methods of classes inherited from ABC.

Using the decorator abstractmethod in one of the class methods, it becomes abstract. However, my mother class should not have abstract methods. It should just be abstract.

The problem is that if I don’t declare some of the methods abstract, it can still be instantiated. See the code below that exemplifies what I am saying:

class Mother(ABC):
    def method(self): pass

class AbstractMother(ABC):
    @abstractmethod        # Não quero que esse método seja abstrato!
    def method(self): pass

obj = Mother()          # Compila, damn it...
obj2 = AbstractMother() # Não compila (como esperado)

A possible solution then to the problem would be to throw an exception in the method __new__ or in the __init__, to make a mistake whenever someone tries to instantiate directly from the class.

class Mother():
    def __init__(self): raise TypeError
    def method(self): pass

class Daughter(Mother):
    def __init__(self): pass

Daughter() # Compila
Mother()   # Não compilar, finalmente!

But this would be a "nut" solution, since all classes you inherit will be required to overwrite the method __new__ or the constructor, as in the code above.

That said, my doubt is: in Python 3, how to prevent a class from being instantiated, without forcing the child class to overwrite some method?

Answer 1

If for some reason you don’t want to put a simple comparison on __init__ how are you in reply from @jfaccioni , you can create a method __init_subclass__ in the base class that over-write an abstract method created only to prevent instantiation. (and use the abcs mechanisms)

The __init_subclass__ is a special class method that is called whenever a subclass is created.

import abc
class Base(abc.ABC):
    
    @abc.abstractmethod
    def _sentinel(self): pass
    
    def __init_subclass__(cls, *args, **kw):
        # Injeta um método só para sobre-escrever o abstract-method:
        cls._sentinel = lambda self: None

class B(Base): pass

In interactive mode:

In [10]: b = B()                                                                                                                                                                             

In [11]: a = Base()                                                                                                                                                                          
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-11-befb5e64d15f> in <module>
----> 1 a = Base()

TypeError: Can't instantiate abstract class Base with abstract method _sentinel

Answer 2

If I understand correctly, what you are looking for is to define the functionality of the method __init__ (or any other method) in the class Mother, but wants only the class Daughter can actually be instantiated. That is, "take advantage" of the Mother for the subclasses, but leave it as an "abstract soft class".

One way to do this is to check the class itself of the object being created within the __init__ and only produce the error if the class is Mother:

class Mother:
    def __init__(self, a, b, c):
        if self.__class__ is Mother:
            raise TypeError("Mother class cannot be instantiated")
        self.a = a
        self.b = b
        self.c = c

class Daughter(Mother):
    pass

Daughter(1, 2, 3)  # funciona
Mother(1, 2, 3)  # produz um TypeError

Although from a more theoretical point of view, I agree with the comment that it does not make much sense to have a class that is treated as if it possessed an abstract method, but which is defined within it.