python - abstract method in normal class

Question

I was reading official python documentation.

In the mentioned link, the second line states that:

Using this decorator requires that the class’s metaclass is ABCMeta or is derived from it.

But, I was successfully able to define the below given class.

from abc import abstractmethod

class A(object):
    def __init__(self):
        self.a = 5
    @abstractmethod
    def f(self):
        return self.a

a = A()
a.f()

So, the code above worked fine. And also, I was able to create a subclass

class B(A):
    def __init__(self):
        super(B, self).__init__() 

b = B()
b.f()

Without overriding the abstract method defined above.

So, basically does this mean that if my base class's metaclass is not ABCMeta(or derived from it), the class does not behave like an abstract class even though I have an abstract method in it?

That means, the documentation needs more clarity?

Or, is this behaviour useful somehow and I'm missing the point.

Hilaryhilbert

How were you expecting it to work? I think the documentation is pretty clear. Also, I'd say, here is not the place to discuss documentation issues. – Glauce

I expect Using this decorator requires that the class’s metaclass is ABCMeta or is derived from it. to be enforced? – Hilaryhilbert

@harman786 Problem is that the only way in Python to enforce something like that is with a metaclass. It's a Catch-22. – Navy

Answer 1

So, basically does this mean that if my base class's metaclass is not ABCMeta(or derived from it), the class does not behave like an abstract class even though I have an abstract method in it?

Correct.

All abstractmethod does is mark the method with __isabstractmethod__ = True. ABCMeta does all the real work. Here is the code for abstractmethod:

def abstractmethod(funcobj):
    """A decorator indicating abstract methods.
    Requires that the metaclass is ABCMeta or derived from it.  A
    class that has a metaclass derived from ABCMeta cannot be
    instantiated unless all of its abstract methods are overridden.
    The abstract methods can be called using any of the normal
    'super' call mechanisms.
    Usage:
        class C(metaclass=ABCMeta):
            @abstractmethod
            def my_abstract_method(self, ...):
                ...
    """
        funcobj.__isabstractmethod__ = True
        return funcobj

Runaway