Pyhon进阶9---类的继承

类的继承

基本概念

定义

格式如下

继承中的访问控制

class Animal:
    __CNOUT = 0
    HEIGHT = 0

    def __init__(self,age,weight,height):
        self.__CNOUT =self.__CNOUT + 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.__CNOUT)

    @classmethod
    def __showcount2(cls):
        print(cls.__CNOUT)

class Cat(Animal):
    NAME = 'CAT'

c = Cat(3,5,15)
c.eat()
c.showcount1()#注意此处的cls.__COUNT仍为0

print(c.NAME)
print(c.__dict__)#{'_Animal__CNOUT': 1, 'age': 3, '_Animal__weight': 5, 'HEIGHT': 15}
print(Cat.__dict__)#{'__module__': '__main__', 'NAME': 'CAT', '__doc__': None}
print(Animal.__dict__)#{'__module__': '__main__', '_Animal__CNOUT': 0, 'HEIGHT': 0,...}

方法的重写、覆盖override

class Animal:
    def shout(self):
        print('Animal shout')

class Cat(Animal):
    #覆盖父类的方法
    def shout(self):
        print('miao')
    #覆盖自身的方法，显示调用了父类的方法
    def shout(self):
        print(super(Cat, self))
        super().shout()

a = Animal()
a.shout()
c =Cat()
c.shout()

#输出结果：
# Animal shout
# <super: <class 'Cat'>, <Cat object>>
# Animal shout

class Animal:
    @classmethod
    def class_method(cls):
        print('class_method_animal')

    @staticmethod
    def static_method():
        print('static_method_animal')

class Cat(Animal):
    @classmethod
    def class_method(cls):
        print('class_method_cat')

    @staticmethod
    def static_method():
        print('static_method_cat')

c = Cat()
c.class_method()
c.static_method()
#输出结果：
# class_method_cat
# static_method_cat

继承中的初始化

示例1

class A:
    def __init__(self):
        self.a1 = 'a1'
        self.__a2 = 's2'
        print('A init')

class B(A):
    pass
b = B()
print(b.__dict__)       #{'a1': 'a1', '_A__a2': 's2'}

示例2

class A:
    def __init__(self):
        self.a1 = 'a1'
        self.__a2 = 's2'
        print('A init')

class B(A):
    def __init__(self):
        self.b1 = 'b1'
        print('B init')
b = B()
print(b.__dict__)    #{'b1': 'b1'}

class A:
    def __init__(self):
        self.a1 = 'a1'
        self.__a2 = 's2'
        print('A init')

class B(A):
    def __init__(self):
        # A.__init__(self)
        # super(B,self).__init__()
        super().__init__()
        self.b1 = 'b1'
        print('B init')
b = B()
print(b.__dict__)   #{'a1': 'a1', '_A__a2': 's2', 'b1': 'b1'}

如何正确初始化

 

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)#c.show()结果为11
        print('Cat init')
        self.age = age + 1
        self.weight = weight
        # super().__init__(age)#c.show()结果为10
c = Cat(10,5)
c.show()   
# c.__dict__   {'age': 11, 'weight': 5}

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
c = Cat(10,5)
c.show()
print(c.__dict__)#{'_Animal__age': 10, '_Cat__age': 11, '_Cat__weight': 5}

Python不同版本的类

多继承

多继承弊端

Python多继承实现

class ClassName(基类列表):
    类体

多继承的缺点

Mixin

class Printable:
    def _print(self):
        print(self.content)

class Document:#假设为第三方库，不允许修改
    def __init__(self,content):
        self.content = content

class Word(Document):pass#假设为第三方库，不允许修改
class Pdf(Document):pass#假设为第三方库，不允许修改

class PrintableWord(Printable,Word):pass
print(PrintableWord.__dict__)
print(PrintableWord.mro())
pw = PrintableWord('test string')
pw._print()

def printable(cls):
    def _print(self):
        print(self.content,'装饰器')
    cls.print = _print
    return cls

class Document:#假设为第三方库，不允许修改
    def __init__(self,content):
        self.content = content

class Word(Document):pass#假设为第三方库，不允许修改
class Pdf(Document):pass#假设为第三方库，不允许修改

@printable
class PrintableWord(Word):pass

print(PrintableWord.__dict__)#{'__module__': '__main__', '__doc__': None, 'print': <function printable.<locals>._print at 0x0000000002961730>}
PrintableWord('test').print()#test 装饰器

4.Mixin

#Mixin示例1
class PrintableMixin:
    def print(self):
        print(self.content,'Mixin')

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

class Word(Document):pass
class Pdf(Document):pass

class PrintableWord(PrintableMixin,Word):pass
print(PrintableWord.__dict__)
print(PrintableWord.mro())

pw = PrintableWord('test\nstring')
pw.print()

#Mixin示例2
class PrintableMixin:
    def print(self):
        print(self.content,'Mixin')

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

class Word(Document):pass
class Pdf(Document):pass

class SuperPrintableMixin(PrintableMixin):
    def print(self):
        print('~'*20)
        super().print() #通过继承复用
        print('~'*20)

class SuperPrintablePdf(SuperPrintableMixin,Pdf):pass
print(SuperPrintablePdf.__dict__)
print(SuperPrintablePdf.mro())

spp = SuperPrintablePdf('super print pdf')
spp.print()

Mixin类

练习

#1.Shape基类，要求所有子类都必须提供面积的计算，子类有三角形、矩形、圆
import  math

class Shape:
    @property
    def area(self):
        raise NotImplementedError('基类未实现')

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
        return math.sqrt(p*(p-self.a)*(p-self.b)*(p-self.c))

class Circle(Shape):
    def __init__(self,radius):
        self.radius = radius

    @property
    def area(self):
        return math.pi*self.radius**2

class Rectangle(Shape):
    def __init__(self,width,height):
        self.width = width
        self.height = height

    @property
    def area(self):
        return self.width*self.height

# shapes = [Triangle(3,4,5),Rectangle(3,4),Circle(4)]
# for s in shapes:
#     print('The area of {} = {}'.format(s.__class__.__name__,s.area))

#2.圆类的数据可序列化
import json
import msgpack

def mydump(cls):
    def _dumps(self, t='json'):
        if t == 'json':
            return json.dumps(self.__dict__)
        elif t == 'msgpack':
            return msgpack.packb(self.__dict__)
        else:
            raise NotImplementedError('没有实现的序列化')
    cls.dumps = _dumps
    return cls

#使用Mixin类
# class SerializableMixin:
#     def dumps(self,t='json'):
#         if t == 'json':
#             return json.dumps(self.__dict__)
#         elif t == 'msgpack':
#             return msgpack.packb(self.__dict__)
#         else:
#             raise NotImplementedError('没有实现的序列化')
#
#使用装饰器
@mydump
class SerializableCircleMixin(Circle):pass

scm  = SerializableCircleMixin(1)
print(scm.area)#3.141592653589793
print(scm.__dict__)#{'radius': 1}
print(scm.dumps('json'))#{"radius": 1}

 作业

#单链表
class SingleNode:
    #代表一个节点
    def __init__(self,val,next=None):
        self.val = val
        self.next = None

class LinkedList:
    #容器类，某种方式存储一个个节点
    def __init__(self):
        self.head = None
        self.tail = None

    def append(self,val):
        node = SingleNode(val)
        if self.head is None:#
            self.head = node
            self.tail = node
        self.tail.next = node
        self.tail = node

    def iternodes(self):
        while self.head:
            yield self.head.val
            self.head = self.head.next

 #实现双向链表
 class SingleNode:
     #代表一个节点
     def __init__(self,val,next=None,prev=None):
         self.val = val
         self.next = next
         self.prev = prev

     def __repr__(self):
         return str(self.val)

 class LinkedList:
     #容器类，某种方式存储一个个节点
     def __init__(self):
         self.head = None
         self.tail = None

     def append(self,val):
         node = SingleNode(val)
         if self.head is None:#
             self.head = node
         else:
             self.tail.next = node
             node.prev = self.tail
         self.tail = node

     def pop(self):
         if self.tail is None:#
             raise NotImplementedError('Empty')
         tail = self.tail
         prev= self.tail.prev
         if prev is None:#1个节点
             self.head = None
             self.tail = None
         else:#>1
             self.tail = prev
             prev.next = None
         return tail.val

     def insert(self,index,val):#1,7
         if index < 0:
             raise Exception('Error')
         cur = None
         for i,current in enumerate(self.iternodes()):
             if i == index:
                 cur = current
                 break

         if cur is None:#说明索引越界或空链表，直接末尾追加
             self.append(val)
             return

         node = SingleNode(val)
         prev = cur.prev
         if prev is None:#1个节点,头部插入
             self.head = node
             node.next = cur
             cur.prev = node
         else:#>=2
             node.next = cur
             prev.next = node
             cur.prev = node
             node.prev = prev

     def iternodes(self,reversed = False):
         current = self.head
         while current:
             yield current
             current = current.next

 a = SingleNode(1)
 b = SingleNode(2)
 c = SingleNode(3)
 d = SingleNode(4)
 e = SingleNode(5)
 f = SingleNode(6)
 ll = LinkedList()
 ll.append(a)
 ll.append(b)
 ll.append(c)
 ll.append(d)
 ll.append(e)
 ll.append(f)
 # ll.insert(1,0)
 # ll.insert(0,0)
 ll.insert(10,100)
 print('pop元素：',ll.pop())
 print('pop元素：',ll.pop())
 print('pop元素：',ll.pop())
 ll.insert(0,10)

 for node in ll.iternodes():
     print(node)