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

迈不过友情╰ 2023-07-15 15:26 14阅读 0赞

### 文章目录 ###

*   *   *   *  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的类型，其实就是它所属的类

运行结果：  
![两个is][is]

#### 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结果：  
![AttributeError][]  
TabError结果：  
![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']  #删除属性

运行结果：  
![item系列][item]

#### 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__()

运行结果：  
![\_\_str\_\_][str]

#### 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'))  #一个不存在的格式将按默认格式输出

运行结果：  
![自定制格式化方法][20200317170944462.png]

#### 6、\_\_doc\_\_描述属性 ####

class Foo:
        '这是Foo的描述信息'
        pass
    
    class Bar(Foo):
        pass
    
    print(Foo.__dict__)
    print(Foo.__dict__)  #描述信息也被继承了，所以两个字典里都有该键值对

运行结果：  
![\_\_doc\_\_][doc]

#### 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('--------------->')

运行结果：  
![析构函数][20200317171148764.png]

#### 8、\_\_call\_\_方法 ####

作用分析：一个对象加()就是在调用生成它的类下的\_\_call\_\_方法

class Foo:
        def __call__(self,*args,**kwargs):
            print('实例带括号，执行啦')
    
    f = Foo()  #实例化
    f()

运行结果：  
![\_\_call\_\_方法][call]

#### 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)  #输出每次遍历得到的值

运行结果：  
![迭代器协议][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpZXdpbmZpbml0ZWx5_size_16_color_FFFFFF_t_70]

#### 10、迭代器协议实现斐波那契数列 ####

**斐波那契数列概念：**  
![斐波那契数列][20200317171625952.png]  
这个数列从第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)

运行结果：  
![迭代器实现斐波那契数列][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpZXdpbmZpbml0ZWx5_size_16_color_FFFFFF_t_70 1]

[is]: /images/20230528/0bc6d42f3bb34bf1bbc96ab0ec13c674.png
[AttributeError]: /images/20230528/c36dd5c9aa09478b837745f26572d307.png
[TabError]: /images/20230528/9cf6b4a1601a46bf9cf1df3a6b0f6b06.png
[item]: /images/20230528/f1f240d8a004431390310e2f2ee327e8.png
[str]: /images/20230528/2297e4cfe8774a358b3431c2f470bba1.png
[20200317170944462.png]: /images/20230528/792b2ba353dc4554be878f2a754c0b45.png
[doc]: /images/20230528/ba3de3ce9d574d0b9841e4ed8cf34a63.png
[20200317171148764.png]: /images/20230528/dc261fd97c4b4d9cb0b001d522505c45.png
[call]: /images/20230528/819c784ca0f64947addb6d499b7a757e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpZXdpbmZpbml0ZWx5_size_16_color_FFFFFF_t_70]: /images/20230528/1c7363522d8b4809805d6ff633c87ef6.png
[20200317171625952.png]: /images/20230528/6135abbb142946e4ba46ad575251c87d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpZXdpbmZpbml0ZWx5_size_16_color_FFFFFF_t_70 1]: /images/20230528/1b48411e29b04535ad5ce57e604459b6.png