Python面向对象（上）

Python面向对象（上）

python是一门面向对象的编程语言。何为对象？对象是类的实例。在生活中，任何一个事物都是一个对象，如牡丹花。牡丹花的类是花类，同样属于花类的还有荷花、月季花、金银花、菊花、梅花、兰花等，它们都是花科，但是每一朵花都有不同的枝叶，不同的色彩，不同的长相。这就是花类的各个属性了，如玫瑰花是红色，菊花是黄色……除了属性，对象里还有方法，也就是花儿怎样开花，怎样长出形态等。

我们来剖析一下分数的构成，一个分数由 分子、分母构成，分子在上，分母在下。分子可以取任意整数，分母的值不能等于0。

现在我们就可以创建一个分数类：

class Fraction:

    def __init__ (self, top, bottom):

    self.num = top

    self.den = bottom

所有的类都应该写构造方法，在python中，构造方法一般是__init__。Self是一个总是指向对象本身的特殊参数，它必须是第一个形式参数。然而，在调用方法时，从来不需要提供相应的实际参数。

在构造函数中，self.num与self.den定义了分子与分母，也就是说，调用对象时传入的初始值给其二者赋予：

Myfra = Fraction(3, 5)

#创建了一个对象Myfra，并给予初始值3和5，对应分子分母，所以为三分之五

如果我们要将此对象的值（也就是三分之五）打印出来，我们则需要定义一个show()方法：

def show(self):

    print(str(self.num)+“/”+ str(self.den))

然后我们调用这个方法：

Myfra.show()

这样就可以显示出它的值了。但其实我们有更好的实现：

def __str__(self):

    return str(self.num) +“/ ”+str( self.den))

因为python中有一套标准方法，我们可以重写它们，也就是重新定义他们，来使我们的程序更加简便。如此调用过程则为：

Myfra = Fraction(3, 5)

print(Myfra)

我们可以根据这种方式来重新其他的标准方法，如实现分数之间的加法运算：

def __add__ (self, otherFraction):

    newNum = self.num * otherFraction.den + \

    self.den * otherFraction.num

    newDen = self.den * otherFraction.den

    return Fraction(newNum, newDen)

如果要使得两个分数相加，最简单的方法就是：

由上式可得上述程序，接着调用：

F1 = Fraction(1,4)

F2 = Fraction(1,2)

F3 = F1 + F2

print(F3)

上述程序虽然可以相加，但不是最简分数，我们可以运用欧几里得算法寻得最大公因数（GCD），然后将分子分母分别除以最大公因数，结果就是最简分数。

欧几里得算法中，对于整数m和n，如果m能被n整除，那么它们的最大公因数就是n。如果m不能被n整除，那么结果是n与m除以n的余数的最大公因数。

def gcd(m, n):

    while m % n != 0:

    oldm = m

    oldn = n

    m = oldn

    n = oldm%oldn

    return n

我们通过上述程序可以迭代出最大公因数，但是需要注意的是，此程序的分数不能为负数。

#改良版分数的加法

def __add__(self, otherFraction):

    newNum = self.num * otherFraction.den + \

    self.den * otherFraction.num

    newDen = self.den * otherFraction.den

    common = gcd(newNum, newDen)

    return Fraction(newNum // common, newDen // common)

为了让两个分数进行比较，还需要怎加一个方法，我们可以通过重写内置方法__eq__来实现。

def __eq__(self, other):

    firstNum = self.num * other.den

    secNum = other.num * self.den

    return firstNum == secNum

如果我们没有重写__eq__方法，那么默认比较的是两个对象实例，如果是指向同一个实例的对象，那么他们两个才能相等，这被称为浅相等。而我们重写后，两个对象只有值相同时，才是相等的，这被称为深相等。

所有代码如下：

class Fraction:
    def __init__(self, top, botton):
        self.num = top
        self.den = botton

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

    def __add__(self, otherFraction):
        newnum = self.num * otherFraction.den + self.den * otherFraction.num
        newden = self.den * otherFraction.den

        common = gcd(newnum, newden)

        return Fraction(newnum // common, newden // common)

    def __eq__(self, otherFraction):
        firstnum = self.num * otherFraction.den
        secnum = self.den * otherFraction.num

        return firstnum == secnum

def gcd(m, n):
    while m % n != 0:
        oldm = m
        oldn = n
        m = oldn
        n = oldm % oldn
    return n

if __name__ == '__main__':
    f1 = Fraction(3, 4)
    f2 = Fraction(3, 4)
    f3 = f1 + f2
    print(f3)
    print(f1 == f2)

    f4 = Fraction(4, 8)
    f5 = Fraction(2, 4)
    print(f4 == f5)
    print(f4 + f5)