类的继承
基本概念
定义
格式如下
继承中的访问控制
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)