conditional class inheritance in python

You probably don't really need that, and this is probably an XY problem, but those happen regularly when you are learning a language. You should be aware that you typically don't need to build huge class hierarchies with Python like you do with some other languages. Python employs "duck typing" -- if a class has the method you want to use, just call it!

Also, by the time __init__ is called, the instance already exists. You can't (easily) change it out for a different instance at that time (though, really, anything is possible).

if you really want to be able to instantiate a class and receive what are essentially instances of completely different objects depending on what you passed to the constructor, the simple, straightforward thing to do is use a function that returns instances of different classes.

However, for completeness, you should know that classes can define a __new__ method, which gets called before __init__. This method can return an instance of the class, or an instance of a completely different class, or whatever the heck it wants. So, for example, you can do this:

class A(object):
    def __init__(self):
        self.history={}
    def do_something(self):
        print("Class A doing something", self.history)

class B(object):
    def __init__(self):
        self.history=[]
    def do_something_else(self):
        print("Class B doing something", self.history)

class C(object):
    def __new__(cls, a=False, b=False):
        if a:
            return A()
        elif b:
            return B()

use1 = C(a=True)
use2 = C(b=True)
use3 = C()

use1.do_something()
use2.do_something_else()

print (use3 is None)

This works with either Python 2 or 3. With 3 it returns:

Class A doing something {}
Class B doing something []
True

I was thinking about the very same thing and came up with a helper method for returning a class inheriting from the type provided as an argument.

The helper function defines and returns the class, which is inheriting from the type provided as an argument.

The solution presented itself when I was working on a named value class. I wanted a value, that could have its own name, but that could behave as a regular variable. The idea could be implemented mostly for debugging processes, I think. Here is the code:

def getValueClass(thetype):
    """Helper function for getting the `Value` class

    Getting the named value class, based on `thetype`.
    """

    # if thetype not in (int, float, complex):  # if needed
        # raise TypeError("The type is not numeric.")

    class Value(thetype):

        __text_signature__ = "(value, name: str = "")"
        __doc__ = f"A named value of type `{thetype.__name__}`"

        def __init__(self, value, name: str = ""):
            """Value(value, name) -- a named value"""

            self._name = name

        def __new__(cls, value, name: str = ""):

            instance = super().__new__(cls, value)

            return instance

        def __repr__(self):

            return f"{super().__repr__()}"

        def __str__(self):

            return f"{self._name} = {super().__str__()}"

    return Value

Some examples:

IValue = getValueClass(int)
FValue = getValueClass(float)
CValue = getValueClass(complex)

iv = IValue(3, "iv")
print(f"{iv!r}")
print(iv)
print()

fv = FValue(4.5, "fv")
print(f"{fv!r}")
print(fv)
print()

cv = CValue(7 + 11j, "cv")
print(f"{cv!r}")
print(cv)
print()

print(f"{iv + fv + cv = }")

The output:

3
iv = 3

4.5
fv = 4.5

(7+11j)
cv = (7+11j)

iv + fv + cv = (14.5+11j)

When working in IDLE, the variables seem to behave as built-in types, except when printing:

>>> vi = IValue(4, "vi")
>>> vi
4
>>> print(vi)
vi = 4
>>> vf = FValue(3.5, 'vf')
>>> vf
3.5
>>> vf + vi
7.5
>>>