day 25-1 接口类、抽象类、多态

# 接口类:python 原生不支持
# 抽象类:python 原生支持的

接口类

首先我们来看一个支付接口的简单例子

from abc import abstractmethod,ABCMeta #我们也可以创建一个规范类
class Payment(metaclass=ABCMeta): # 元类 默认的元类 type
@abstractmethod
def pay(self,money):
raise Notlmplemented #规范类要求需要实现一个 叫做 pay 的方法
#这样在不调用的情况下 就会抛出错误 在实例化时就可以发现这个问题 # 规范 :接口类或者抽象类都可以
# 接口类 支持多继承,接口类中的所有的方法都必须不能实现 —— java
# 抽象类 不支持多继承,抽象类中方法可以有一些代码的实现 —— java class Payment:
def pay(self,money): #2.没有实现该方法,就会抛出这个异常,用来隐藏 1 处的错误
raise Notlmplemented #原理就是 如果不实现 pay 方法 就会抛出这个报错
#报错如下
#NameError: name 'Notlmplemented' is not defined class Weipay(Payment):
def pay(self,money):
print('微信支付了%s元'%money) class Alipay(Payment):
def pay(self,money):
print('支付宝支付了%s元'%money) class Apppay(Payment):
def pays(self,money): #1.如果这里的 pay 换成了其他名字就会报错 与下面的 pay 函数冲突了
print('苹果支付了%s元'%money)
wei = Weipay()
ali = Alipay()
app = Apppay() def pay(pay_obj,money):
pay_obj.pay(money) pay(wei,100)
pay(ali,100)
pay(app,100)
#weipay.pay(100)
#alipay.pay(100)

接口类的多继承

这是三种动物
tiger      走路  游泳
swan     走路  游泳 飞
oldying  走路  飞

为了避免代码重复,我们写以下三个类
下面就是实现了 接口类的规范 不需要有功能实现的代码

#下面就是实现了 接口类的规范 不需要有功能实现的代码
from abc import abstractmethod,ABCMeta
class Swim_Animal(metaclass=ABCMeta):
@abstractmethod
def swim(self):pass class Walk_Animal(metaclass=ABCMeta):
@abstractmethod
def walk(self):pass class Fly_Animal(metaclass=ABCMeta):
@abstractmethod
def fly(self):pass #继承了类里面的相应的方法就必须要写
class Tiger(Walk_Animal,Swim_Animal):
def walk(self):
pass
def swim(self):
pass
class OldYing(Fly_Animal,Walk_Animal):pass
class Swan(Swim_Animal,Walk_Animal,Fly_Animal):pass # 这样就完了 接口类 刚好满足接口隔离原则 面向对象开发的思想 规范

python 中没有接口类 这个只是类似,就是说 我要实现不同的功能,我就去继承不同的接口,来规范我当前类中要用那些函数

好了我们接下来稍稍完善下上满的例子

from abc import abstractmethod,ABCMeta
class Swim_Animal(metaclass=ABCMeta):
@abstractmethod
def swim(self):pass class Walk_Animal(metaclass=ABCMeta):
@abstractmethod
def walk(self):pass class Fly_Animal(metaclass=ABCMeta):
@abstractmethod
def fly(self):pass class Tiger(Walk_Animal,Swim_Animal):
def walk(self,num):
print('狮子跑了 %s 公里'%num)
def swim(self,num):
print('狮子游了 %s 公里'%num) class OldYing(Fly_Animal,Walk_Animal):
def fly(self,num):
print('老鹰飞了 %s 公里'%num)
def walk(self,num):
print('老鹰跑了 %s 公里'%num) class Swan(Swim_Animal,Walk_Animal,Fly_Animal):
def fly(self,num):
print('天鹅飞了 %s 公里'%num)
def walk(self,num):
print('天鹅跑了 %s 公里'%num)
def swim(self,num):
print('天鹅游了 %s 公里'%num) T = Tiger()
o = OldYing()
s = Swan()
#s.fly(5) def action(action_obj,num):
action_obj(num) action(s.fly,5)

抽象类

如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类就是从一堆类中抽取相同的内容而来的,内容包括数据属性和函数属性
在 python 中实现抽象类,抽象类一般是单继承
操作系统一切皆文件

我们来实现一个抽象类

import abc #利用 abc 模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
all_type='file'
@abc.abstractmethod #定义抽象方法,无需实现功能
def read(self):
'子类必须定义读功能'
with open('filaname') as f:
pass @abc.abstractmethod #定义抽象方法,无需实现功能
def write(self):
'子类必须定义写功能'
pass class Txt(All_file): #子类继承抽象类,但是必须定义read和write方法
def read(self):
print('文本数据的读取方法')
def write(self):
print('文本数据的读取方法') class Sata(All_file): #子类继承抽象类,但是必须定义read和write方法
def read(self):
print('硬盘数据的读取方法') def write(self):
print('硬盘数据的读取方法') class Process(All_file): #子类继承抽象类,但是必须定义read和write方法
def read(self):
print('进程数据的读取方法') def write(self):
print('进程数据的读取方法') wenbenwenjian=Txt() yingpanwenjian=Sata() jinchengwenjian=Process() #这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read() print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

抽象类 : 规范
一般情况下 单继承 能实现的功能都是一样的,所以在父类中可以有一些简单的基础实现
多继承的情况 由于功能比较复杂,所以不容易抽象出相同的功能的具体实现写在父类中

抽象类还是接口类 : 面向对象的开发规范 所有的接口类和抽象类都不能实例化

java:
java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题
但对于多继承的需求,由于java本身语法的不支持,所以创建了接口Interface这个概念
来解决多继承的规范问题

python:
python中没有接口类 :
python中自带多继承 所以我们直接用class来实现了接口类
python中支持抽象类 : 一般情况下 单继承 不能实例化(接口类抽象类)
且可以实现python代码

多态

python 天生支持多态,python 是动态强类型的语言

多态指的是一类事物有多种形态
动物有多种形态:人,狗,猪

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') People().talk()

文件有多种形态:文本文件,可执行文件

多态性
什么是多态动态绑定(在继承的背景下使用时,有时也称为多态性)
多态性是指在不考虑实例类型的情况下使用实例

在面向对象方法中一般是这样表述多态性:
向不同的对象发送同一条消息( !!!obj.func():是调用了obj的方法func,又称为向 obj 发送了一条消息 func ),不同的对象在接收时会产生不同的行为(即方法)。 也就是说,每个对象可以用自己的方式去响应共同的消息。所谓消息,就是调用函数,不同的行为就是指不同的实现,即执行不同的函数。 比如:老师.下课铃响了(),学生.下课铃响了(),老师执行的是下班操作,学生执行的是放学操作,虽然二者消息一样,但是执行的效果不同

鸭子类型

# 鸭子类型
# list tuple 如果说两个类型为鸭子类型 就是说这两个类型很相识
# 不崇尚根据继承所得来的相似
# 我只是自己实现我自己的代码就可以了。
# 如果两个类刚好相似,并不产生父类的子类的兄弟关系,而是鸭子类型
# list tuple 这种相似,是自己写代码的时候约束的,而不是通过父类约束的
# 优点:松耦合 每个相似的类之间都没有影响
# 缺点:太随意了,只能靠自觉

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

封装

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

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

class Person:
__key = 123 # 私有静态属性
def __init__(self,name,passwd):
self.name = name
#self.passwd = passwd
self.__passwd = passwd #当属性前面加上 __ 就成为了私有属性 def get_pwd(self): #在类的内部使用方法调用 __passwd 属性
print(self.__dict__)
return self.__passwd #只要在类的内部使用私有属性,就会自动的带上_类名 def __login(self): #私有方法
self.__get.pwd() per = Person('ysg','')
#print(alex.passwd)
#print(per.__passwd) #然后就找不到该属性了
print(per.__dict__) #这里还是可以看到 所有私有属性并不是约束数据安全的只是在代码级别加了一层密
print(per._Person__passwd) # _类名__属性名 这样调用就可以了 不过不应该去调取
print(per.get_pwd()) print(per.__login) #调取不到
#定义类的私有属性 只能在类的内部 外部就不可以
per.__high = 1
print(per.__high) #外部就可以直接使用

所有的私有 都是在变量的左边加上双下划线
  对象的私有属性
  类中的私有方法
  类中的静态私有属性
所有的私有的 都不能在类的外部使用

封装之隐藏

如何隐藏:在 python 中用双下划线开头的方式将属性隐藏起来(设置成私有的)

class A:
__x = 1 def __init__(self, name):
self.name = name def __foo(self):
print('this is foo') #print(A.__x)
# AttributeError: type object 'A' has no attribute '__x'
a = A('ysg')
print(a.name) # ysg
#print(A.__foo) #AttributeError: type object 'A' has no attribute '__foo' # 我们来查看下 class A 的属性
# 可以看到并没有 __x、__foo 的属性,但有了 _A__x、_A__foo 的属性
print(A.__dict__) #{'__module__': '__main__', '_A__x': 1, '__init__': <function A.__init__ at 0x000001D63A0602F0>, '_A__foo': <function A.__foo at 0x000001D63A0BB268>,,...}

如上,我们可以大胆的猜测一下,当我们使用双下划线隐藏后,它可能做了某种变形,我们来尝试下

print(A._A__x)      # 1
print(A._A__foo) # <function A.__foo at 0x000001D26E09D1E0>

可以看出,的确是做了变形的处理

接下来看下它有哪些特点:

  1. 类中定义的 __x 只能在内部使用,如 self.__x,引用的就是变形的结果
  2. 这种变形其实正是针对外部的变形,在外部无法通过 __x 这个名字访问到
  3. 在子类定义的 __x 不会覆盖在父类定义的 __x,因为子类中变形成了:_子类名__x,而父类中变形成了:_父类名__x,即双下滑线开头的属性在继承给子类时,子类是无法覆盖的

这种变形需要注意的问题是:

  1. 这种机制也并没有真正意义上限制我们从外部直接访问属性,知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,如a._A__N
  2. 变形的过程只在类的定义是发生一次,在定义后的赋值操作,不会变形
  3. 在继承中,父类如果不想让子类覆盖自己的方法,可以将方法定义为私有的

我们用一个例子来验证下

class B:
def __foo(self):
print('B.foo') def bar(self):
print('B.bar')
self.__foo() class C(B):
def __foo(self):
print('C.foo') c = C()
c.bar() # 结果:
B.bar
B.foo

封装不是单纯意义的隐藏

1.封装数据属性:明确区分内外,控制外部对隐藏属性的操作

将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口,然后我们可以在接口附加上对该数据操作的限制,以此完成对数据属性操作的严格控制

我们来写一个例子

class People:
def __init__(self, name, age):
self.__name = name
self.__age = age def tell_info(self):
print('Name:<%s>\nAge:<%s>' % (self.__name, self.__age)) def set_info(self, name, age):
if not isinstance(name, str):
print('名字必须是字符串类型')
return
if not isinstance(age, int):
print('年龄必须是 int 类型')
return
self.__name = name
self.__age = age p = People('ysg', 16)
p.tell_info()
# Name:<ysg>
# Age:<16> p.set_info(123, 18) # 名字必须是字符串类型
p.tell_info()
p.set_info('er', '18') # 年龄必须是 int 类型
p.tell_info()
# Name:<ysg>
# Age:<16> p.set_info('er', 18)
p.tell_info()
# Name:<er>
# Age:<18>

上面可以看到:

tell_inso() 实现了在不能直接查看属性时,开一个接口且按照一定的规格进行查看属性

set_info() 实现了在不能直接修改属性时,开一个接口且对传来的属性进行判断,通过则进行修改

2.封装方法:隔离复杂度

我们来看下面的例子

1.取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
2.对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
3.隔离了复杂度,同时也提升了安全性
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()

注意:在编程语言里,对外提供的接口(接口可理解为了一个入口),可以是函数,称为接口函数,这与接口的概念还不一样,接口代表一组接口函数的集合体

封装与可扩展性

封装在于明确区分内外,使得类实现者可以修改封装内的东西而不影响外部调用者的代码;而外部使用用者只知道一个接口(函数),只要接口(函数)名、参数不变,使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说,只要接口这个基础约定不变,则代码改变不足为虑

class Room:
def __init__(self,name,owner,weight,length,height):
self.name=name
self.owner=owner # 这里访问者其实是要结果,值可以隐藏起来
self.__weight=weight
self.__length=length
self.__height=height #在这里改变运算规则
def tell_area(self):
return self.__weight * self.__length * self.__height r=Room('卫生间','alex',10,10,10) # print(r.tell_area()) #用户调用方式不变
print(r.tell_area())

达到了:对外提供的接口中,隐藏了内部的实现细节;扩展了功能,但不需要改变调用的方法

上一篇:Rabbitmq(5) 路由模式


下一篇:131.007 Unsupervised Learning - Feature Selection | 非监督学习 - 特征选择