Python笔记（5）类__方法与继承

时间：2023-03-09 15:35:24
Python笔记（5）类__方法与继承

方法

类方法@classmethod,实例方法,静态方法@staticmethod,特殊方法，__init__

形式上的区别：调用是通过类和实例进行，不能直接调用，有自己的特殊参数，如__init__有self,类方法有参数class，有自己的声明方式。

实质上的区别：类方法与类绑定，实例方法绑定实例，静态方法无绑定（和函数一样，只不过用类和实例进行调用），特殊方法某些场景会自动调用。

特殊方法

Python笔记（5）类__方法与继承

数字计算：加减乘除都是通过特殊方法来实现的，round是四舍五入。

调用方法：str()转化成字符串，len()长度，bool判断真假。

比较大小：lt是less than,le是less equal，gt是great than，ge是great equal，ne是not equal。

集合访问：setslice,getslice是切片操作，getitem，setitem是字典的item访问，contains是包含（就是if a in b）的时候用。

迭代器，属性访问，类生产，前面有说过了。

class Point(object):

    def __init__(self,x,y):

        self.x = float(x)

        self.y = float(y)

    def __sub__(self, other):

        assert isinstance(other,Point)

        return Point(self.x-other.x,self.y-other.y)

    def __add__(self, other):

        assert isinstance(other,Point)

        return Point(self.x+other.x,self.y+other.y)

    def __mul__(self,factor):

        return Point(self.x*factor, self.y*factor)

    def __div__(self,factor):

        return Point(self.x/factor, self.y/factor)    

    @property

    def xy(self):

        return (self.x,self.y)

    def __str__(self):

        return "x={0},y={1}".format(self.x,self.y)

    def __repr__(self):

        return str(self.xy)

if __name__ == '__main__':

    a = Point(50,60)

    b = Point(30,40)

    print a-b

    print a+b

    print a*2

    print a/2

a

Out[5]: (50.0, 60.0)

print a

x=50.0,y=60.0

这里重载了加减乘除。python中运算符重载很方便，只要你重新写一下特殊方法。

__str__是当你调用print的时候他会自动调用__str__。

__repr__是给计算机看的，比如你输入a 他应该输出地址什么的，但是因为这里重写了repr所以他会输出我们想要的（self.x,self.y)。

继承

通过已有的类，生产新的类，新的类具有父类的属性和方法，实现代码的重用。

单一继承比较简单，就是直接继承属性和方法。

继承顺序

MRO method resolution order 方法的解析顺序。

继承顺序，经典类是深度优先，新式类是C3算法。

经典类A是优先于C的，新式类C优先于A。

class A:

    a=1

    b=1

class B(A):

    a=2

class C(A):

    a=3

    b=3

    c=3

class D(B,C):

    pass    

if __name__=="__main__":

    d=D()
import inspect

inspect.getmro(D)

Out[15]:

(<class __main__.D at 0x07A14148>,

 <class __main__.B at 0x07A140D8>,

 <class __main__.A at 0x07A140A0>,

 <class __main__.C at 0x07A14110>)

d.a

Out[17]: 2

d.b

Out[18]: 1

d.c

Out[19]: 3

d的a属性继承自B，b属性继承自A，c属性继承自C，如果A中已经定义了c，则C对于c属性的重写则永远都不会访问到。新式类曾经有一段时间使用深度优先，这样解决了无法访问重写的问题，但是他违背了查找的顺序性。

新式类：

class A(object):

    a=1

    b=1

#只要修改A（object）就好了,其他不变。

inspect.getmro(D)

Out[22]: (__main__.D, __main__.B, __main__.C, __main__.A, object)

print d.a,d.b,d.c

2 3 3

这里a属性继承自B，bc属性继承自C。并且新式类D中有mro的特殊方法，经典类没有。

D.__mro__

Out[26]: (__main__.D, __main__.B, __main__.C, __main__.A, object)
Python笔记（5）类__方法与继承

C3算法，用的是一个拓扑排序并且为了顺序性，拓扑排序的时候出现两个入度为0则取左边的。可以参考http://python.jobbole.com/85685/。

方法调用
class A:

    def test(self):

        print "A's test"

class B(A):

    def test(self):

        print "B's test"

        A.test(self)


class C(A):

    def test(self):

        print "C's test"

        A.test(self)

class D(B,C):

    def test(self):

        print "D's test"

        B.test(self)

        C.test(self)

if __name__=="__main__":

    a=D()

    a.test()
D's test

B's test

A's test

C's test

A's test

为了避免父类函数被重复调用，所以有了Super。

Super是一个类，不是函数。Super只在新式类里有。super(instance,self)。

class A(object):

    def test(self):

        print "A's test"

class B(A):

    def test(self):

        print "B's test"

        super(B,self).test()

class C(A):

    def test(self):

        print "C's test"

        super(C,self).test()

class D(B,C):

    def test(self):

        print "D's test"

        super(D,self).test()

if __name__=="__main__":

    a=D()

    a.test()

D's test

B's test

C's test

A's test

#只出现一次，广度优先。

多态　　

　　 多态是不同类的相同方法，相同参数，不同的功能。不同的参数是重载（args,kwargs)。

　　 Python中并不需要像java那样写好接口，规定什么属性，python是一种动态语言，参数在传入之前是无法确定参数类型的。所以python会假设存在，然后直接调用，如果没有就会报错。可以参考http://blog.****.net/shangzhihaohao/article/details/7065675。

　　Python是动态强类型语言。

相关文章