文章目录
- 1、isinstance与issubclass判断方法
- 2、__getattribute__方法
- 3、item系列
- 4、__str__与__repr__方法
- 5、自定制格式化方法
- 6、__doc__描述属性
- 7、__del__析构
- 8、__call__方法
- 9、迭代器协议
- 10、迭代器协议实现斐波那契数列
前几篇关于Python面向对象编程的文章也介绍了一部分类的一些内置方法和属性，本篇文章总结的是类的一些其他内置方法及属性
1、isinstance与issubclass判断方法
isinstance(obj,cls)： 判断obj对象是否为类cls的实例
issubclass(Bar,Foo)： 判断Bar是否为Foo的子类
class Foo:
pass
obj = Foo()
print(isinstance(obj,Foo)) #判断obj是否为Foo的实例
class Bar(Foo): #继承Foo类
pass
obj2 = Bar()
print(issubclass(Bar,Foo)) #判断Bar是否为Foo的子类
#继承后的子类实例化的对象也是父类的实例
print(isinstance(obj2,Foo))
print(type(obj2)) #查看obj2的类型，其实就是它所属的类
运行结果：
2、__getattribute__方法
属性有或没有都会触发__getattribute__方法，它也是Python内置的报错机制原理
class Foo:
y = 2020
def __init__(self,x):
self.x= x+1
def __getattr__(self,item): #item为必须参数
print('%s属性不存在，触发__getattr__方法' %item)
def __getattribute__(self,item):
print('正在触发__getattribute__方法')
#只要有getattribute在，就会先触发它，无论调用的属性是否存在
raise AttributeError('抛出异常了')
#加上raise AttributeError语句，触发__getattribute__方法后，
#若属性不存在，则才会触发__getattr__方法
#若加上raise TabError语句，则不会再触发__getattr__方法，直接终止程序
#raise TabError('抛出异常了')
#实例化
p1 = Foo(1313)
p1.zzzzzz #调用一个不存在的属性
AttributeError结果：
TabError结果：
3、item系列
有这三个：
getitem
setitem
delitem
class Test:
y = 2020
def __init__(self,x):
self.x= x+1
def __getitem__(self,item): #item为必须参数
print('正在执行__getitem__方法')
def __delitem__(self,item):
print('正在触发__delitem__删除值')
def __setitem__(self,key,value): #设置值的时候是加入属性字典里，所以传入的是键值对
print('正在用__setitem__设置值')
#__setattr__内必须有设置值的操作
self.__dict__[key]= value #设置原属性字典
#实例化
p1= Test(1313)
p1.age = 22 #正常情况的添加属性字典键值对
#可以用字典的方式来赋值
p1['name'] = 'Zoro'
#输出
print(p1.age,p1.name)
print(p1.__dict__)
#但是用__setitem__赋值的属性不会出现在属性字典里
#和__getattr__\__setattr__\__delattr__类似，只是item是基于字典的方式来处理
#调用不存在的属性触发__getitem__,删除操作触发__delitem__
p1['zzzzzzz'] #调用不存在的属性
del p1['age'] #删除属性
运行结果：
4、__str__与__repr__方法
class Foo:
def __init__(self,name,age):
self.name= name
self.age= age
def __str__(self):
return '名字是%s，年龄是%s' %(self.name,self.age) #必须设置一个返回值
def __repr__(self):
return '名字是%s，年龄是%s' %(self.name,self.age) #必须设置一个返回值
#实例化
p1= Foo('View',22)
print(p1) #就会默认输出__str__内的返回值，相当于print(str(p1))
repr(p1)
#repr在解释器里面用，相当于p1.__repr__()
运行结果：
5、自定制格式化方法
#定义可供选择的字典
format_dic={
'ymd':'{0.year}{0.month}{0.day}',
'm-d-y':'{0.month}-{0.day}-{0.year}',
'y:m:d':'{0.year}:{0.month}:{0.day}',
}
class Date:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
def __format__(self,format_spec): #定义一个__format__方法
print('正在执行__format__方法')
#做一个默认格式，当选择为空或者不规范(不在选择字典的key中)时就用这个输出
if not format_spec or format_spec not in format_dic:
fm = format_dic['ymd'] #默认格式
else:
fm = format_dic[format_spec] #取格式，即从字典取值
return fm.format(self) #将self参数中的值用fm的格式返回，fm即为自定义格式
#实例化
d1 = Date(2020,3,17)
print(format(d1,'y:m:d')) #用键来取值供选择的字典
#执行对象d1下的__fromat__方法，并输出返回值
#第一个参数传给self,第二个参数传给format_spec表示你选择的格式
print(format(d1,'ymm')) #一个不存在的格式将按默认格式输出
运行结果：
6、__doc__描述属性
class Foo:
'这是Foo的描述信息'
pass
class Bar(Foo):
pass
print(Foo.__dict__)
print(Foo.__dict__) #描述信息也被继承了，所以两个字典里都有该键值对
运行结果：
7、__del__析构
析构函数： 整个类被执行完毕了，即内存被释放了才触发，或者将整个类产生的对象删除了
class Foo:
def __init__(self,name,age):
self.name = name
self.age = age
def __del__(self):
print('该类已执行完毕!')
p = Foo('View',22)
del p
print('--------------->')
运行结果：
8、__call__方法
作用分析：一个对象加()就是在调用生成它的类下的__call__方法
class Foo:
def __call__(self,*args,**kwargs):
print('实例带括号，执行啦')
f = Foo() #实例化
f()
运行结果：
9、迭代器协议
class Foo:
def __init__(self,x):
self.x = x
def __iter__(self):
return self #将属性变成可迭代对象
#既然有__iter__方法，一定要有__next__方法，才可以正常遍历
def __next__(self):
self.x += 1
if self.x == 530: #设置迭代的终止条件为达到530就停止
raise StopIteration('迭代结束！')
return self.x #将传入的值加1,作为返回值
f1 = Foo(519) #实例化
print(f1.__next__()) #用__next__方法让它向后遍历
print(f1.__next__())
print(next(f1))
print(next(f1))
for i in f1: #遍历f1,实质上就是iter(f1)---->f1.__iter__()
print(i) #输出每次遍历得到的值
运行结果：
10、迭代器协议实现斐波那契数列
斐波那契数列概念：
这个数列从第3项开始，每一项都等于前两项之和。
下面用迭代器+类与对象来实现：
class Fib:
def __init__(self):
self.a=1 #定义两个初始值a,b
self.b=1
def __iter__(self):
return self #将属性字典变成可迭代对象
def __next__(self): #定义用来迭代的next方法
self.a,self.b = self.b, self.a+self.b
#将b的值赋值给a,即后面的一个数给前面的变量
#将a+b的值赋值给b,即前一个数和后一个数的和赋值给后一个变量
#设置停止条件
if self.a > 100:
raise StopIteration("斐波那契数列已遍历到指定长度")
return self.a #返回第一个值
p1 = Fib() #实例化
for i in p1: #遍历可迭代对象
print(i)
运行结果：
