面向对象编程（三）

一.继承顺序

1 继承顺序

class A(object):
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B):
    def test(self):
        print('from D')

class E(C):
    def test(self):
        print('from E')

class F(D,E):
    # def test(self):
    #     print('from F')
    pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性

#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类

 1 class A(object):
 2     def test(self):
 3         print('from A')
 4 
 5 class B(A):
 6     def test(self):
 7         print('from B')
 8 
 9 class C(A):
10     def test(self):
11         print('from C')
12 
13 class D(B):
14     def test(self):
15         print('from D')
16 
17 class E(C):
18     def test(self):
19         print('from E')
20 
21 class F(D,E):
22     # def test(self):
23     #     print('from F')
24     pass
25 f1=F()
26 f1.test()
27 print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性
28 
29 #新式类继承顺序:F->D->B->E->C->A    一条路走，走完走另一条路，最后走A
30 #经典类继承顺序:F->D->B->A->E->C    一条路走，中间走尖，回到起始，再走另一条路    
31 #python3中统一都是新式类
32 #pyhon2中才分新式类与经典类

 1 class A(object):
 2     def test(self):
 3         print('from A')
 4 
 5 class M(A):
 6     # def test(self):
 7     #     print('from M')
 8     pass
 9 class N(A):
10     def test(self):
11         print('from N')
12 class B(M):
13     # def test(self):
14     #     print('from B')
15     pass
16 class C(N):
17     def test(self):
18         print('from C')
19 
20 
21 class E(C):
22     def test(self):
23         print('from E')
24 class D(B):
25     # def test(self):
26     #     print('from D')
27     pass
28 
29 class F(D,E):
30     # def test(self):
31     #      print('from F')
32     pass
33 
34 
35 f1=F()
36 f1.test()
37 print(F.mro())   #只有新式才有这个属性可以查看线性列表，经典类没有这个属性
38 
39 
40 
41 
42 [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.M'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.N'>, <class '__main__.A'>, <class 'object'>]

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

二.子类中调用父类的方法

1.父类名.父类方法（）

 1 #_*_coding:utf-8_*_
 2 __author__ = 'jj'
 3 
 4 class Vehicle: #定义交通工具类
 5      Country='China'
 6      def __init__(self,name,speed,load,power):
 7          self.name=name
 8          self.speed=speed
 9          self.load=load
10          self.power=power
11 
12      def run(self):
13          print('开动啦...')
14 
15 class Subway(Vehicle): #地铁
16     def __init__(self,name,speed,load,power,line):
17         Vehicle.__init__(self,name,speed,load,power)
18         self.line=line
19 
20     def run(self):
21         print('地铁%s号线欢迎您' %self.line)
22         Vehicle.run(self)
23 
24 line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
25 line13.run()

2.super()

 1 class Vehicle: #定义交通工具类
 2      Country='China'
 3      def __init__(self,name,speed,load,power):
 4          self.name=name
 5          self.speed=speed
 6          self.load=load
 7          self.power=power
 8 
 9      def run(self):
10          print('开动啦...')
11 
12 class Subway(Vehicle): #地铁
13     def __init__(self,name,speed,load,power,line):
14         #super(Subway,self) 就相当于实例本身 在python3中super()等同于super(Subway,self)
15         super().__init__(name,speed,load,power)
16         self.line=line
17 
18     def run(self):
19         print('地铁%s号线欢迎您' %self.line)
20         super(Subway,self).run()
21 
22 class Mobike(Vehicle):#摩拜单车
23     pass
24 
25 line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
26 line13.run()

使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表

 1 #每个类中都继承了且重写了父类的方法
 2 class A:
 3     def __init__(self):
 4         print('A的构造方法')
 5 class B(A):
 6     def __init__(self):
 7         print('B的构造方法')
 8         super(B,self).__init__()
 9 
10 
11 class C(A):
12     def __init__(self):
13         print('C的构造方法')
14         super(C,self).__init__()
15 
16 
17 class D(B,C):
18     def __init__(self):
19         print('D的构造方法')
20         super(D,self).__init__()
21 
22 f1=D()
23 
24 print(D.__mro__) #python2中没有这个属性

super()传的第一个参数一定是自己的类名

py2

 1 #encoding:utf-8
 2 class People:
 3     def __init__(self,name,sex,age):
 4         self.name=name
 5         self.age=age
 6         self.sex=sex
 7     def walk(self):
 8         print('%s is walking' %self.name)
 9 
10 class Chinese(People):
11     country='China'
12     def __init__(self,name,sex,age,language='Chinese'):
13         super(Chinese,self).__init__(name,sex,age)  #super(子类，self)  调用的对象的绑定方法，调用的从mro列表从父类的开始找
14         self.language=language
15 
16 c=Chinese('egon','male',18)
17 print(c.name,c.age,c.sex,c.language)

py3

 1 class People:
 2     def __init__(self,name,sex,age):
 3         self.name=name
 4         self.age=age
 5         self.sex=sex
 6     def walk(self):
 7         print('%s is walking' %self.name)
 8 
 9 class Chinese(People):
10     country='China'
11     def __init__(self,name,sex,age,language='Chinese'):
12         super().__init__(name,sex,age)  #super(子类，self)  调用的对象的绑定方法，调用的从mro列表从父类的开始找
13         self.language=language
14     def walk(self,x):
15         super().walk()
16         print('子类的x',x)
17 
18 
19 egon 18 male Chinese
20 egon is walking
21 子类的x 123

三.多态

多态：(定义角度)
同一种事物的多种形态


多态性：（使用角度）
一种调用方式，不同的执行效果
依赖于：
1.继承： 都有父类的特点
2.
定义统一的接口：可以传入不同类型的值，但是调用的逻辑都一样，执行的结果却不一样
def func(obj): #obj这个参数没有类型限制，可以传入不同类型的值
    obj.run()  #调用的逻辑都一样，执行的结果却不一样

func(peo1)
func(pig1)

python自带多态，默认支持多态


好处:
1.增加了程序的灵活性
2.增加了程序额外可扩展性

 1 class Animal:
 2     def run(self):
 3         raise AttributeError('子类必须实现这个方法')
 4     def speak(self):
 5         raise AttributeError('子类必须实现这个方法')
 6 
 7 class People(Animal):
 8     def run(self):
 9         print('人正在跑')
10 
11 class Pig(Animal):
12     def run(self):
13         print('pig is running')
14 
15 peo1=People()   #创建一个人的对象
16 pig1=Pig()　　　 #创建一个猪的对象
17 
18 peo1.run()
19 pig1.run()
20 
21 def func(obj):
22     obj.run()
23 
24 func(peo1)
25 func(pig1)
26 
27 
28 人正在跑
29 pig is running
30 人正在跑
31 pig is running

四.封装

封装数据的主要原因是：保护隐私（作为男人的你，脸上就写着：我喜欢男人，你害怕么？）

封装方法的主要原因是：隔离复杂度（快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了，比如你不必知道你自己的尿是怎么流出来的，你直接掏出自己的接口就能用尿这个功能）

封装其实分为两个层面，但无论哪种层面的封装，都要对外界提供好访问你内部隐藏内容的接口（接口可以理解为入口，有了这个入口，使用者无需且不能够直接访问到内部隐藏的细节，只能走接口，并且我们可以在接口的实现上附加更多的处理逻辑，从而严格控制使用者的访问）

第一个层面的封装（什么都不用做）：创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去访问里面的名字，这本身就是一种封装

注意：对于这一层面的封装（隐藏），类名.和实例名.就是访问隐藏属性的接口

第二个层面的封装：类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问。

在python中用双下划线的方式实现隐藏属性（设置成私有的）

类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：

这种自动变形的特点：

类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

注意：对于这一层面的封装（隐藏），我们需要在类中定义一个函数（接口函数）在它内部访问被隐藏的属性，然后外部就可以使用了

也可以通过特性property来解决。

这种变形需要注意的问题是：

1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N

>>> a=A()
>>> a._A__N
>>> a._A__X
>>> A._A__N

2.变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形

3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

#正常情况
>>> class A:
...     def fa(self):
...         print('from A')
...     def test(self):
...         self.fa()
...
>>> class B(A):
...     def fa(self):
...         print('from B')
...
>>> b=B()
>>> b.test()
from B

#b.test---->B---->A b.fa()

#把fa定义成私有的，即__fa
>>> class A:
...     def __fa(self): #在定义时就变形为_A__fa
...         print('from A')
...     def test(self):
...         self.__fa() #只会与自己所在的类为准,即调用_A__fa
...
>>> class B(A):
...     def __fa(self):
...         print('from B')
...
>>> b=B()
>>> b.test()
from A

 #B-->A-->test.fa-->def __fa(self)

python并不会真的阻止你访问私有的属性，模块也遵循这种约定，如果模块名以单下划线开头，那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的

其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的，原则上是供内部调用的，作为外部的你，一意孤行也是可以用的，只不过显得稍微傻逼一点点

python要想与其他编程语言一样，严格控制属性的访问权限，只能借助内置方法如__getattr__，详见面向对象进阶

1 class A:
2     __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
3     def __init__(self):
4         self.__X=10 #变形为self._A__X
5     def __foo(self): #变形为_A__foo
6         print('from A')
7     def bar(self):
8         self.__foo() #只有在类内部才可以通过__foo的形式访问到.

 1 class A:
 2     x=1
 3     def test(self):
 4         print('from A')
 5 
 6 
 7 print(A.x)
 8 A.test(123)
 9 a=A()
10 a.y=1
11 print(a.y)
12 a.test()              #隔离复杂度
13 
14 
15 
16 1
17 from A
18 1
19 from A

只是一种变形手段，提醒自己的

#__名字，这种语法，只在定义的时候才有变形的效果，如果类或者对象已经产生了，就不会有变形效果了

 1 class A:
 2     __x=1 #_A_x
 3     def test(self):
 4         print('from A')
 5 
 6 # print(A.__x)
 7 print(A.__dict__)
 8 print(A._A__x)
 9 a=A()
10 print(a._A__x)
11 
12 
13 
14 
15 {'test': <function A.test at 0x0000000000A3E1E0>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None, '__dict__': <attribute '__dict__' of 'A' objects>, '_A__x': 1}
16 1
17 1

 1 class A:
 2     __x=1 #_A_x
 3     def __test(self):
 4         print('from A')
 5 
 6 print(A.__dict__)
 7 A._A__test(123)
 8 
 9 a=A()
10 a._A__test()
11 
12 
13 
14 {'__module__': '__main__', '__dict__': <attribute '__dict__' of 'A' objects>, '_A__x': 1, '_A__test': <function A.__test at 0x0000000000B2E1E0>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
15 from A
16 from A

原：

 1 class A:
 2     def fa(self):
 3         print('from A')
 4     def test(self):
 5         self.fa()
 6 
 7 class B(A):
 8     def fa(self):
 9         print('from B')
10 
11 b=B()
12 b.test()  #b.test---->B---->A b.fa()
13 
14 
15 
16 
17 from B

 1 class A:
 2     def __init__(self):
 3         self.__x=1
 4 a=A()
 5 print(a.__dict__)
 6 print(a._A__x)
 7 #print(a.__x)
 8 
 9 
10 
11 
12 
13 {'_A__x': 1}
14 1

在继承中，父类不想让子类覆盖自己的方法，可以将方法定义为私有的。

改：

 1 class A:
 2     def __fa(self):  #A__fa
 3         print('from A')
 4     def test(self):
 5         self.__fa()  #self._A__fa
 6 
 7 class B(A):
 8     def __fa(self):  #B__fa
 9         print('from B')
10 b=B()
11 b.test()  #B-->A-->test.fa-->def __fa(self)
12 
13 
14 
15 
16 
17 from A