一、多态与多态性
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','18') 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伪装成数据属性
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