Создать класс – рациональную дробь

from random import randint
from math import gcd
#==============================================================================
class My_fraction:
    #==========================================================================
    def __init__(self, numerator, denominator=1):
        self._num = numerator
        self._den = denominator
        if not self._den:
            self._den = 1
        g = gcd( self._num, self._den )
        self._num //= g
        self._den //= g
        is_neg = self._num * self._den < 0
        self._den = abs( self._den )
        self._num = abs( self._num )
        if is_neg:
            self._num *= -1
    # ==========================================================================
    def __add__(self, other):
        if type( other ) == My_fraction:
            a = self._num
            b = self._den
            c = other._num
            d = other._den
            return My_fraction(a*d + b*c, b*d)
        elif type( other ) == int:
            return self + My_fraction( other )
    # ==========================================================================
    def __radd__(self, other):
        return self + other
    # ==========================================================================
    def __sub__(self, other):
        a = self._num
        b = self._den
        c = other._num
        d = other._den
        return My_fraction(a * d - b * c, b * d)
    # ==========================================================================
    def __mul__(self, other):
        a = self._num
        b = self._den
        c = other._num
        d = other._den
        return My_fraction(a * c, b * d)
    # ==========================================================================
    def __floordiv__(self, other):
        if type( other ) == My_fraction:
            a = self._num
            b = self._den
            c = other._num
            d = other._den
            return My_fraction(a * d, b * c)
        elif type( other ) == int:
            return self // My_fraction( other )
    # ==========================================================================
    def __lt__(self, other):
        a = self._num
        b = self._den
        c = other._num
        d = other._den
        return a*d < b*c
    # ==========================================================================
    def __str__(self):
        return str(self._num) + '/' + str(self._den)
# =============================================================================
a = My_fraction(2, -3)
b = My_fraction(4, 5)
print(f'a = {a}')
print(f'b = {b}')
print()
print(f'a + b = {a+b}')
print(f'a - b = {a-b}')
print(f'a * b = {a*b}')
print()
print(f'a // b = {a//b}')
print(f'a < b = {a < b}')
n = 3
arr = []
for i in range(n):
    arr.append( My_fraction( randint(-10,10), randint(-10,10) ) )
print(f'Массив:', *arr)
arr.sort(reverse=True)
print(f'Массив, отсортированный по убыванию: ', *arr)
print( f'Среднее арифметическое массива: { sum(arr)//len(arr) }' )

class Rational:
    
    # Наибольший общий делитель
    
    @staticmethod
    def gcd(a,b):
        while (b != 0):
            (a, b) = (b, a%b)
        return a     
 
    # Получить знак числа
    
    @staticmethod
    def sgn(x):
        if x>0:
            return 1
        elif x<0:
            return -1
        else:
            return 0
 
    def __init__(self,n,d=1):
        if n==0 and d !=0: # нулевой числитель дает (0,1)
            self.__num=0
            self.__den=1
        elif d==0:
            self.__num=Rational.sgn(n)
            self.__den=0
        else:
            z=Rational.sgn(n)*Rational.sgn(d)
            n=abs(n)
            d=abs(d)
            k=Rational.gcd(n,d) 
            self.__num=z*n//k
            self.__den=d//k
            
    def getnum(self):
        return self.__num
        
    def setnum(self):
        raise AttributeError
            
    def delnum(self):
        raise AttributeError
        
    num=property(getnum,setnum,delnum,"Числитель (read-only)")
    
    def getden(self):
        return self.__den
        
    def setden(self):
        raise AttributeError
            
    def delden(self):
        raise AttributeError
        
    den=property(getden,setden,delden,"Знаменатель (read-only)")
    
    def __str__(self):
        if self.__den==0:
            if self.__num>0:
                return "<+INF>"
            elif self.__num==0:
                return "<UND>"
            else:
                return "<-INF>"
        elif self.__num==0:
            return "0"
        elif self.__den==1:
            return str(self.__num)
        else:    
            return str(self.__num)+"/"+str(self.__den)
 
    # Сложение
    def __add__(self,o):
        if self.__den==0 or o.__den==0:
            if self.__num>0 and o.__num>0:
                return Rational(1,0) 
            elif self.__num<0 and o.__num<0:
                return Rational(-1,0)
            elif self.__num*o.__num<0:
                return Rational(0,0)
            elif self.__den==0 and o.__den != 0:
                return self
            else:
                return o
        else:
            n1=self.num
            d1=self.den
            n2=o.num
            d2=o.den
            n=n1*d2+n2*d1
            d=d1*d2
            k=Rational.gcd(n,d)        
            return Rational(n//k,d//k)
 
    # Вычитание
    def __sub__(self,o):
        tmp=Rational(-o.__num,o.__den)
        return self+tmp
 
    # Умножение __mul__
    
    def __mul__(self,o):
        if self.__den==0 and o.__den==0:
            if self.__num==0 or self.__den==0:
                return Rational(0,0)
            else:
                return Rational(self.__num*o.__num,0) # произвведение бесконечностей со знаком
        else:
            n1=self.num
            d1=self.den
            n2=o.num
            d2=o.den
            n=n1*n2
            d=d1*d2
            k=Rational.gcd(n,d)
            return Rational(n//k,d//k)
            
    # Деление __floordiv__
    
    def __floordiv__(self,o):
        tmp=Rational(o.__den,o.__num)
        return self*tmp
 
r1=Rational(3,2)
r2=Rational(5,6)
r5=Rational(0,0)
print(r1.num)
print(r2.den)
r3=r1+r2
r6=r1//r2
print(r3)
print(r5)
print(r5.num)
print(r5.den)
print(r6)
z1=Rational(1,2)
z2=Rational(1,3)
z3=(z1+z2)//(z1-z2)
print(z3)