Python_basic_class1

Python类的构造和默认标准方法的使用，实现了一个‘分数类’，对于理解面向对象编程比较实用。

# 欧几里得算法求最大公约数
def gcd(m, n):
    while m % n != 0:
        oldm = m
        oldn = n

        m = oldn
        n = oldm % oldn
    return n

class Fraction:
    # 构造方法，self是一个总指向对象本身的特殊参数，它必须是第一个形式参数，这里先约分再返回分数
    def __init__(self, top, bottom):
        if((type(top) != int) or (type(bottom) != int)):
    #判断输入的数字是否为整数，不是则异常
            raise RuntimeError("You must input integer!")

        else:
            common = gcd(top, bottom)
            self.num = top // common
            self.den = bottom // common

    # _str_方法是类中默认用来实现将对象转为字符串的方法，这里重写它
    def __str__(self):
        return str(str(self.num)+"/"+str(self.den))

    # _add_方法是类中默认用来实现相加的方法，这里将它重写，使得可以进行两分数的加法，这里不需要再化简结果（构造函数已经做了）
    def __add__(self, other):
        newnum = self.num * other.den + \
                 self.den * other.num
        newden = self.den * other.den
        return Fraction(newnum,newden)

    #_sub_方法用来实现减法
    def __sub__(self, other):
        newnum = self.num * other.den - \
                self.den * other.num
        newden = self.den * other.den
        return Fraction(newnum,newden)

    #_mul_方法用来实现乘法
    def __mul__(self, other):
        newnum = self.num * other.num
        newden = self.den * other.den
        return Fraction(newnum,newden)

    #_truediv_方法实现除法
    def __truediv__(self, other):
        newnum = self.num * other.den
        newden = self.den * other.num
        return Fraction(newnum,newden)

    # 利用交叉相乘来判断两个对象的值是否相等（深相等）
    def __eq__(self, other):
        firstnum = self.num * other.den
        secondnum = other.num * self.den
        return firstnum == secondnum

    #_gt_方法判断self对象是否大于other对象
    def __gt__(self, other):
        selfnum = self.num * other.den
        othernum = other.num * self.den
        return selfnum > othernum

    #_ge_方法判断self对象是否大于等于other对象
    def __ge__(self, other):
        selfnum = self.num * other.den
        othernum = other.num * self.den
        return selfnum >= othernum

    #_lt_方法判断self对象是否小于other对象
    def __lt__(self, other):
        selfnum = self.num * other.den
        othernum = other.num * self.den
        return selfnum < othernum
    #_ne_方法判断是否不相等（!=），当只定义_eq_时，在实际调用!=时会将_eq_取反，大小于也是同样道理（可以只定义一个）
    def __ne__(self, other):
        if (self.num != other.num) or (self.den !=other.den):
            return True

    #getNum和getDen分别返回分数的分子和分母
    def getNum(self):
        return self.num

    def getDen(self):
        return self.den

    #_radd_方法  +号左侧对象没有_add_方法时，会在右侧对象寻找并调用_radd_，此时的self是 + 右端对象
    def __radd__(self, other):
        newnum = self.num * other.den + \
                 self.den * other.num
        newden = self.den * other.den
        return Fraction(newnum, newden)

if __name__ == '__main__':
    f1 = Fraction(6,-8)
    f2 = Fraction(7,4)
    print(f1+f2)
    print(f1-f2)
    print(f2.getDen())
    print(f2.getNum())
    print(f1>=f2)
    print(f1==f2)