python_14 多态，封装

多态：

由不同的类实例化得到的对象，调用同一个方法，执行的逻辑不同。

多态的概念指出了对象如何通过他们的共同的属性和动作来操作及访问，而不需考虑他们的类。

class H2O:
    def __init__(self,name,temperature):
        self.temperature=temperature
        self.name=name

    def turn(self):
        if self.temperature<0:
            print('%s  冰'%self.name)
        elif self.temperature>100:
            print('%s  水蒸气'%self.name)
        else:print('%s  水'%self.name)

class Water(H2O):
    pass

class Ice(H2O):
    pass

class Vapor(H2O):
    pass

w1=Water('水',25)
i1=Ice('冰',-25)
v1=Vapor('水蒸气',200)

def func(obj):
    obj.turn()

func(w1)
func(i1)
func(v1)

多态实际上依附于继承，多态实际上是继承的实现细节

封装

第一个层面的封装：类本身

第二个层面的封装：类中定义私有的，外部无法访问，python约定，类中单下划线开头的变量和函数外部不可访问，双下划线开头的变量或函数python会重命名，变成_类名__变量名访问

第三个层面的封装：明确区分内外，内部实现逻辑，外部无法知晓，并且为内部封装的逻辑提供一个接口给外部使用。定义接口函数，内部调用私有属性，外部调用接口函数。

面向对象的优点：

面向对象是一种高等级的结构化编程方式

1.通过封装明确内外，内部逻辑外部无需知道，想让你知道的你才能知道

2.通过继承+多态在语言层面支持归一化设计

 反射/自省 

参考：反射

下列方法使用于类和对象

hasattr(obj,name)判断object中有没有一个name字符串对应的方法或属性

getattr(obj,name,default=None)返回object中name字符串对应的方法或属性,相当于x.'y',没有则报错，可返回defalut设置值

setattr(x,y,v)在object中设置或修改一个方法或属性

delattr(x,y)在object中删除一个方法或属性

class House:
    owner='April'
    def __init__(self,name,money):
        self.name=name
        self.money=money

    def decorate(self):
        print('装修花了',self.money)

h1=House('Manuel',1000000)

print(hasattr(h1,'decorate'))
print(hasattr(h1,'owner'))

a=getattr(h1,'owner')
print(a)
b=getattr(h1,'eee','没有这个属性')
print(b)

setattr(h1,'style','北欧')
print(h1.__dict__)
c=h1.style
print(c)

setattr(h1,'owner','Manuel')
print(h1.owner)

print('~~~~~~~~~~~~~')
delattr(h1,'owner')
print(h1.__dict__)

反射/自省的作用：

不影响前人编写代码的情况下，写自己的逻辑

动态导入模块:

若导入模块为字符串，利用__import__('a.b.c')方法,调用的是最顶级的模块，如需导入c模块中的c1函数，

i=__import__('a.b.c')
i.b.c.c1()

或：

与上述方法的区别是直接导入了a.b.c模块

import importlib

m=importlib.import_module('a.b.c')

1