day26

python 面向对象的多态性，可以多种形态去执行，基础是基类

#python 内置的函数中，len() 等同于 object.__len__()

l = 'bbs'
len(l)
l.__len__()

输出结果：
3
3

自定义函数实现

class test:
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def run(self):
        print('name is %s, gender is %s' %(self.name, self.gender))

def run_fun(obj):
    obj.run()

t = test('libai', 'none')
t.run()
run_fun(t)

输出结果：
name is libai, gender is none
name is libai, gender is none

用字典的方式调用函数

def Add(x,y):
    return x+y
def Multiply(x,y):
    return (x*y)
def check(x):
    try:
        int(x)
        return True
    except:
        return False

#用字典的方式调用函数
mute = {
    1:Add,
    2:Multiply
}
symbol = {
    1:'+',
    2:'*'
}
def input_check(b): #检测输入是否合法
    while(True):
        x = input('%s::' %b)
        x_check = check(x)
        if x_check:
            return int(x)
        else:
            print('please input again')

def main():
    print("please input x and y")
    while(True):
        x = input_check('x')
        y = input_check('y')
        print('you input x = %d, y = %d' %(x,y))
        print('1::add\n2::multiply\n')
        while(True):
            choice = input_check('choice')
            if choice==1 or choice == 2:
                break
            else:
                print('please input again')
        print('Calcluate..................')
        end = mute[choice](x,y)
        print('%d %s %d = %d' %(x, symbol[choice], y, end))
        gets = input("you want to continue(Yes Contiue):")
        if gets.lower() != 'yes': #忽略yes的大小写
            break

if __name__ == '__main__':
    main()

封装，python 没有定义完全意义上的封装
第一个层面的封装：类就是麻袋，这本身就是一种封装
第二个层面的封装：类中定义私有的，只在类的内部使用，外部无法访问
第三个层面的封装：明确区分内外，内部的实现逻辑，外部无法知晓，并且为封装到内部的逻辑提供一个访问接口给外部使用（这才是真正的封装）

不同的对象调用相同的方法，执行的逻辑并不一样

类的继承有两层意义，1.改变，2，扩展
多态就是类的这两层意义的一个具体的实现机制
即，调用不同的类实例化的对象下的相同方法，实现的过程不一样

python 中的标准类型就多态概念的一个很好的示范

class test:
    __start = 55
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def run(self):
        print('name is %s, gender is %s' %(self.name, self.gender))

t = test('libai', 'none')
print(test.__dict__)
print(t.__dict__)
print(t._test__start) #外部可以访问内部的隐藏属性

输出结果：
{'__module__': '__main__', '_test__start': 55, '__init__': <function test.__init__ at 0x00000247925B4620>, 'run': <function test.run at 0x00000247925B46A8>, '__dict__': <attribute '__dict__' of 'test' objects>, '__weakref__': <attribute '__weakref__' of 'test' objects>, '__doc__': None}
{'name': 'libai', 'gender': 'none'}
55

设定封装的外部接口

class test:
    __start = 55
    def __init__(self, name, gender):
        self.__name = name  #封装
        self.gender = gender
    def run(self):
        print('name is %s, gender is %s' %(self.name, self.gender))
    def get_start(self):  #外部访问内部封装变量的接口
        return self.__start #内部访问隐藏变量不受影响
t = test('libai', 'none')
print(test.__dict__)
print(t._test__start)  #外部可以通过添加类名访问
print(t.__dict__)
print(t._test__name)  #添加类名访问
print(t.get_start())

输出结果：
{'__module__': '__main__', '_test__start': 55, '__init__': <function test.__init__ at 0x00000218E5FE4620>, 'run': <function test.run at 0x00000218E5FE46A8>, 'get_start': <function test.get_start at 0x00000218E5FE4730>, '__dict__': <attribute '__dict__' of 'test' objects>, '__weakref__': <attribute '__weakref__' of 'test' objects>, '__doc__': None}
55
{'_test__name': 'libai', 'gender': 'none'}
libai
55