面向对象编程（三）

一.继承顺序

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中才分新式类与经典类

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    一条路走，走完走另一条路，最后走A
#经典类继承顺序:F->D->B->A->E->C    一条路走，中间走尖，回到起始，再走另一条路    
#python3中统一都是新式类
#pyhon2中才分新式类与经典类    

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

class M(A):
    # def test(self):
    #     print('from M')
    pass
class N(A):
    def test(self):
        print('from N')
class B(M):
    # def test(self):
    #     print('from B')
    pass
class C(N):
    def test(self):
        print('from C')


class E(C):
    def test(self):
        print('from E')
class D(B):
    # def test(self):
    #     print('from D')
    pass

class F(D,E):
    # def test(self):
    #      print('from F')
    pass


f1=F()
f1.test()
print(F.mro())   #只有新式才有这个属性可以查看线性列表，经典类没有这个属性




[<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.父类名.父类方法（）

#_*_coding:utf-8_*_
__author__ = 'jj'

class Vehicle: #定义交通工具类
     Country='China'
     def __init__(self,name,speed,load,power):
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power

     def run(self):
         print('开动啦...')

class Subway(Vehicle): #地铁
    def __init__(self,name,speed,load,power,line):
        Vehicle.__init__(self,name,speed,load,power)
        self.line=line

    def run(self):
        print('地铁%s号线欢迎您' %self.line)
        Vehicle.run(self)

line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()

2.super()

class Vehicle: #定义交通工具类
     Country='China'
     def __init__(self,name,speed,load,power):
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power

     def run(self):
         print('开动啦...')

class Subway(Vehicle): #地铁
    def __init__(self,name,speed,load,power,line):
        #super(Subway,self) 就相当于实例本身 在python3中super()等同于super(Subway,self)
        super().__init__(name,speed,load,power)
        self.line=line

    def run(self):
        print('地铁%s号线欢迎您' %self.line)
        super(Subway,self).run()

class Mobike(Vehicle):#摩拜单车
    pass

line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()

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

#每个类中都继承了且重写了父类的方法
class A:
    def __init__(self):
        print('A的构造方法')
class B(A):
    def __init__(self):
        print('B的构造方法')
        super(B,self).__init__()


class C(A):
    def __init__(self):
        print('C的构造方法')
        super(C,self).__init__()


class D(B,C):
    def __init__(self):
        print('D的构造方法')
        super(D,self).__init__()

f1=D()

print(D.__mro__) #python2中没有这个属性

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

py2

#encoding:utf-8
class People:
    def __init__(self,name,sex,age):
        self.name=name
        self.age=age
        self.sex=sex
    def walk(self):
        print('%s is walking' %self.name)

class Chinese(People):
    country='China'
    def __init__(self,name,sex,age,language='Chinese'):
        super(Chinese,self).__init__(name,sex,age)  #super(子类，self)  调用的对象的绑定方法，调用的从mro列表从父类的开始找
        self.language=language

c=Chinese('egon','male',18)
print(c.name,c.age,c.sex,c.language)

py3

class People:
    def __init__(self,name,sex,age):
        self.name=name
        self.age=age
        self.sex=sex
    def walk(self):
        print('%s is walking' %self.name)

class Chinese(People):
    country='China'
    def __init__(self,name,sex,age,language='Chinese'):
        super().__init__(name,sex,age)  #super(子类，self)  调用的对象的绑定方法，调用的从mro列表从父类的开始找
        self.language=language
    def walk(self,x):
        super().walk()
        print('子类的x',x)


egon 18 male Chinese
egon is walking
子类的x 123

三.多态

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


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

func(peo1)
func(pig1)

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


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

class Animal:
    def run(self):
        raise AttributeError('子类必须实现这个方法')
    def speak(self):
        raise AttributeError('子类必须实现这个方法')

class People(Animal):
    def run(self):
        print('人正在跑')

class Pig(Animal):
    def run(self):
        print('pig is running')

peo1=People()   #创建一个人的对象
pig1=Pig()　　　 #创建一个猪的对象

peo1.run()
pig1.run()

def func(obj):
    obj.run()

func(peo1)
func(pig1)


人正在跑
pig is running
人正在跑
pig is running

四.封装

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

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

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

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

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

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

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

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

这种自动变形的特点：

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

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

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

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

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

1 2 3 4

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#正常情况 >>> 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()

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#把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__，详见面向对象进阶

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

class A:
    x=1
    def test(self):
        print('from A')


print(A.x)
A.test(123)
a=A()
a.y=1
print(a.y)
a.test()              #隔离复杂度



1
from A
1
from A

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

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

class A:
    __x=1 #_A_x
    def test(self):
        print('from A')

# print(A.__x)
print(A.__dict__)
print(A._A__x)
a=A()
print(a._A__x)




{'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}
1
1

class A:
    __x=1 #_A_x
    def __test(self):
        print('from A')

print(A.__dict__)
A._A__test(123)

a=A()
a._A__test()



{'__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}
from A
from A

 原：

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()  #b.test---->B---->A b.fa()




from B

class A:
    def __init__(self):
        self.__x=1
a=A()
print(a.__dict__)
print(a._A__x)
#print(a.__x)





{'_A__x': 1}
1

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

改：

class A:
    def __fa(self):  #A__fa
        print('from A')
    def test(self):
        self.__fa()  #self._A__fa

class B(A):
    def __fa(self):  #B__fa
        print('from B')
b=B()
b.test()  #B-->A-->test.fa-->def __fa(self)





from A