Python()- 面向对象三大特性----继承
继承:
继承是一种创建新类的方式，
在python中，新建的类可以继承一个或多个父类(基类或超类)，新建的类是所继承的类的(派生类或子类)
人类和狗 有相同的属性, 提取了一个__init__方法,在这个方法里放一些共有的属性
人类和狗 在相同的方法,提取了一个def func():方法,在这个方法里放一些共有的方法
单继承和多继承
class Par1:
pass
class Par2:
pass
class Sub1(Par1):
pass
class Sub2(Par1,Par2):
pass
#__base__只查看从左到右的第一个父类,而__bases__查看所有父类
print(Sub1.__bases__)
#(<class '__main__.Par1'>,)
print(Sub2.__bases__)
#(<class '__main__.Par1'>, <class '__main__.Par2'>)
------------------------------------
print(Par1.__base__)
#<class 'object'>
如果没有指定基类,python的类默认继承object类,object类是所有类的基类,它提供了一些常见的方法(如__str__)的实现
class Par1:
def __init__(self,name):
self.name = name
def __str__(self):
return self.name
p = Par1('kitty')
print(p)
# kitty
class Foo1:
def __init__(self,name): # self是f对象
self.name = name
def __str__(self):
return self.name
class Foo2(Foo1):
a = 1
f = Foo2('kitty') #Foo2中没有__init__函数,就去基类去找,然后传入参数
print(f.name) # kitty
继承与抽象:
世间本来没有人类,只是很多个具体的人对象,后来把所有的人抽象成(划规成)一类,才有了人类的概念
so: 抽象是从下往上
继承从上往下
继承与重用性:
继承的目的是为了减少代码的重复性
比如:
想创建一个b类, 但是发现b类的属性大部分和a类的相同, 就让b去继承a的属性,节省代码
提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大生了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.
经典类 和 新式类:
python3都是新式类 (新式类默认继承object class Foo(object): == class Foo: )
python2中经典类和新式类共存
- class Foo: 是经典类
- class Foo(object): 是新式类
钻石继承:
- 经典类: 深度优先,就是单线走到头,再去其它线
- 新式类: 就是单线走到剩余最后一个父类停止,再去找其它线,最后一条线走到尾
经典类继承顺序:
深度优先
新式类继承顺序:
广度优先:
如果找到b就去找c c再去找e e在去找f f没有就报错了 因为f找不到d 单线
=====================================================
python2 中: 最原始的加上object,往后的都会继承object
======================================
再来看:
class D: def __init__(self): print('d') class C(D): def __init__(self): print('c') super().__init__() class B(D): def __init__(self): print('b') super().__init__() class A(B,C): def __init__(self): print('a') super().__init__() #mro a = A() print(A.mro()) ##结果如下: a b c d [<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>] 和mro的顺序一样 广度优先 (super只有新式类中有) 在多继承中，super不只是寻找当前类的父类，而是依据mro顺序， 从A节点出发，根据广度优先排序查找下一个类
Mixin
在设计类的继承关系时，通常，主线都是单一继承下来的，例如，Ostrich继承自Bird。但是，如果需要“混入”额外的功能，通过多重继承就可以实现，比如，让Ostrich除了继承自Bird外，再同时继承Runnable。这种设计通常称之为Mixin。
为了更好地看出继承关系，我们把Runnable和Flyable改为RunnableMixin和FlyableMixin。类似的，你还可以定义出肉食动物CarnivorousMixin和植食动物HerbivoresMixin，让某个动物同时拥有好几个Mixin：
class Dog(Mammal, RunnableMixin, CarnivorousMixin): pass
Mixin的目的就是给一个类增加多个功能，这样，在设计类的时候，我们优先考虑通过多重继承来组合多个Mixin的功能，而不是设计多层次的复杂的继承关系。
Python自带的很多库也使用了Mixin。举个例子，Python自带了TCPServer和UDPServer这两类网络服务，而要同时服务多个用户就必须使用多进程或多线程模型，这两种模型由ForkingMixin和ThreadingMixin提供。通过组合，我们就可以创造出合适的服务来。
比如，编写一个多进程模式的TCP服务，定义如下：
class MyTCPServer(TCPServer, ForkingMixin): pass
编写一个多线程模式的UDP服务，定义如下：
class MyUDPServer(UDPServer, ThreadingMixin): pass
如果你打算搞一个更先进的协程模型，可以编写一个CoroutineMixin：
class MyTCPServer(TCPServer, CoroutineMixin): pass
这样一来，我们不需要复杂而庞大的继承链，只要选择组合不同的类的功能，就可以快速构造出所需的子类。
总结:
由于Python允许使用多重继承，因此，Mixin就是一种常见的设计。只允许单一继承的语言（如Java）不能使用Mixin的设计。
派生
派生:
class A: # 基类(提取了狗和人的共同属性) def __init__(self,name, aggressivity, life_value): #里面的self是对象 self.name = name self.aggressivity = aggressivity self.life_value = life_value def eat(self): print('A eating') class Dog(A): # 定义一个狗类 def __init__(self,name, aggressivity, life_value,breed,): #派生一个__init__方法 #A.__init__(self,name, aggressivity, life_value) : 类名.__init__(参数) super().__init__(name, aggressivity, life_value) #调用基类__init__方法:super().__init__() self.breed = breed # 每一只狗都有自己的品种; def bite(self,people): #派生bite方法 父类中没有的属性&方法 people.life_value -= self.aggressivity def eat(self): #重新定义eat (派生) A.eat(self) #如果想加上父类的方法: A.eat(对象) print('dog eating') class Person(A): # 定义一个人类 def __init__(self,name, aggressivity, life_value,money): #派生 super().__init__(name, aggressivity, life_value) #调用基类__init__方法 self.money = money def attack(self,dog): dog.life_value -= self.aggressivity def get_weapon(self,weapon_obj): if self.money > weapon_obj.price: self.money -= weapon_obj.price # 金老板花钱买武器 self.weapon = weapon_obj # 金老板装备打狗棒 self.aggressivity += weapon_obj.aggr # 金老板的攻击力增加了 jin = Person('jin',250,250,100) dog = Dog('酷狗',33,50,'藏獒') print(jin.name) # jin print(jin.money) # 100 print(dog.name) # 酷狗 print(dog.breed) # 藏獒 dog.eat() # A eating # dog eating ------------------- A.eat(dog) #A eating #类名.方法名(对象名) -------------------------------- super(Dog,dog).eat() #A eating super(类名,对象名) super在外面用,必须传参数
派生方法和属性:
1.在子类中增加父类没有的
2.如果再调用父类的的方法和属性
父类.__init__(self,参数...) ⇒ 指名道姓调用
super()__init__(参数...)
在类外面用super的时候, super(子类名,对象).属性
小结:
子类有,用自己的,没有用父类的
子类有,父类有,仍然想用父类的:
经典类: 父类.__init__(self,参数...) 父类.方法名(对象)
新式类: super().__init__(参数...) 父类.方法名(对象)
一般情况下super都满足了
指名道姓调用父类的方法 父类.方法(self) self是子类的对象
例题:打印结果
class Foo: def __init__(self): (self是对象,对象自己有func()) self.func() def func(self): print('父类') class Son(Foo): def func(self): print('子类') s = Son() #子类 ---------------- print(Son.mro()) 新式类才有的查看继承顺序的方法: print(类名.mro()) [<class '__main__.Son'>, <class '__main__.Foo'>, <class 'object'>]
接口类:
接口类:多继承,父类不实现
(模板:都按我的来,这是约定好的)
=================================
格式:
from abc import ABCMeta, abstractmethod class Foo(metaclass=ABCMeta) @abstractmethod def func(self,money):pass
=============================
# 是规范子类的一个模板，只要接口类中定义的，就应该在子类中必须实现
# 接口类不能被实例化,它只能被继承
# 支持多继承
from abc import ABCMeta, abstractmethod class Payment(metaclass=ABCMeta): # 模板，接口类 metaclass 元类 先不用深究 @abstractmethod # 装饰接口类中方法， 加上这个装饰器，自动检测子类中的方法名 def pay(self, money): pass # def get(self):pass 接口类有,下面子类必须有,如果包含没有@abstractmethod的方法,就不是接口类,而是抽象类 class Apple_Pay(Payment): def pay(self, money): print('您使用苹果支付支付了%s元' % money) def func(self): print('类自己的方法') class Ali_Pay(Payment): def pay(self, money): print('您使用支付宝支付了%s元' % money) class WeChat_Pay(Payment): def pay(self, money): print('您使用微信支付了%s元' % money) def pay(obj, money): return obj.pay(money) # 这个pay是和类里面的一一对应的 apple = Apple_Pay() ali = Ali_Pay() wechat = WeChat_Pay() pay(apple, 100) # apple.pay(100) pay(wechat, 200)
===========
def pay(obj,money): return obj.pay(money) 类似: def next(obj): return obj.__next_() __next__() next() 内置函数
=======================================
接口类: 主动触发异常
class Payment(Payment): def pay(self,money):raise NotImplementedError (这个方法有个缺点,子类只有调用那个方法时才会抛错,推荐@abstractmethod,可以在类被实例化后触发它) ..................下面代码省略........... 报错 def pay(self,money):raise NotImplementedError NotImplementedError
=========================================
===============
接口的多继承:
接口隔离原则:使用多个专门的接口,而不使用单一的总接口.(客户端不应该依赖那些不需要的接口)
(模板不能放到一个里面)
(接口类鼓励多继承) # (抽象类避免多继承)
===========================================
python 本来没有接口类, 接口类的@abstractmethod 是借用的 抽象类的模块(装饰器)来实现接口类
接口类概念来自java
抽象类:
模板 规范
抽象类可以实现一些子类共有的功能和属性\抽象类避免多继承
python 没有接口的概念
只能借助抽象类的模块 来实现接口类
---------------------------------------------------------
接口 —— 来自java,但是java没有多继承 , java有个Interface关键字,
---------------------------------------------------------
例子:
文件操作 ：打开文件 关闭文件 写文件 读文件
硬盘操作：打开，关闭，写 读
进程文件：打开 关闭，读 写
都有打开,关闭,读取,写入的功能
from abc import ABCMeta,abstractmethod #格式参考接口类格式 class Base(metaclass=ABCMeta): def __init__(self,filename): #抽象类可以有__init_(), 接口类不能有 其它的没感觉两个有有啥区别 self.filename = filename @abstractmethod #抽象方法 def open(self): return 'file_handler' @abstractmethod def close(self):pass @abstractmethod def read(self):pass @abstractmethod def write(self):pass class File(Base): def open(self):pass def close(self):pass def read(self):pass def write(self):pass
抽象类不能被实例化
这个抽象类可以规范子类必须实现抽象类中的抽象方法 (没有强制子类必须有父类的所有方法)
例二: 原博客地址: https://www.cnblogs.com/bjdxy/archive/2012/11/15/2772119.html
由于python 没有抽象类、接口的概念，所以要实现这种功能得abc.py 这个类库,具体方式如下
from abc import ABCMeta, abstractmethod #抽象类 class Headers(object): __metaclass__ = ABCMeta def __init__(self): self.headers = ' ' @abstractmethod def _getBaiduHeaders(self):pass def __str__(self): return str(self.headers) def __repr__(self): return repr(self.headers) #实现类 class BaiduHeaders(Headers): def __init__(self, url, username, password): self.url = url self.headers = self._getBaiduHeaders(username, password) def _getBaiduHeaders(self, username, password): client = GLOBAL_SUDS_CLIENT.Client(self.url) headers = client.factory.create('ns0:AuthHeader') headers.username = username headers.password = password headers.token = _baidu_headers['token'] return headers
如果子类不实现父类的_getBaiduHeaders方法,则抛出TypeError: Can't instantiate abstract class BaiduHeaders with abstract methods 异常
===============================================
抽象类和接口类的区别
python的语法角度上来说,是没有区别的,(因为没有接口类的概念,接口类借用抽象类的概念和模块)
小区别:接口类不能实现内部的代码,
抽象类能实现司内部的代码(__init__())
应用场景的不同:
抽象类不鼓励多实现(少继承)
接口类鼓励多实现(多继承)
所以一般情况下,没有法子通过代码上的不同去区分它们,只能通过应用场景去区分它们.(一种思想上的改变)
抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），
而接口只强调函数属性的相似性。
抽象类是一个介于类和接口之间的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计
================================================
