python_day21_面向对象编程3详解编程语言

支付功能的例子 
    支付宝支付 
    qq支付 
    apply_pay 
    微信支付 
 
class Alipay: 
    ''' 
    支付宝支付 
    ''' 
    def pay(self,money): 
        print('支付宝支付了%s元'%money) 
 
class Applepay: 
    ''' 
    apple pay支付 
    ''' 
    def pay(self,money): 
        print('apple pay支付了%s元'%money) 
 
class Wechatpay: 
    def fuqian(self,money): 
        ''' 
        实现了pay的功能，但是名字不一样 
        ''' 
        print('微信支付了%s元'%money) 
 
def pay(payment,money): 
    ''' 
    支付函数，总体负责支付 
    对应支付的对象和要支付的金额 
    ''' 
    payment.pay(money) 
 
p = Wechatpay() 
pay(p,200)    
 
#执行会报错 
AttributeError: 'Wechatpay' object has no attribute 'pay' 
 
使用ABC模块创建一个规范 
from abc import ABCMeta,abstractmethod 
class Payment(metaclass=ABCMeta):    # 抽象类 接口类  规范和约束  metaclass指定的是一个元类 
    @abstractmethod 
    def pay(self):pass  # 抽象方法 
 
class Alipay(Payment): 
    def pay(self,money): 
        print('使用支付宝支付了%s元'%money) 
 
class QQpay(Payment): 
    def pay(self,money): 
        print('使用qq支付了%s元'%money) 
 
class Wechatpay(Payment): 
    def pay(self,money): 
        print('使用微信支付了%s元'%money) 
    def recharge(self):pass 
 
def pay(a,money): 
    a.pay(money)    # 归一化设计：不管是哪一个类的对象，都调用同一个函数去完成相似的功能 
 
a = Alipay() 
a.pay(100) 
pay(a,100)     
q = QQpay() 
# q.pay(100) 
pay(q,100) 
w = Wechatpay() 
pay(w,100)  

例：在python中实现抽象类  
 
# 模拟linux一切皆文件 
 
import abc #利用abc模块实现抽象类 
 
class All_file(metaclass=abc.ABCMeta): 
    all_type='file' 
    @abc.abstractmethod #定义抽象方法，无需实现功能 
    def read(self): 
        '子类必须定义读功能' 
        pass 
 
    @abc.abstractmethod #定义抽象方法，无需实现功能 
    def write(self): 
        '子类必须定义写功能' 
        pass 
 
# class Txt(All_file): 
#     pass 
# 
# t1=Txt() #报错,子类没有定义抽象方法 
 
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)

例：描述动物园 
会游泳的 会走路的 会爬树的 会飞的 
老虎 
青蛙 
天鹅 
猴子 
from abc import ABCMeta,abstractmethod 
class FlyAnimal(metaclass=ABCMeta): 
    @abstractmethod 
    def fly(self):pass 
    @abstractmethod 
    def cal_flying_speed(self):pass 
    @abstractmethod 
    def cal_flying_height(self):pass 
class WalkAnimal(metaclass=ABCMeta): 
    @abstractmethod 
    def walk(self):pass 
class SwimAnimal(metaclass=ABCMeta): 
    @abstractmethod 
    def walk(self):pass 
class Tiger(WalkAnimal,SwimAnimal): 
    def walk(self):pass 
    def swim(self):pass 
class Monkey: 
    def walk(self):pass 
    def climb(self):pass 
class Swan(FlyAnimal,WalkAnimal,SwimAnimal): 
    def swim(self):pass 
    def walk(self):pass 
    def fly(self):pass 
    def cal_flying_speed(self):pass 
    def cal_flying_height(self):pass 
class Parrot(FlyAnimal): 
    def fly(self):pass 
    def cal_flying_speed(self):pass 
    def cal_flying_height(self): pass 
 
所有会飞的动物 具有一些会飞的动物的特性 
所有会走的动物 具有一些会走的动物的特性 
 
在python中根本就没有一个叫做interface的关键字，上面的代码只是看起来像接口， 
其实并没有起到接口的作用，子类完全可以不用去实现接口 ， 
如果非要去模仿接口的概念，可以借助第三方模块： 
http://pypi.python.org/pypi/zope.interface 
twisted的twisted/internet/interface.py里使用zope.interface 
文档https://zopeinterface.readthedocs.io/en/latest/ 
设计模式：https://github.com/faif/python-patterns

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')

例： 
peo=People() 
dog=Dog() 
pig=Pig() 
 
#peo、dog、pig都是动物,只要是动物肯定有talk方法 
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用 
peo.talk() 
dog.talk() 
pig.talk() 
 
#更进一步,我们可以定义一个统一的接口来使用 
def func(obj): 
    obj.talk() 
 
题外话： 
java c++ c# —— 强类型语言 
相同数据类型之间做运算 
def func(int a):pass 
func('a') 
 
shell语言 —— 弱类型语言 
1+'1' 
def func(a):pass 
1 'a' [1,2,3] () 
 
介于 强类型 与 弱类型之间 —— python 动态强类型语言 
相同数据类型之间做运算 
def func(a):pass 
 
例： 
class Payment: 
    def pay(self):pass 
 
class QQpay(Payment): 
    def pay(self,money): 
        print('使用qq支付了%s元'%money) 
 
class Wechatpay(Payment): 
    def pay(self,money): 
        print('使用微信支付了%s元'%money) 
    def recharge(self):pass 
 
def pay(Payment pay_obj,int money):    
#  java 多态 在一个类之下发展出来的多个类的对象都可以作为参数传入这里 
pay_obj.pay(money) 
 
# 无论是python的2.*还是3.* ： 天生自带多态效果 
# qq_obj = QQpay() 
# print(type(qq_obj))  # 一个对象的数据类型就是它所在的类

class QQpay(): 
    def pay(self,money): 
        print('使用qq支付了%s元'%money) 
 
class Wechatpay(): 
    def pay(self,money): 
        print('使用微信支付了%s元'%money) 
 
def pay(pay_obj,money): 
    pay_obj.pay(money)