Closest thing to a virtual call in python

Question

Python does not provide some built-in inheritance mechanism to call implementations of base virtual or abstract methods in the derived class from the base methods

I am wondering what is the closest thing in python that would provide the following structure:

class Base(?):
   def some_abstract_interface(self, **params):
     raise Unimplemented()
   def some_base_impl(self):
     self.some_abstract_interface(self, a=4, b=3, c=2)


class Derived(Base):

   @neat_override_decorator_here? 
   def some_abstract_interface(self, **params):
     print("actual logic here {0}".format(params))

d = Derived()
d.some_base_impl()
>>>output: actual logic here a=4, b=3, c=2

You might consider using closures, and store them in some fields, then implemening your own virtual dispatch mechanism. — Basile Starynkevitch, Sep 23 '19 at 16:46
`abc` (the abstract base class module) has a abstract method decorator [reference](https://stackoverflow.com/q/5856963/8150685). What are you trying to achieve? — Error - Syntactical Remorse, Sep 23 '19 at 16:50
for an instance of `Derived`, `self.some_abstract_interface` on `Base.some_base_impl` must resolve to the implementation in `Derived`, not the one on `Base` — lurscher, Sep 23 '19 at 16:53

blhsing · Accepted Answer · 2019-09-23T16:55:37.020

You can already do that without any neat decorator:

class Base:
    def some_abstract_interface(self):
        raise NotImplemented

    def some_base_impl(self):
        self.some_abstract_interface()

class Derived(Base):
    def some_abstract_interface(self):
        print('actual logic here')

Derived().some_base_impl()

This outputs:

actual logic here

If you want to enforce that Base is an abstract class and cannot be used to instantiate an object directly, and that some_abstract_interface is meant to be an abstract method and always has to be overridden by an implementation of the method from a child class, you can make the base class inherit from the ABC class of the abc module and decorate abstract methods with abc.abstractmethod like this:

import abc

class Base(abc.ABC):
    @abc.abstractmethod
    def some_abstract_interface(self):
        raise NotImplemented

    def some_base_impl(self):
        self.some_abstract_interface()

class Derived(Base):
    def some_abstract_interface(self):
        print('actual logic here')

Derived().some_base_impl()

that `abc` module looks like what I'm looking for – lurscher Sep 23 '19 at 16:55 — lurscher, Sep 23 '19 at 16:55

score 4 · Answer 2 · answered Sep 23 '19 at 16:52

You simply make the call yourself. That's not going to be any heavier, syntactically, then the decorator you posit.

class Derived(Base):
    def some_abstract_interface(self, **params):
        self.some_base_impl()
        print('actual logic her {0}.format(params))

In fact, you don't even need to separate some_base_impl and some_abstract_interace; an abstract method can have an implementation but still require overriding.

from abc import ABC, abstractmethod


class Base(ABC):
    @abstractmethod
    def some_abstract_interface(self, **params):
        pass  # Put base implementation here


class Derived(Base):
    def some_abstract_interface(self, **params):
        super().some_abstract_interface(**params)
        print("actual logic here {0}".format(params))

Closest thing to a virtual call in python

2 Answers2