Python-面向对象之多继承

1、Python不同版本的类

　　Python2.2之前类是没有共同的祖先的，之后，引入object类，它是所有类的共同祖先类object。

　　Python2 中为了兼容 ，分为古典类，新式类。

　　Python2 中全部都是新式诶

　　新式类都是继承自object的，新式类可以使用super

　　　　

　　Python2.2
    　　新式类：等同 python3,
   　　 旧式类：不能使用super，只能使用 类名. 调用父类的方法属性， 没有base，只有bases
　　Python3.x
    　　对2的统一， 一切都继承自 object，3 更像面向对象

　　dir:尽量收集一个对象所有属性：dir(A):所有属性的列表
　　

In [4]: dir(A)
Out[4]:
['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__']

In [5]:

 2、多继承
　　ocp原则：多用继承，少修改

　　继承的用途：在子类上实现对基类的增强，实现多态

　　多态：

 　　　　在面向对象中，父类，子类通过继承联系 在一起，如果可以通过一套方法，就可以实现不同表现，就是多态。

　　　　一个类继承自多个类就是多继承，它将有多个类的特征

　　　　多态必须建立在 继承和 覆盖才会体现！

 3、多继承弊端

　　多继承很好的模拟了世界，但是会引起复杂性，带来冲突。多继承的实现会导致编译器设计的复杂度增加，所以现在很多语言舍弃了类的多继承。

　　C++支持多继承， java舍弃多继承

　　多继承可能会带来二义性。如：猫，狗继承了动物类的叫，但是子类继承谁的shout呢？

　　解决方案：实现多继承的语言，要解决二义性，深度优先还是广度优先

 

 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图1

 

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图2

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图3

    Python 有三套解决方案：
        2.2 早期：图2， 图3
            经典算法，深度优先 如截图2，c 离得近，但是没法使用，只能先用A的X，但是新式类后来修改后，只保留重复的最后一个
                        即 M D B C A object
                        继承的单调性 不能保证
        2.3版本解决了上面的问题：
            C3 算法，并不是真正的 深度优先，可以检测有没有冲突性，单调性如果有二义性会抛异常

            先看一下MRO 就明白搜索顺序了，以后多看看继承路径！（方法 属性都是一样的查找顺序）

            因为动态语言，所以编译时才可能发现问题，此时已经晚了！！！，所以宁愿使用单继承，少使用多继承
　　　　　　　　
　　　　　　　C3算法解决了多继承的二义性


　　经典算法有很大的问题，如果C 中有覆盖A的方法，就不会访问到了，因为先访问A
　　新式算法，还是深度优先，解决了重复问题，但是没有解决继承的单调性
　　c3算法，解决了继承的单调性，它阻止了之前版本产生二义性的代码，求得MRO本质是为了线性化，且确定了顺序。

　　MRO：方法解析顺序

3、多继承的缺点：
　　当类很多，继承复杂的情况下，继承路径太多，很难说清什么样的继承路径
　　Python语法允许多继承，但Python代码时解释执行，只有执行到的时候，才会发现错误，此时已经晚了。
　　不管语言是够支持多继承，都应避免多继承。
　　 Python的面向对象太灵活，太开放，所以要团队协作。

4、 Mixin混合功能：
　　类有下面的继承关系：
　　　　　　　　　　Pdf --------> Document  <--------Word
　　文档Document类是其他所有文档类的抽象基类：
　　Word，Pdf类是Document的子类
　　
　　思路：

　　1、需求为Document子类提供打印能力

class Document:
    def __init__(self, content):
        self.content = content

    def print(self):# 没有实现，完全抽象成一个方法
        raise NotImplemented('未实现')

class Word(Document): pass # 其他功能略去
class Pdf(Document): pass # 其他功能略去

　　基类提供的方法不应该具体实现，因为他未必适合子类的打印，子类需要覆盖重写。

　　基类中只定义了，不实现的方法，称为抽象方法 在Python中，如果采用这种方式定义的抽象方法，子类可以不实现，知道子类使用该方法的是才报错。
　　
　　print算是一种能力，打印功能，不是所有的Document的子类都需要的，所以，从这个角度出发，有点问题。

　2、需要打印的子类上增加
　　如果在现有子类上直接增加，违反了Ocp原则，所以应该继承后增加：

class Document:
    def __init__(self, content):
        self.content = content

    def print(self):# 没有实现，完全抽象成一个方法，这个方法是知道所有的子类必须实现。
        raise NotImplemented('未实现')

class Word(Document): pass # 其他功能略去
class Pdf(Document): pass # 其他功能略去


# 单继承 这就是OCP，不要在第三方库修改，继承下来，增强或修改
class PrintableWord(Word):
    def print(self):
        print(self.content)


print(PrintableWord.__dict__)
print(PrintableWord.mro())

pw = PrintableWord('test string')
pw.print()

# {'__module__': '__main__', 'print': <function PrintableWord.print at 0x0000000002960378>, '__doc__': None}
# [<class '__main__.PrintableWord'>, <class '__main__.Word'>, <class '__main__.Document'>, <class 'object'>]
# test string

　　看似不错，如果需要还要提供其他的能力，如何继承？
　　应用于网络，文档应该具备序列化能力，类上就应该实现序列化。
　　可序列化还可能分为使用pickle，json，messagepack等

　　这个时候发现，为了增加一种能力，就要增加一次继承，类可能太多了，继承的方式不是很好了。
　　功能太多，A 类需要某几样功能，B类需要另几样功能，它们需要的是多个功能的自由组合，继承实现很繁琐。

　　3、装饰器
　　用装饰器增强一个类，把功能给类附加上去，哪个类需要，就装饰它。

class Document:
    def __init__(self, content):
        self.content = content

    def print(self):# 没有实现，完全抽象成一个方法
        raise NotImplemented('未实现')

class Word(Document): pass # 其他功能略去
class Pdf(Document): pass # 其他功能略去


def printable(cls):
    def _print(self):
        print(self.content)
    cls.print = _print
    return cls

# 单继承 这就是OCP，不要在第三方库修改，继承下来，增强或修改
@printable # PrintableWord = printable(PrintableWord)=PrintableWord
class PrintableWord(Word):pass
    # def print(self):
    #     print(self.content)

pw = PrintableWord('test string')
pw.print()

 　　 注意：上图 如果在类里边，如果实例 self在 print方法中，直接调用print的话，就会出错，递归调用，自己调用自己。

　　优点：

　　　　简单方便，在需要的地方动态的加入，直接使用装饰器，可以为类灵活的增加功能

　　4、Mixin

　　　　举例：

class Document:
    def __init__(self, content):
        self.content = content

    def print(self):
        raise NotImplemented

class Word(Document):pass

# 简单的实现了一个Mixin 类，添加了一个打印功能
class PrintTableMixin:
    def print(self):
        print('{}:{}'.format(type(self).__name__, self.content))

# 再对之前的Mixin再做修饰
class SuperPrintableMixin(PrintTableMixin):
    def print(self):
        print('!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
        super().print()
        print('!!!!!!!!!!!!!!!!!!!!!!!!!!!!')

# 继承了Mixin 类
class SuperPrintableWordMixin(SuperPrintableMixin, Word):pass

# 实例化一个被修饰后的实例
swm = SuperPrintableWordMixin('test word')
swm.print()

　　打印结果：

!!!!!!!!!!!!!!!!!!!!!!!!!!!!
SuperPrintableWordMixin:test word
!!!!!!!!!!!!!!!!!!!!!!!!!!!!

　　Mixin就是其他类混合进来，同时带来了类的属性和方法。
　　这里看来Mixin 类 和装饰器效果一样， 也没有什么特别的，但是Mixin就是类，就可以继承。！！！
　　
　　总结：
　　　　Mixin本质上就是类，就是多继承实现的
　　　　Mixin体现的是一种组合的设计模式
　　　　在面向对象的设计中，一个复杂的类，往往需要很多的功能，而这些功能有来自不同的类提供，
　　　　这就需要很多的类组合在一起
　　　　从设计模式的角度来说，多组合，少继承
　　　　　
　　　　Mixin 类的使用原则；

• • • Mixin 类中不应该显示的出现__init__ 初始化方法
    • Mixin 类通常不能独立工作，因为他是准备混入别的类中的部分功能实现
    • Mixin 类的最先类也是Mixin类

　　　　使用时：Mixin 类通常在继承列表的第一个位置，
　　　　　　　　例如：class PrintWord(PrintMixin, Word):pass

　　　　　　　　因为深度优先，如果放在右侧，可能会出现异常，如果其他父类也实现了该方法，但是功能不一定一样，所以导致结结果不同！

 

练习：

import math
import pickle

class Shape:
    def __init__(self):
        pass

    def area(self):
        raise NotImplemented('未实现')

# class ser:
#     def serialize(self):
#         s = pickle.dumps(self.area())
#         return s
#
# class circle(ser, Shape):
#     def __init__(self, r):
#         self.r = r
#
#     def area(self):
#         area =  math.pi * (self.r ** 2)
#         return  area

def ser(cls):
    def serialize(self):
        s = pickle.dumps(self.area())
        return s
    cls.ser = serialize
    return cls


@ser # cricle = ser(cricle)
class circle(Shape):
    def __init__(self, r):
        self.r = r

    def area(self):
        area =  math.pi * (self.r ** 2)
        return  area

c = circle(4)
print(c.area())
print(c.ser())
print(circle.__dict__)




class triangle(Shape):
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
    def area(self):
        p = (self.a + self.b + self.c) / 2
        q = math.sqrt(p * (p-self.a) * (p-self.b) * (p-self.c))
        return p / q

class square(Shape):
    def __init__(self, a):
        self.a = a

    def area(self):
        return self.a * self.a