面向对象（三）--多态、封装、property装饰器

一、多态与多态性

1、什么是多态

多态指的是同一种类/事物的不同形态

class Animal:
    def speak(self):
        pass
 
class People(Animal):
    def speak(self):
        print('say hello')
 
class Dog(Animal):
    def speak(self):
        print('汪汪汪')
 
class Pig(Animal):
    def speak(self):
        print('哼哼哼')

多态

2、抽象类

只是用来建立规范的,不能用来实例化的,更无需实现内部的方法

import abc
 
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def speak(self):
        pass
 
    @abc.abstractmethod
    def run(self):
        pass
 
class People(Animal):
    def speak(self):
        print('say hello')
 
    def run(self):
        pass
 
class Dog(Animal):
    def speak(self):
        print('汪汪汪')
 
    def run(self):
        pass
 
class Pig(Animal):
    def speak(self):
        print('哼哼哼')
 
    def run(self):
        pass
 
obj1=People()
obj2=Dog()
obj3=Pig()

抽象类

• 鸭子类型

python不推崇强制的继承关系，而崇尚的是鸭子类型，叫声像鸭子，走路也像鸭子，那它就是鸭子。

只要约定俗成的建立统一的一套标准/规范就行，就像Linux中有一种观点就是一切皆文件！

例如，如果想编写现有对象的自定义版本，可以继承该对象

也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。

例1：利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass
 
    def write(self):
        pass
 
class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

例2：其实我们一直在享受着多态性带来的好处，比如Python的序列类型有多种形态：字符串，列表，元组，多态性体现如下

#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))
 
#我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()
 
len(s)
len(l)
len(t)

二、封装

1、什么是封装

装:往容器/名称空间里存入名字
封:代表将存放于名称空间中的名字给藏起来,这种隐藏对外不对内

2、怎么封装

封装的方法是在属性前加上__（双下划线）

（1）在类内定义的属性前加__开头(没有__结果)

（2）__开头的属性实现的隐藏仅仅只是一种语法意义上的变形，并不会真的限制类外部的访问，外部可以调用类内的接口来操作属性

（3）该变形操作只在类定义阶段检测语法时发生一次,类定义阶段之后新增的__开头的属性并不会变形

1 class Foo:
 2     __x=111         # _Foo__x    在定义的时候已经将__x改为_Foo__x
 3     __y=222         # _Foo__y    在定义的时候就将__y改成_Foo__y
 4
 5     def __init__(self,name,age):
 6         self.__name=name     # 函数再定义的时候添加属性，可以被封装
 7         self.__age=age
 8
 9     def __func(self):     # 在定义的时候已经将__func改为_Foo__func
10         print('func')
11
12     def get_info(self):
13         print(self.__name,self.__age,self.__x)  # 内部可以访问封装的属性
14
15 print(self._Foo__name,self._Foo__age,self._Foo__x)
16
17 print(Foo.__x)     # 报错  无法直接访问封装的属性
18
19 print(Foo.__dict__)
20
21 print(Foo._Foo__x)    # 111 封装只是在属性前面加了“_类名”，可以访问封装的属性
22
23 Foo.__z=333
24
25 print(Foo.__z)    # 333 后期添加的属性不会被封装，封装只发生在类定义的阶段

3、封装数据属性

（1）将数据属性隐藏起来，类外就无法直接操作属性

（2）需要类内开辟一个接口来外部的使用可以间接地操作属性，可以在接口内定义任意的控制逻辑，从而严格控制使用对属性的操作

class People:
    def __init__(self,name,age):
        self.__name=name
        self.__age=age
 
    def tell_info(self):   #接口用来访问封装的数据属性
        print('<name:%s age:%s>'  %(self.__name,self.__age))
 
    def set_info(self,name,age):  # 接口用来修改封装的数据属性的值
        if type(name) is not str:
            print('名字必须是str类型')
            return
        if type(age) is not int:
            print('年龄必须是int类型')
            return
        self.__name=name
        self.__age=age
 
obj=People('egon',18)
# obj.tell_info()
 
# obj.set_info('EGON',19)
# obj.set_info(123,19)
obj.set_info('EGON','')
obj.tell_info()

封装的数据属性

4、封装函数属性

class ATM:
    def __card(self):
        print('插卡')
    def __auth(self):
        print('用户认证')
    def __input(self):
        print('输入取款金额')
    def __print_bill(self):
        print('打印账单')
    def __take_money(self):
        print('取款')
 
    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()
 
a=ATM()
a.withdraw()

封装函数属性

三、property装饰器

property装饰器是用来将类内的函数属性伪装成数据属性

class People:
    def __init__(self, weight, height):
        self.weight = weight
        self.height = height
 
    @property       # property装饰器
    def bmi(self):
        return self.weight / (self.height ** 2)
 
obj = People(70, 1.75)
 
print(obj.bmi)   # bmi被property伪装成数据属性

property装饰器

class People:
    def __init__(self,name):
        self.__name=name
 
    @property
    def name(self):
        return '<名字:%s>' %self.__name
 
    @name.setter
    def name(self,obj):
        if type(obj) is not str:
            print('name必须为str类型')
            return
        self.__name=obj
 
    @name.deleter
    def name(self):
        # print('不让删')
        del self.__name
 
obj=People('egon')
 
print(obj.name)        # egon
obj.name='EGON'
#obj.name=123
print(obj.name)    # EGON

property拓展