Kalkulator ulamków

Jestem poczatkująca. Stworzyłam program-kalulator ułamkowy (suma i różnica). Działa on dobrze, gdy ulamki są dodatnie, dobrze uproszczone (np. 2 1/3, a nie 1 4/3), i pierwszy ułamek jest większy od drugiego.

Np.: 1 5/7 i 1 3/6 daje odpowiednio rezultaty: 3/14 (odejmowanie) i 3 3/14 (dodawanie).

Czy może ktoś pomóc mi z tym kodem i popełnić go tak, by był on uniwersalny dla dowolnego ułamka (ujemnych, "niedobrze" uproszczonych i podobnie)?

class ulamek:
    czescCalkowita = 0
    licznik = 0
    mianownik = 1

    def __init__(self,czescC = 0, licznikArg = 0, mianownikArg = 1):
        self.licznik = licznikArg
        self.mianownik = mianownikArg
        self.czescCalkowita = czescC

    def __str__(self):
        retVal = ""
        if self.czescCalkowita != 0:
            retVal = retVal + str(self. czescCalkowita) + " "
        if self.licznik != 0:
            retVal = retVal + str(self.licznik) + "/" + str(self.mianownik)
        return(retVal)

    def ulamekNiewlasciwy(self):
        self.licznik += self.czescCalkowita * self.mianownik
        self.czescCalkowita = 0

    def CzescCalkowita(self):
            self.czescCalkowita = self.licznik // self.mianownik
            self.licznik -= (self.czescCalkowita * self.mianownik)

    def upraszczanie(self):
        for i in xrange(2,100): 
            while self.licznik % i == 0 and self.mianownik % i == 0:
                self.licznik = self.licznik / i
                self.mianownik = self.mianownik / i
        return self.licznik
        return self.mianownik

    def __add__(self, innyUlamek): 
        mianownikOdp = self.mianownik * innyUlamek.mianownik
        licznikOdp = (mianownikOdp / self.mianownik) * self.licznik + (mianownikOdp / innyUlamek.mianownik) * innyUlamek.licznik
        retVal = ulamek(0, licznikOdp, mianownikOdp)
        return retVal

    def __sub__(self, innyUlamek): 
        mianownikOdp = self.mianownik * innyUlamek.mianownik
        licznikOdp = (mianownikOdp / self.mianownik) * self.licznik - (mianownikOdp / innyUlamek.mianownik) * innyUlamek.licznik
        retVal = ulamek(0, licznikOdp, mianownikOdp)
        return retVal

czescCalkowita1 = int(raw_input("Czesc calkowita pierwszego ulamka: "))
licznik1 = int(raw_input("Licznik pierwszego ulamka: "))
mianownik1 = int(raw_input("Mianownik pierwszego ulamka: "))
czescCalkowita2 = int(raw_input("Czesc calkowita drugiego ulamka: "))
licznik2 = int(raw_input("Licznik drugiego ulamka: "))
mianownik2 = int(raw_input("Mianownik drugiego ulamka: "))

A = ulamek(czescCalkowita1,licznik1,mianownik1)
B = ulamek(czescCalkowita2,licznik2,mianownik2)

A.ulamekNiewlasciwy()
B.ulamekNiewlasciwy()

mnozenie = A * B
dzielenie = A / B
roznica = A - B
suma = A + B

roznica.upraszczanie ()
suma.upraszczanie ()

roznica.CzescCalkowita ()
suma.CzescCalkowita ()

print roznica
print suma

    def upraszczanie(self):
        for i in xrange(2,100): 
            while self.licznik % i == 0 and self.mianownik % i == 0:
                self.licznik = self.licznik / i
                self.mianownik = self.mianownik / i
        return self.licznik
        return self.mianownik

Ostatnia linijka nigdy się nie wykona. Poza tym, ten kod do upraszczania jest nieco fatalny. Uprość mi proszę 4237 / 44377 taką metodą. Zapewniam, że po uproszczeniu wygląda ładniej.

Nieszczęśliwie Zaczęłaś, po co ta część całkowita? Upraszczanie jest przekomplikowane, Spróbuj tak:

from math import gcd

class Fraction:

    def __init__(self, _num, _den):
        divisor = gcd(_num, _den)
        self.num = _num // divisor
        self.den = _den // divisor

    def __str__(self):
        return str(self.num) + "/" + str(self.den)

    def __add__(self, other):
        return  Fraction(self.num * other.den + other.num * self.den, self.den * other.den)

if __name__ == '__main__':
    fr1 = Fraction(3, 4)
    fr2 = Fraction(3, 4)
    print(fr1, ",", fr2)
    print(fr1 + fr2)

Upraszcza się dzieląc przez najwiekszy wspólny dzielnik, tak?:) Jak chcesz mozna to też zrobić jako oddzielna metodę, a nie od razu w konstruktorze (tak jest prościej, imo). Jak bardzo Ci potrzebna część całkowita, to można zmodyfikować drukowanie, żeby pokazywać ją światu, ale wewnetrznie operować tylko na liczniku i mianowniku. Zobacz u siebie, metody na ułamkach zwracaja wynik z częścią całkowitą zero, przecież to nie ma sensu! Trzeba też jakoś rozwiązać (wyjątek?), sytuacje gdy ktoś poda zero w mianowniku.