一、多态与多态性
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拓展