标签：git parent 部分 elf 支付接口 过程 eth 内存 依赖倒置
一、继承
1.1什么是继承？
继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类
python中类的继承分为：单继承和多继承
class ParentClass1: #定义父类
pass
class ParentClass2: #定义父类
pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
pass
class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
pass
查看继承
>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class ‘__main__.ParentClass1‘>,)
>>> SubClass2.__bases__
(<class ‘__main__.ParentClass1‘>, <class ‘__main__.ParentClass2‘>)
提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。
>>> ParentClass1.__bases__
(<class ‘object‘>,)
>>> ParentClass2.__bases__
(<class ‘object‘>,)
例子 :继承的代码实现
class Animal:
def eat(self):
print("%s 吃 " %self.name)
def drink(self):
print ("%s 喝 " %self.name)
class Cat(Animal):
def __init__(self, name):
self.name = name
self.breed = ‘猫‘
def climb(self):
print(‘爬树‘)
class Dog(Animal):
def __init__(self, name):
self.name = name
self.breed=‘狗‘
def look_after_house(self):
print(‘汪汪叫‘)
# ######### 执行 #########
c1 = Cat(‘小白家的小黑猫‘)
c1.eat()
c2 = Cat(‘小黑的小白猫‘)
c2.drink()
d1 = Dog(‘胖子家的小瘦狗‘)
d1.eat()
1.2派生
当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。
在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值.
在python3中，子类执行父类的方法也可以直接用super方法.
class Animal:
‘‘‘
人和狗都是动物，所以创造一个Animal基类
‘‘‘
def __init__(self, name, aggressivity, life_value):
self.name = name # 人和狗都有自己的昵称;
self.aggressivity = aggressivity # 人和狗都有自己的攻击力;
self.life_value = life_value # 人和狗都有自己的生命值;
def eat(self):
print(‘%s is eating‘%self.name)
class Dog(Animal):
‘‘‘
狗类，继承Animal类
‘‘‘
def __init__(self,name,breed,aggressivity,life_value):
super().__init__(name, aggressivity, life_value) #执行父类Animal的init方法
self.breed = breed #派生出了新的属性
def bite(self, people):
‘‘‘
派生出了新的技能：狗有咬人的技能
:param people:
‘‘‘
people.life_value -= self.aggressivity
def eat(self):
# Animal.eat(self)
#super().eat()
print(‘from Dog‘)
class Person(Animal):
‘‘‘
人类，继承Animal
‘‘‘
def __init__(self,name,aggressivity, life_value,money):
#Animal.__init__(self, name, aggressivity, life_value)
#super(Person, self).__init__(name, aggressivity, life_value)
super().__init__(name,aggressivity, life_value) #执行父类的init方法
self.money = money #派生出了新的属性
def attack(self, dog):
‘‘‘
派生出了新的技能：人有攻击的技能
:param dog:
‘‘‘
dog.life_value -= self.aggressivity
def eat(self):
#super().eat()
Animal.eat(self)
print(‘from Person‘)
egg = Person(‘egon‘,10,1000,600)
ha2 = Dog(‘二愣子‘,‘哈士奇‘,10,1000)
print(egg.name)
print(ha2.name)
egg.eat()
1.3抽象类与接口类
接口类
继承有两种用途：
一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）
二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能
归一化设计
实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。
继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。
归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。
依赖倒置原则：
高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该应该依赖细节；细节应该依赖抽象。换言之，要针对接口编程，而不是针对实现编程
在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
接口提取了一群类共同的函数，可以把接口当做一个函数的集合，然后让子类去实现接口中的函数，这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。
比如：我们定义一个动物接口，接口里定义了有跑、吃、呼吸等接口函数，这样老鼠的类去实现了该接口，松鼠的类也去实现了该接口，由二者分别产生一只老鼠和一只松鼠送到你面前，即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑，都会吃，都能呼吸。
再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样
预备知识
l=[123,456,789]
info={"name":"alex","age":1000}
s="hello"
print(len(l))
print(len(info))
print(len(s))
例子：支付接口归一化
##################### 归一化设计 #####################
# 支付宝 微信 银行卡 nfc支付
class AliPay(object):
def __init__(self,name,money):
self.money=money
self.name=name
def pay(self):
# 支付宝提供了一个网络上的联系渠道
print(‘%s通过支付宝消费了%s元‘%(self.name,self.money))
class WeChatPay(object):
def __init__(self,name,money):
self.money=money
self.name=name
def pay(self):
# 微信提供了一个网络上的联系渠道
print(‘%s通过微信消费了%s元‘%(self.name,self.money))
def pay_func(pay_obj):
pay_obj.pay()
alipay=AliPay("alex",100)
wechatpay=WeChatPay("yuan",200)
pay_func(alipay)
pay_func(wechatpay)
规范化方法
支付宝 微信 银行卡 nfc支付
同事协作之间的代码规范问题
规定:Payment 就是一个规范类,这个类存在的意义不在于实现实际的功能,而是为了约束所有的子类必须实现pay的方法
Payment : 抽象类
pay = Payment() # 抽象类: 不能实例化
抽象类主要就是作为基类/父类,来约束子类中必须实现的某些方法
抽象类的特点:
必须在类定义的时候指定metaclass = ABCMeta
必须在要约束的方法上方加上@abstractmethod方法
‘‘‘
from abc import ABCMeta,abstractmethod #(抽象方法)
class Payment(metaclass=ABCMeta): # metaclass 元类 metaclass = ABCMeta表示Payment类是一个规范类
def __init__(self,name,money):
self.money=money
self.name=name
@abstractmethod # @abstractmethod表示下面一行中的pay方法是一个必须在子类中实现的方法
def pay(self,*args,**kwargs):
pass
@abstractmethod
def back(self):
pass
class AliPay(Payment):
def pay(self):
# 支付宝提供了一个网络上的联系渠道
print(‘%s通过支付宝消费了%s元‘%(self.name,self.money))
class WeChatPay(Payment):
def pay(self):
# 微信提供了一个网络上的联系渠道
print(‘%s通过微信消费了%s元‘%(self.name,self.money))
def pay_func(pay_obj):
pay_obj.pay()
alipay=AliPay("alex",100)
wechatpay=WeChatPay("yuan",200)
pay_func(alipay)
pay_func(wechatpay)
当子类和父类都存在相同的pay()方法时，我们说，子类的pay()覆盖了父类的pay()，在代码运行的时候，总是会调用子类的pay()。这样，我们就获得了继承的另一个好处：多态。
抽象类
什么是抽象类
与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化
为什么要有抽象类
如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。 比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。
从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。
从实现角度来看，抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的，即将揭晓答案
在python中实现抽象类
#一切皆文件
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)
抽象类与接口类
抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。
抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计
在python中，并没有接口类这种东西，即便不通过专门的模块定义接口，我们也应该有一些基本的概念。
1.多继承问题
在继承抽象类的过程中，我们应该尽量避免多继承；
而在继承接口的时候，我们反而鼓励你来多继承接口
接口隔离原则：
使用多个专门的接口，而不使用单一的总接口。即客户端不应该依赖那些不需要的接口。
2.方法的实现
在抽象类中，我们可以对一些抽象方法做出基础实现；
而在接口类中，任何方法都只是一种规范，具体的功能需要子类实现
1.4继承小结
继承的作用
减少代码的重用
提高代码可读性
规范编程模式
几个名词
抽象：抽象即抽取类似或者说比较像的部分。是一个从具题到抽象的过程。
继承：子类继承了父类的方法和属性
派生：子类在父类方法和属性的基础上产生了新的方法和属性
抽象类与接口类
1.多继承问题
在继承抽象类的过程中，我们应该尽量避免多继承；
而在继承接口的时候，我们反而鼓励你来多继承接口
2.方法的实现
在抽象类中，我们可以对一些抽象方法做出基础实现；
而在接口类中，任何方法都只是一种规范，具体的功能需要子类实现
复制代码
钻石继承
新式类：广度优先
经典类：深度优先
标签：git parent 部分 elf 支付接口 过程 eth 内存 依赖倒置
原文地址：https://www.cnblogs.com/linux985/p/10458008.html
