初学者python笔记（类的内置属性）

前几篇关于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)  

运行结果：