chapter8.2、面向对象三要素--继承
继承Inheritance
单继承
个体继承自父母，继承父母的属性,但也会有自己的属性
面向对象里，属性和方法可以从从父类继承，这样能减少代码，能复用就复用，子类复用的属性不能表达他自己的属性时，再为子类增添属性。
父类father，也称为 基类base，超类super，它们意思相同
子类son，派生类sub，
class Creatures: def __init__(self,name): self._name = name def shout(self): print('{} shout'.format(self.__class__.__name__)) @property def name(self): return self._name a = Creatures('monster') a.shout() class Cat(Creatures): pass cat = Cat("garfield") cat.shout() print(cat.name) class Pig(Creatures): pass pig = Pig('peiqi') pig.shout() print(pig.name)
表达方法 ：
class 子类名(基类1[,基类2,.....]):
语句块
class Person: pass class Person(object) pass
以上两种等价
object 祖先，根基类，唯一没有父类的，所有的类都继承自object，python3中全部类最终继承自object，如果不写父类，父类就是object，Python3之前不是
python 支持多继承，查看继承的特殊属性和方法有
__base__ 类的基类,只往上找一层，返回类对象
__bases__ 类的基类元祖，不会找到object，但在中间的类都会包装成元组返回
__mro__ 返回继承路线，返回所有元祖，包括object，也可以mro()
mor() 方法，返回的是列表
__subclasses__() 类的子类列表
class Animal: __COUNT = 100 HEIGHT = 0 def __init__(self,age,weight,height): self.__COUNT += 1 self.age = age self.__weight = weight#实例的私有属性，类不会保存 self.HEIGHT = height def eat(self): print('{} eat'.format(self.__class__.__name__)) def __getweight(self): print(self.__weight) @classmethod def showcount1(cls): print(cls) #print(cls.__dict__) print(cls.__COUNT,'--------1') @classmethod def __showcount2(cls): print(cls.COUNT,'---------2') def showcount3(self): print(self.__COUNT,'-------3') class Pig(Animal): NAME = 'PAGE' __COUNT = 300 #p = Pig()###创建实例访问的属性为Pig的类，Pig没有，就去父类Animal里找，要求有参数 p = Pig(5,50,30)#创建实例 p.eat()##实例所属的类Pig没有该方法，但是Animal有，调用 print(p.HEIGHT)##实例自身的属性 #print(p.__COUNT)##对象的属性是储存在自己字典里的，只不过换了名字 #p.__getweight()##该方法属于它的类，但是类隐藏了该属性，所以调不到 p.showcount1()##该方法属于类的父类，且未隐藏，可以调，返回100，该方法是Animal类调用的__count,不会去实例里边找，所以返回类里的隐藏变量100 #p.showcount2()##该方法属于它的类，但是类隐藏了该属性，所以调不到 p.showcount3()##返回101，对象调用类的方法，首先找的是对象的字典，谁调用，去谁那找 ##信息都藏在字典里！ print('{}'.format(Animal.__dict__)) print('{}'.format(Pig.__dict__)) print(p.__dict__) print(p.__class__.mro())
继承中的访问控制
只要是继承，自己没有的，就可以到父类中找，私有的和类相关，私有属性的更改就要在类下更改
私有的都是不可访问的，但本质时放在了属性或类的字典__dict__中，可以找到，黑魔法，慎用，
谁调用谁的self和cls
继承时，公有的，子类和实例都可以随意访问；隐藏的，子类和实例都不可直接访问，私有不会和子类父类分享，只有自己用，自己类下的方法都可以访问这个私有变量
子类实例都不可访问私有属性，私有一旦出了类，就不能访问了
其他语言有的严格限制访问
方法的重写，覆盖override
继承修改了属性，就是重写，自己类下的方法也可以覆盖
class Creatures: def shout(self): print('Animal shout') class Pig(Creatures): def shout(self): print('hengheng') def shout(self): print(super()) print(super(Pig,self))##和上一种相同 super().shout()##子类调父类的方法，以下两种与之相同 super(Pig,self).shout() self.__class__.__base__.shout(self)##不推荐使用此方法 c = Creatures() c.shout() pig = Pig() pig.shout() print(c.__dict__) print(pig.__dict__) print(Creatures.__dict__) print(Pig.__dict__)
子类可以使用super（）访问父类的属性，super() 等价于 super(父类名，self)
静态方法和类方法都与之相同，都可以覆盖
class Creatures: @classmethod def class_method(cls): print('class method creatures') @staticmethod def static_method(): print('static method creatures') class Pig(Creatures): @classmethod def class_method(cls): print('class method pig') @staticmethod def static_method(): print('static method pig') p = Pig() p.class_method() p.static_method()
继承中的初始化
本身有初始化方法，初始化不会自动调父类的初始化方法。
如果没有，就会调父类的初始化方法 ，父类有init方法，子类也调用是好习惯，不调用实例可能会少父类的实例的属性
class Animal: def __init__(self,age): print('animal init') self.age = age def show(self): print(self.age) class Cat(Animal): def __init__(self,age,weight): super().__init__(age)##放在此处，age返回11，先执行Animal的初始化，在执行Cat的age，所以c的age是11 print('cat init') self.age = age +1##此处执行时age为10加11 self.weight = weight #super().__init__(age) ##如果放在此处，返回的为10，首次执行Cat的初始化，将c的age设置为了11，再执行Animal的初始化，传入的是参数age，不是c的age，所以又覆盖了c的属性，输出10 c = Cat(10,5) c.show()
调用父类的初始化方法的顺序会影响实例的属性，应当注意
class Animal: def __init__(self,age): print('animal init') self.__age = age def show(self): print(self.__age) class Cat(Animal): def __init__(self,age,weight): super().__init__(age) print('cat init') self.__age = age +1 self.__weight = weight #super().__init__(age) c = Cat(10,5) c.show() print(c.__dict__)
实例调用类的私有方法调用时产生的属性放在实例中，但是名字与类有关，最好不要用。
父类的初始化方法调用后，使用的实例是当前类的实例，父类不产生实例，子类调用他父类的的方法
主要原则：自己的私有属性，就用自己的方法读取修改，不要使用父类和派生类或者其他类的方法
python的不同版本的类
python2.2之前，没有类的共同祖先，之后，引入了object 所有类的共同祖先，
python2.2之后，分为古典类和新式类。
python3中都是新式类，都继承自object
dir 所有属性的列表
多继承
OCP原则，多‘继承’，少修改
在子类上对基类的增强，实现多态，
多态：在面向对象中，父类，子类通过继承联系在一起，如果可以通过一套方法，就可以实现不同表现，就是多态
一个类继承自多个类就是多继承，它将具有多个类的特征
多继承弊端
复杂性，只要不是单一继承，就会面对复杂性这一问题
二义性，如果继承自两个类，两个类里都有相同的方法，子类该继承那个方法，就产生了二义性
C++支持多继承，Java舍弃了多继承
解决途径
排除二义性，要遍历，方法是深度优先，或广度优先
菱形选择问题，类D继承自B和C，B和C又继承自A，当然，类的继承顺序可以比这更复杂
2.2之前，最早是深度优先，先根再左在右
2.2古典类继承路线中重复的以最后为准，但不能解决问题
python2.3 之后，C3算法，可以解决二义性问题，还可以抛异常，解决了继承的单调性，出现二义性就阻止它，求得的MRO本质就是为了线性化，且确定顺序，
多继承使用时要注意
python语法是可以多继承，但是它是解释执行，只有执行到时才会发现错误。
尽量避免多继承，不论语言是否支持
团队协作开发，引入多继承，代码可能会不可控
python开发要求较高，只有运行时才能提示错误，所以在编写时要团队遵守相同的规矩
Mixin
抽象方法可以不实现，继承实现，父类不具体实现，子类来覆盖它
基类中只定义，不实现，称为‘抽象方法’，在Python中，如果采用这种定义方式，子类也可以不实现，直到子类使用该方法时才报错。
import math import json import msgpack class Shape: @property def area(self): raise NotImplemented('weishixian') class Triangle(Shape): def __init__(self, a, b, c): self.__a = a self.__b = b self.__c = c @property def area(self): p = (self.__a + self.__b + self.__c) / 2 ret = math.sqrt(p*(p - self.__a)*(p - self.__b)*(p - self.__c)) return ret class Square(Shape): def __init__(self,a,b): self.__a = a self.__b = b @property def area(self): return self.__a*self.__b class Circle(Shape): def __init__(self,r): self.__r = r @property def area(self): return math.pi*(self.__r**2) t = Triangle(3,4,5) print(t.area) s = Square(2,2) print(s.area) r = Circle(1) print(r.area)
临时注入功能，可以用装饰器注入，装饰器为类灵活的增添功能；也可以Mixin，用Mixin时，混入谁，把谁放在前边，Mixin覆盖其他的属性，缺少啥补啥，一般不会太复杂
class SerializableMixin:##Mixin类 def dump(self,t = 'json'):##增添的功能，可序列化 if t == 'json': return json.dumps(self.__dict__) if t == 'msgpack': return msgpack.dumps(self.__dict__) else : return "not realize serialize" class SerializableCircleMixin(SerializableMixin,Circle): pass#多继承，放在第一位 scm = SerializableCircleMixin(4) print(scm.area) s = scm.dump('msgpack') print(s) j = scm.dump('json') print(j)
子类指向父类，画图的规则
继承的层次多了，会笨拙，
Mixin，混入其他功能，Mixin带来了其他属性和方法，Mixin本质是多继承实现的
Mixin体现的是组合的·设计思想，模式，
在面向对象的设计中，复杂功能可以抽取出来，为其他类提供功能，可以装饰或者Mixin，
从设计角度来说，多组合，少继承，为了改变mro列表
使用原则
Mixin类中不能显式的出现初始化方法__init__
Mixin通常不能单独工作，因为它是为混入其他类增加功能的
Mixin的祖先只能是Mixin类，只是为了增添功能，不是强制，但这是原则，一般都这样做
注意Mixin类通常在继承列表的第一个位置
两种方式都可以，如果要继承就使用Mixin，
PEP是python的增强提案，Python Enhancement Proposals
新特性，PEP 572，2018年7月，Guido van Rossum，python之父卸任了BDFL（benevolent dictator for life），没有指定继任者，
PEP 0 文档索引
PEP 1 协议指南
PEP 8 代码规范！！！
Python社区，新的规范的原始文档都在这里，可以访问
https://www.python.org/dev/peps/pep-0008/
