Números desde cero

Un día de estos,como me aburro mucho, se me ocurrió que era una buena idea programar en Python los números naturales desde cero. Mi idea era que funcionaran teóricamente, pero no que se usase.

Para los naturales, programé esto:

class Natural:
    def __init__(self,Previous=None):
        self.Previous=Previous
    def Succesor(self):
        return Natural(Previous=self)
    def __add__(self,value):
        if type(value)==Natural:
            if value.Previous==None:
                return self.Succesor()
            else:
                return self.Succesor()+value.Previous
        else:
            raise TypeError
    def __mul__(self,value):
        if type(value)==Natural:
            if value.Previous==None:
                return self
            else:
                return self*value.Previous+self
        else:
            raise TypeError
    def __pow__(self,value):
        if type(value)==Natural:
            if value.Previous==None:
                return self
            else:
                return self**value.Previous*self
        else:
            raise TypeError
    def __sub__(self,value):
        if type(value)=!Natural:
            raise TypeError
        if value>self:
            raise valueError
        if value.Previous==None:
            return self.Previous
        else:
            return self.Previous-value.Previous
    def __eq__(self,value):
        if type(value)=!Natural:
            raise TypeError
        return self.Previous==value.Previous
    def __gt__(self,value):
        if type(value)=!Natural:
            raise TypeError
        if value.Previous==None and self.Previous!=None:
            return True
        else:
            return self.Previous>value.Previous
    def __ge__(self,value):
        if type(value)=!Natural:
            raise TypeError
        return self==value or self>value

La clase Natural funciona asignando a None el valor 0, y a cada instancia de la clase, lo que almacene en Previous más 1.

La función Succesror suma 1. Crea una nueva instancia de la clase en la que Previous vale la entrada de la función.

La función __add__ suma a self el valor de value. Lo que hace es mirar si value.Previous vale None, y entonces devuelve self.Succesor(). Si no, devuelve self.Succesor()+value.Previous. Esto lo que hace es sumar 1 a self y luego restarlo a value. Sigue dando lo mismo pero está expresado de una forma un poco más conveniente

Las funciones __mul__ y __pow__ funcionan con el mismo principio que __add__, el cambio es la sustitución de self.Succesor por self+value.Previous y self*value.Previous respectivamente y la operación que compensa el cambio por el operador correspondiente a la función, además de devolver self en lugar de self.Succesor()

La fución __sub__ empieza comprobando que value es menor que self. Si no lanza una excepción. A partir de ahí, va restando value.Previous a self.Previous hasta que value valga None, emtonces devuelve self.Previous