多态和封装

python 天生支持多态

导引

在其他语言中

class Alipay:
    def pay(self,money):
        print('使用支付宝支付了%s元' % money)

class Appplepay:
    def pay(self,money):
        print('使用Appplepay支付了%s元' % money)

def pay(Applepay,pay_obj,int money):#其他语言里面，这里需要传一个数据类型，但是代码里面既有Alipay又有Appplepay，只能传一个。
    pay_obj.pay(money)

那么怎么做？

class Payment:pass
class Alipay(Payment):
    def pay(self,money):
        print('使用支付宝支付了%s元' % money)

class Appplepay(Payment):
    def pay(self,money):
        print('使用Appplepay支付了%s元' % money)

def pay(Payment,pay_obj,int money):#直接以Payment代替
    pay_obj.pay(money)

其中class Payment:pass，这就是多态

但是python天生支持多态，所以就不用写这些

class Alipay():
    def pay(self,money):
        print('使用支付宝支付了%s元' % money)

class Appplepay():
    def pay(self,money):
        print('使用Appplepay支付了%s元' % money)

def pay(pay_obj,money):#直接以Payment代替
    pay_obj.pay(money)

动态的定义

多态指的是一类事物有多种形态

比如动物有多种形态：人，狗，猪等

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

比如上面就是Animal类的多种形态

文件有多种形态：文本文件，可执行文件

import abc
class File(metaclass=abc.ABCMeta): #同一类事物:文件
    @abc.abstractmethod
    def click(self):
        pass

class Text(File): #文件的形态之一:文本文件
    def click(self):
        print('open file')

class ExeFile(File): #文件的形态之二:可执行文件
    def click(self):
        print('execute file')

多态性

比如上面支付的代码：可以使用payment一种方法同时实现Applepay和Alipay，这个就是多态性

class List:
    def __len__(self):pass
class Tuple:
    def __len__(self):pass

#上面两个类很相似，实现了相同的方法，所以将这种情形叫做鸭子类型

def len(l_t):#因为python是一个强动态类型的语言，如果是其他强类型语言，那么这里就必须指定是list还是tuple,不能直接写参数；为为了方便就必须在代码前面协商一个fu类型来统指代这里
    return l_t.__len__()

l=list()
len(l)

其他语言怎么操作

class Foo:pass
class List(Foo):
    def __len__(self):pass
class Tuple(Foo):
    def __len__(self):pass

#上面两个类很相似，实现了相同的方法，所以将这种情形叫做鸭子类型

def len(Foo,l_t):#这里就使用Foo类来代理
    return l_t.__len__()

l=list()
len(l)

python是一个动态强类型的语言：
不崇尚根据继承所得来的相似
只是自己实现自己的代码即可
如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型
list,tuple这种相似，是自己写代码的时候约束的，而不是通过父类约束的，也就是说，list和tuple两种数据类型的操作模式非常类似，但是彼此独立，比如删掉list中的str功能，并不影响tuple,这种关系又被称为松耦合。
优点：松耦合，每个相似的类之间都没有影响
缺点：太随意，如果

接口类和抽象类在python中的应用并不是非常必要

封装

广义上面向对象的封装：代码的保护，面向对象的思想本身就是一种
只让自己的对象能调用自己类中的方法

狭义上的封装——面向对象的三大特征之一
属性和方法都隐藏起来，不让你看见

class Person:
    def __init__(self,name,password):
        self.name=name
        self.password=password
alex=Person('alex','alex341')
print(alex.password)

假设我们不想让别人打印出密码，但是代码内部仍需要使用则

class Person:
    def __init__(self,name,password):
        self.name=name
        self.__password=password#在password前面加上__，这就能够将password私有，无法打印
alex=Person('alex','alex341')
print(alex.password)

调用字典，打印结果是这样

class Person:
    def __init__(self,name,password):
        self.name=name
        self.__password=password#在password前面加上__，这就能够将password私有，无法打印

alex=Person('alex','alex341')
print(alex.__dict__)

D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/3.二分查找算法.py
alex341
{'name': 'alex', '_Person__password': 'alex341'}

Process finished with exit code 0

那么也就是可以

class Person:
    def __init__(self,name,password):
        self.name=name
        self.__password=password#在password前面加上__，这就能够将password私有，无法打印

alex=Person('alex','alex341')
print(alex.__dict__)
print(alex._Person__password)#通过_Person__password方法调用

进一步

class Person:
    def __init__(self,name,password):
        self.name=name
        self.__password=password#在password前面加上__，这就能够将password私有，无法打印
    def get_pwd(self):
        return self.__password
alex=Person('alex','alex341')
print(alex.__dict__)
print(alex._Person__password)
print(alex.get_pwd())

#新的问题，为何明明是__password，为何生成的是_Person__password？
#因为这是在python类的内部才会这样，自动实现转换

那么如何证明只在类内部才有这个功能？

class Person:
    def __init__(self,name,password):
        self.name=name
        self.__password=password#在password前面加上__，这就能够将password私有，无法打印
    def get_pwd(self):
        print(self.__dict__)#得到的是__high而非_Person__high
        return self.__password
alex=Person('alex','alex341')

alex.__high=1
print(alex.get_pwd())

私有静态属性、私有对象、私有方法

class Person:
    __key=123#私有静态属性
    def __init__(self,name,password):
        self.name=name
        self.__password=password#私有对象
    def __get_pwd(self):#私有方法
        print(self.__dict__)#得到的是__high而非_Person__high
        return self.__password
alex=Person('alex','alex341')

alex.__high=1
print(alex.get_pwd())

当定义了私有以后，只能在类的内部调用，而不能在外部调用，那是因为发生了改变：

比如表面上是将password变为了__password，但是实际上却是变化了_Person__password，发生了变形，所以外面调不到

 封装的应用

class Room:
    def __init__(self,name,length,width):
        self.name = name
        self.__length=length#这里做了隐藏
        self.__width = width

    def area(self):
        return self.__length*self.__width

Jin=Room('金老板',2,4)
print(Jin.area())

延申

class Room:
    def __init__(self,name,length,width):
        self.__name = name
        self.__length=length#这里做了隐藏
        self.__width = width
#下面的get和set方法在c++里面很常用，python中用途较少，在实际编程过程中可以根据自己的实际情况选择合适的编程方法
    def get_name(self):
        return self.__name#因为上面已经对name进行了封装，所以必须要写这个函数，这样才能实现在外部调用name
    def set_name(self,Newname):
        if type(Newname) is str and Newname.isdigit()==False:
            self.__name=Newname
        else:
            print('名字不合法')

    def area(self):
        return self.__length*self.__width

Jin=Room('金老板',2,4)
print(Jin.area())
Jin.set_name('2')
print(Jin.get_name())

新的问题：父类的私有属性能被子类调用吗？

class Foo:
    __key='123'#这里封装以后，实际结果变为_Foo__key
class Son(Foo):
    print(Foo.__key)#而这里实际上是_Son__key，所以调不到，代码报错
#如果子类能够调用父类，那么代码执行结果就是123，但是结果显示代码报错

D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/3.二分查找算法.py
Traceback (most recent call last):
  File "F:/python/python学习/人工智能/第一阶段day2/3.二分查找算法.py", line 4, in <module>
    class Son(Foo):
  File "F:/python/python学习/人工智能/第一阶段day2/3.二分查找算法.py", line 5, in Son
    print(Foo.__key)
AttributeError: type object 'Foo' has no attribute '_Son__key'

Process finished with exit code 1

也就是再次验证，私有化以后只能在自己的类中调用，不能在类的外面，更不能在其他类中调用

会用到私有这个概念的场景：
隐藏起一个属性，不想让类的外部调用；
我想保护这个属性，不想让属性随意改变
我想保护这个属性，不被子类继承