What you need is a factory , that is, a method or function that can create objects. __init__()it is not a factory, it cannot create objects, it can only initialize previously created objects. In fact __init__()it never returns anything (and if it does, the return value is ignored).

But every class has a method __new__()that is responsible for creating the object, and which Python calls before calling __init__(). It is in that method where you must do your "magic".

The problem is that the thing is not as simple as:

# ESTO NO VA A FUNCIONAR, BUCLE INFINITO DE RECURSION
class Numero:
    def __new__(cls, valor: str):
      if '.' in valor:
          return NumeroDecimal(valor)
      else:
          return NumeroEntero(valor)

The reason why it doesn't work is that when trying to instantiate an object through the syntax NumeroDecimal(), python will call NumeroDecimal.__new__(), and since it is not implemented, it will call the one __new__()of its base class, so we end up entering again by Numero.__new__()and we are in a infinite recursion loop that terminates when it breaks the stack.

That forces us to use this other slightly more cumbersome syntax:

# Esto si fuciona
class Numero:
    def __new__(cls, valor: str):
      if '.' in valor:
          return super().__new__(NumeroDecimal)
      else:
          return super().__new__(NumeroEntero)

class NumeroEntero(Numero):
    def __init__(self, valor: str):
        self.valor = int(valor)

class NumeroDecimal(Numero):
    def __init__(self, valor: str):
        self.valor = float(valor)


var1 = Numero("10")
var2 = Numero("10.0")
print(type(var1), type(var2))

Result:

<class '__main__.NumeroEntero'> <class '__main__.NumeroDecimal'>

By doing it this way: super().__new__(NumeroDecimal)we are calling the __new__()from the base class of Numero. In this case there is "no" base class, so your base class is actually object. This is the Python class that every other class derives from, and it contains the method __new__()that ultimately creates the objects (allocates memory, etc... that stuff that happens behind the scenes). The method __new__()always receives as its first parameter the class it is supposed to instantiate, although it can instantiate something else, as our factory does.

More details

When the code does for example:

n = Numero("10")

the following happens:

1. Python invokes Numero.__new__(Numero, "10")and collects the value that it returns in a temporary variable, let 's call it obj(if Numeroit does not implement __new__(), the one __new__()of its base class will be called, but passing it Numeroas the first parameter)
2. Python execute obj.__init__("10")and returnobj
3. That is assigned objto the variablen

In your case, step 1 is going to cause a call to super().__new__(NumeroEntero), that is, a call to object.__new__(NumeroEntero). This function is implemented internally by python and makes the necessary memory allocation for an object of type NumeroEntero(not yet initialized), and returns that reference, which is returned by your function as a result of theNumero.__new__()

An unforeseen side effect

As explained, we now have a new problem. We cannot force the instance to be NumeroDecimalor NumeroEnteroat will. For example:

>>> NumeroDecimal("10")
<__main__.NumeroEntero at 0x7fc22ff43950>

Although we have asked to instantiate a NumeroDecimal, the result has been a NumeroEntero. It is foreseeable that this happens because the NumeroDecimal.__new__(), is not implemented, so it goes to its base class, it is called Numero.__new__()and therefore it is the factory that decides the type, based on the string "10".

To avoid this problem we should make the factory decide the type based on the string, only if it is being used with the syntax Numero("10"), but not if it is reached from the syntax NumerDecimal("10"). How to differentiate these cases? Well, by the first parameter clsthat the factory receives, which would be Numeroin the first case but NumeroDecimalin the second.

If cls it IS NOT Numero , then the factory must return an object of the type specified in clsand if it is Numero, the factory will decide intelligently according to the value of the received string.

So that:

class Numero:
    def __new__(cls, valor: str):
      if cls != Numero:
        return super().__new__(cls)
      if '.' in valor:
          return super().__new__(NumeroDecimal)
      else:
          return super().__new__(NumeroEntero)

And now we can see that everything works as it should:

>>> Numero("10")
<__main__.NumeroEntero at 0x7fc22fdb4dd0>

>>> Numero("10.0")
<__main__.NumeroDecimal at 0x7fc22fdaa190>

>>> NumeroDecimal("10")
<__main__.NumeroDecimal at 0x7fc22fd529d0>  # Ok!

>>> NumeroEntero("10.0")
...
ValueError: invalid literal for int() with base 10: '10.0'
# Bueno, yo me lo he buscado...