走入计算机的第三十天（继承实现原理和封装）

一 继承的实现原理

1 继承的实现顺序

从左到有依次查找，     每一个分支查找完了才进行下一个分支的查找

在新式类中每个分支属于同一个父类的时候查找的顺序是如下

这种属于广度优先，就是在新式类中，查找从左到右每个分支依次查找完毕过后，最后在查找他们共同的父类。

在经典类中每个分支属于同一个父类的时候查找的顺序是如下

这种属于深度查找，就是在经典类中，从左到右，每个分支查找到底，在进行下一个分支的查找，但是在他们共同父类第一次查找过后，就不会在查找他们共同的父类了。

 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
30 #经典类继承顺序:F->D->B->A->E->C
31 #python3中统一都是新式类
32 #pyhon2中才分新式类与经典类

2 继承原理（python如何实现的继承）

python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如

>>> F.mro() #等同于F.__mro__
[<class ‘__main__.F‘>, <class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.E‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>]

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

二 子类调用父类的方法

子类继承了父类的方法，然后想进行修改，注意了是基于原有的基础上修改，那么就需要在子类中调用父类的方法

方法一：父类名.父类方法()

 1 # class People:
 2 #     def __init__(self,name,age,sex):
 3 #         self.name=name
 4 #         self.age=age
 5 #         self.sex=sex
 6 #     def foo(self):
 7 #         print(‘from your‘)
 8 # class Teacher(People):
 9 #     def __init__(self,name,age,sex,level,salary):
10 #         People.__init__(self,name,age,sex)   #指名道姓的调用People类的__init__的函数
11 #         self.level=level
12 #         self.salary=salary
13 #     def foo(self):
14 #         print(‘from sb‘)
15 # t1=Teacher(‘egon‘,81,‘girl‘,-10,3000)
16 # t1.foo()

方法二：super()

 1 # class People:
 2 #     def __init__(self,name,age,sex):
 3 #         self.name=name
 4 #         self.age=age
 5 #         self.sex=sex
 6 #     def foo(self):
 7 #         print(‘from your‘)
 8 # class Teacher(People):
 9 #     def __init__(self,name,age,sex,level,salary):
10 #         super().__init__(name,age,sex)   #调用的是父类__init__的功能，实际上是调用父类的绑定方法
11 #         self.level=level
12 #         self.salary=salary
13 #     def foo(self):
14 #         super().foo()
15 #         print(‘from sb‘)
16 # t1=Teacher(‘egon‘,81,‘girl‘,-10,3000)
17 # t1.foo()

当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次（注意注意注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表）

在python中使用super()时括号里需要加上类名和自己，如下

 1 #python2中super()的使用方法是
 2 # class People:
 3 #     def __init__(self,name,age,sex):
 4 #         self.name=name
 5 #         self.age=age
 6 #         self.sex=sex
 7 #     def foo(self):
 8 #         print(‘from your‘)
 9 # class Teacher(People):
10 #     def __init__(self,name,age,sex,level,salary):
11 #         super(Teacher.srlf).__init__(name,age,sex)   #调用的是父类__init__的功能，实际上是调用父类的绑定方法
12 #         self.level=level
13 #         self.salary=salary
14 #     def foo(self):
15 #         super(Teacher.self).foo()
16 #         print(‘from sb‘)
17 # t1=Teacher(‘egon‘,81,‘girl‘,-10,3000)
18 # t1.foo()

三 封装

1 什么是封装：将一些东西装起来，然后再给封闭住，不然别人看见。

2 封装的内容：数据的封装和功能的封装。

封装数据是为了将自己的隐私给隐藏起来。

功能的封装只需要给别人提供一个接口即可。

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

4封装的两个层面

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

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

 1 class Teacher(People):
 2     def __init__(self,name,age,sex,level,salary):
 3         self.name=name
 4         self.age=age
 5         self.sex=sex
 6         self.level=level
 7         self.salary=salary
 8     def foo(self):
 9         print(‘from sb‘)
10 t1=Teacher(‘egon‘,81,‘girl‘,-10,3000)
11 t1.foo()
12
13
14
15 #foo()就是这种封装

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

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

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

 1 # class People:
 2 #     __school=‘oldboy‘
 3 #     def __init__(self,name,age,sex):
 4 #         self.name=name
 5 #         self.__age=age
 6 #         self.__sex=sex
 7 #     def __foo(self):
 8 #         print(‘from your‘)
 9 #
10 # t1=People(‘egon‘,81,‘girl‘)
11 # # print(t1._People__age)
12 # t1._People__foo()

 1 class Teacher:
 2     __school="oldboy"    #_Teacher__school
 3     def __init__(self,name,salary):
 4         self.name=name
 5         self.__salary=salary   # _Teacher__salary
 6     def foo(self):              #_Teacher__foo
 7         print("====>",self.__salary)
 8         #调用时已经变成   print("====>",self._Teacher__salary)
 9 t=Teacher(‘egon‘,30000)
10 print(t.foo())

这种自动变形的特点：

1.类中定义的只能在内部使用，如self.__salary，引用的就是变形的结果。

2.这种变形其实正是针对外部的变形，在外部是无法通过__salary这个名字访问到的。

2.在子类定义的__salary不会覆盖在父类定义的__salary，因为子类中变形成了：_子类名__salary,而父类中变形成了：_父类名__salary，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

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

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

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

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

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

 1 #正常情况
 2 >>> class A:
 3 ...     def fa(self):
 4 ...         print(‘from A‘)
 5 ...     def test(self):
 6 ...         self.fa()
 7 ...
 8 >>> class B(A):
 9 ...     def fa(self):
10 ...         print(‘from B‘)
11 ...
12 >>> b=B()
13 >>> b.test()
14 from B

 1 #把fa定义成私有的，即__fa
 2 >>> class A:
 3 ...     def __fa(self): #在定义时就变形为_A__fa
 4 ...         print(‘from A‘)
 5 ...     def test(self):
 6 ...         self.__fa() #只会与自己所在的类为准,即调用_A__fa
 7 ...
 8 >>> class B(A):
 9 ...     def __fa(self):
10 ...         print(‘from B‘)
11 ...
12 >>> b=B()
13 >>> b.test()
14 from A

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

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

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

5 特性（propert）

什么事特性：property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

例

 1 # class People:
 2 #     def __init__(self,name,age,sex,height,weight):
 3 #         self.__name=name
 4 #         self.__age=age
 5 #         self.__sex=sex
 6 #         self.__height=height
 7 #         self.__weight=weight
 8 #     @property   #bmi=property(bmi)
 9 #     def bmi(self):
10 #         res=self.__weight / (self.__height ** 2 )
11 #         print(‘name %s bmi %s‘%(self.__name,res))
12
13 #
14 # egon=People(‘egon‘,18,‘male‘,1.79,70)
15 # egon.bmi

当property函数装饰后，返回的结果是一个数据数学，property函数装饰后，还可以有增删改的作用，调用就可以使用例二

 1 # class People:
 2 #     def __init__(self,name,age,sex,height,weight):
 3 #         self.__name=name
 4 #         self.__age=age
 5 #         self.__sex=sex
 6 #         self.__height=height
 7 #         self.__weight=weight
 8 #     @property   #name=property(name)
 9 #     def name(self):
10 #         print(self.__name)
11 #     # @name.setter
12 #     # def name(self,val):
13 #     #         self.__name=val
14 #
15 #     @name.deleter
16 #     def name(self):
17 #         raise PermissionError(‘不让删‘)
18 #
19 # egon=People(‘egon‘,18,‘male‘,1.79,70)
20 # egon.name                #egon
21 #
22 # del egon.name
23 #

为什么要用property：将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则