python 面向对象高级

08 面向对象高级

常用内置函数

#hasattr() 判断实例对象属性是否存在
hasattr(aa,'abc') #存在返回True，不存在返回False
#getattr() 返回实例对象属性值
getattr(aa,'def')
#setattr() 设置实例对象属性和属性值
setattr(aa,'name','安安') #属性不存在，新增属性；属性存在，更改属性值
#delattr() 删除实例对象属性
delattr(aa,'def')
#issubclass() 判断是否是继承关系
issubclass(Aa,Bb) #判断前面的类是否是后面类的子类，是返回True，不是返回False
issubclass(Cc,(Dd,Ee)) #多继承的情况
#isinstance() 判断对象是否是类的实例
isinstance(aa,Aa) #判断前面的对象是否是后面类（包括父类）的实例，是返回True，不是返回False
isinstance(Cc,(Dd,Ee)) #多继承的情况

属性调用过程

属性的调用过程（语法糖）

#底层调用过程
bd.name -> bd.__getattribute__('name') -> getattr(bd,'name') -> bd.__getattribute__('name')

依据底层的调用过程，可通过改变调用函数，改变报错

class Person:
	def __init__(self,name):
		self.name = name
	def __getattr__(self,item): #item用作接收属性
		print('no attribute')

魔法方法

魔法方法是python内置的方法，方法名左右两边为双下划线
不同的魔法方法有不同的功能

1. 魔法方法 new 创建实例对象

#无视代码位置，new方法先执行
class Earth:
	def __init__(self,name):
		print('这是实例化函数')
		self.name = name
	def __new__(cls,*args,**kwargs): #方法重载，python中自带就有new方法，cls指类本身
		print('这是初始化函数')
		return super().__new__(cls) #调用父类的new方法

2. 单例模式

class Earth:
	def __init__(self,name):
		print('这是实例化函数')
		self.name = name
	def __new__(cls,*args,**kwargs):
		print('这是初始化函数')
		if not hasattr(cls,'_instance'): #判断实例是否存在
			cls._instance = super().__new__(cls) #如果不存在，调用父类new方法进行创建
			return cls._instance

3. 输出魔法方法 str repr

class Earth:
	def __init__(self,name):
		print('这是实例化函数')
		self.name = name
	def __new__(cls,*args,**kwargs):
		print('这是初始化函数')
		if not hasattr(cls,'_instance'):
			cls._instance = super().__new__(cls)
		return cls._instance
	def __str__(self): #print输出时候调用的方法
		return 'this is __str__ %' % self.name 
	def __repr__(self): #直接打印时调用的方法
		return 'this is __str__ %' % self.name 
	def __call__(self): #把实例对象变成可调用的方法
		print('你好！')
oo=Earth('地球')
print(oo)
oo
#print调用方法默认先调用str方法，若str方法没写，则自动调用repr方法
oo()

协议

需要用两个或两个以上的魔法方法实现的效果为协议

1. 序列协议

class IndexTuple:
	def __init__(self,*args):
		self.values = [x for x in args] #列表推导式保存不定长参数里的值
		self.index = tuple(enumerate(self.values)) #枚举函数将所有值取出存放为元组形式保存
	def __len__(self): #获取对象长度
		return len(self.values)
	def __getitem__(self,key): #根据索引取值
		return self.index[key]

2. 迭代协议

迭代器

#dir() 查看是否为可迭代对象，有iter为可迭代对象
li = [5,6,7,8,10]
f = li.__iter__() 
next(f)

迭代协议

class Number:
	def __init__(self,end = 10):
		self.start = 0 #迭代起始值
		self.end = end #迭代结束值
	def __iter__(self): #iter 让类变成可迭代对象
		return self
	def __next__(self): #next 让可迭代对象变成迭代器
		self.start += 1
		if self.start >= self.end:
			raise StopIteration #主动报错 raise抛出异常
		return self.start
n = Number()
next(n)

3. 上下文协议
   with 方法 首先会调用 enter（打开文件）, exit（关闭文件）

import time
time.time() #时间戳 1970至今的时间秒数
class RunTime:
	def __enter__(self):
		self.start = time.time()
		return self.start
	def __exit__(self,exc_type,exc_val,exc_tb): #捕获异常类型 捕获异常值 捕获异常的最终信息
		self.end = time.time()
		self.run = self.end - self.start
		print('时间运行：%s'%self.run)		
#通过上下文协议 测试代码运行时间
with RunTime():
	for i in range(10000000):
		pass

练习

1. 试列表推导和不用列表推导那一种速度更快

import time
class RunTime:
	def __enter__(self):
		self.start = time.time()
		return self.start
	def __exit__(self,exc_type,exc_val,exc_tb):
	self.end = time.time()
	self.run = self.end - self.start
	print('运行时间为%s'%self.run)
with RunTime():
	li1 = []
	for i in range(1000000):
		li1.append(i)
with RunTime():
	li2 = [i for i in range(1000000)]

2. range不可以使用小数做步长，实现一个可迭代对象，可以实现小数步长

import decimal
class Fragen():
	def __init__(self,start,end = None,step = 1):
		if not isinstance(start,(int,float)):
			raise TypeError
		elif end != None and (not isinstance(end,(int,float))):
			raise TypeError
		elif not isinstance(step,(int,float)):
			raise TypeError
		elif start > end:
			print('开始值不能大于结束值')
		elif step < 0:
			print('步长不能为负')
		else:
			if end == None:
				self.start = 0
				self.end = start
			else:
				self.start = start
				self.end = end
				self.step = step
		self.start = decimal.Decimal(str(self.start))
		self.end = decimal.Decimal(str(self.end))
		self.step = decimal.Decimal(str(self.step))
	def __iter__(self):
		return self
	def __next__(self):
		self.start += self.step
		if self.start <= self.end:
			return self.start
		else:
			raise StopIteration