Создайте класс «Правильная дробь» и реализуйте методы сравнения

class Fraction:
    def __init__(self, a, b):
        self.a = a
        self.b = b
 
    def __mul__(self, other):
        pass
 
    def __add__(self, other):
        pass
 
    def __sub__(self, other):
        pass
 
    def __eq__(self, other):
        pass
 
    def __gt__(self, other):
        pass
 
    def __lt__(self, other):
        pass
 
    def __str__(self):
        return f"Fraction: {self.a}, {self.b}"
 
 
f_a = Fraction(2, 3)
f_b = Fraction(3, 6)
f_c = f_b + f_a
print(f_c)  # Fraction: 21, 18
f_d = f_b * f_a
print(f_d)  # Fraction: 6, 18
f_e = f_a - f_b
print(f_e)  # Fraction: 3, 18
 
print(f_d < f_c)  # True
print(f_d > f_e)  # True
print(f_a == f_b)  # False

class Fraction:
    def __init__(self, a, b):
        self.a = a
        self.b = b
 
    def __mul__(self, other):
        return Fraction(self.a*other.a, self.b*other.b)
 
    def __add__(self, other):
        return Fraction(self.a*other.b+other.a*self.b, self.b*other.b)
 
    def __sub__(self, other):
        return Fraction(self.a*other.b-other.a*self.b, self.b*other.b)
 
    def __eq__(self, other):
        if (self.a==other.a) and (self.b==other.b):
           return True
        else:
            return False
 
    def __gt__(self, other):
        if (self.a*other.b>other.a*self.b):
            return True
        else:
            return False
 
    def __lt__(self, other):
        if (self.a*other.b<other.a*self.b):
            return True
        else:
            return False
 
    def __str__(self):
        return f"Fraction: {self.a}, {self.b}"
 
f_a = Fraction(2, 3)
f_b = Fraction(3, 6)
f_c = f_b + f_a
print(f_c)  # Fraction: 21, 18
f_d = f_b * f_a
print(f_d)  # Fraction: 6, 18
f_e = f_a - f_b
print(f_e)  # Fraction: 3, 18
print(f_d < f_c)  # True
print(f_d > f_e)  # True
print(f_a == f_b)  # False

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
 
    # Сравнения
    
    def __lt__(self,o):
        
        if self.den == 0:                      
            if self.num < 0:                   # слева минус бесконечность
                if o.den != 0:
                    return True                # -бесконечность меньше любого рационального
                elif o.num > 0:                # -бесконечность меньше +бесконечности
                    return True
                else:                          # остальное не сравнивается
                    raise ValueError
            elif self.num > 0:                 # слева плюс бесконечность
                if o.den !=0:
                    return False
                else:
                    raise ValueError
 
        if o.den == 0:                         # справа бесконечность
            if o.num > 0:
                return True
            elif o.num < 0:
                return False
            else:
                raise ValueError
                
        tmp=self.num*o.den-self.den*o.num
        return tmp<0
 
    def __le__(self,o):
        
        if self.den == 0:                      
            if self.num < 0:                   # слева минус бесконечность
                if o.den != 0:
                    return True                # -бесконечность меньше любого рационального
                elif o.num > 0:                # -бесконечность меньше +бесконечности
                    return True
                else:                          # остальное не сравнивается
                    raise ValueError
            elif self.num > 0:                 # слева плюс бесконечность
                if o.den !=0:
                    return False
                else:
                    raise ValueError
 
        if o.den == 0:                         # справа бесконечность
            if o.num > 0:
                return True
            elif o.num < 0:
                return False
            else:
                raise ValueError
                
        tmp=self.num*o.den-self.den*o.num
        return tmp<=0
 
    def __gt__(self,o):
        
        if self.den == 0:                      
            if self.num < 0:                   # слева минус бесконечность
                if o.den != 0:
                    return False               # -бесконечность меньше любого рационального
                elif o.num > 0:                # -бесконечность меньше +бесконечности
                    return False
                else:                          # остальное не сравнивается
                    raise ValueError
            elif self.num > 0:                 # слева плюс бесконечность
                if o.den !=0:
                    return True
                else:
                    raise ValueError
 
        if o.den == 0:                         # справа бесконечность
            if o.num > 0:
                return False
            elif o.num < 0:
                return True
            else:
                raise ValueError
                
        tmp=self.num*o.den-self.den*o.num
        return tmp>0
 
    def __ge__(self,o):
        
        if self.den == 0:                      
            if self.num < 0:                   # слева минус бесконечность
                if o.den != 0:
                    return False               # -бесконечность меньше любого рационального
                elif o.num > 0:                # -бесконечность меньше +бесконечности
                    return False
                else:                          # остальное не сравнивается
                    raise ValueError
            elif self.num > 0:                 # слева плюс бесконечность
                if o.den !=0:
                    return True
                else:
                    raise ValueError
 
        if o.den == 0:                         # справа бесконечность
            if o.num > 0:
                return False
            elif o.num < 0:
                return True
            else:
                raise ValueError
                
        tmp=self.num*o.den-self.den*o.num
        return tmp>=0
        
    def __eq__(self,o):
        
        if self.den == 0 and o.den == 0:
            raise ValueError
        else:
            return o.num == self.num and o.den == self.den
 
    def __ne__(self,o):
        
        if self.den == 0 and o.den == 0:
            raise ValueError
        else:
            return o.num != self.num or o.den != self.den
 
 
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)
 
print(z1 < z2)
q1=Rational(1,2)
q2=Rational(1,3)
print(q2 <= q1)
print(q1 >= q2)
print(q1 != z2)

print(f_d)  # Fraction: 6, 18