面向对象高级

基本内置函数

1.基本内置函数的增删改查

class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
anyan=Person('anyan',18)

hasattr(anyan,‘name’)判断属性存不存在
getattr(anyan,‘name’)获取属性的属性值
setattr(anyan,‘age’,3)无则增，有则改
delattr(anyan,‘sex’)删除属性

2.检测属性是否存在

通过简单if 判断就能避免属性不存在时，
报错的问题，同时也可以设置属性值

class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    if hasattr(anyan,'sex'):  判断属性存不存在
        a=getattr(anyan,'sex') 存在的话输出
     else:
         setattr(anyan,'sex','female')  不存在的话添加
      
anyan=Person('anyan',18)

利用三目运算获取属性值

a=(getattr(anyan,'sex') if hasattr(anyan,'sex') else setattr(anyan,'sex','female'))

3.对象关系方法
所有类都是obiect的子类

①issubcalss(hunan,Person) 判断前面的类是不是后面类的子类

②isinstance(anyan,Person)判断前面的实例是不是属于后面实例出来的(前面是不是属于后面的类型)

③type(1)==int 判断数据类型，但是只能判断单个

class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age

class Hunan(Person):
    pass

anyan=('anyan',18)

issubclass(Hunan,Person)
→True
isinstance(anyana,Person)
→True

4.属性调用过程

item:接收实例的属性
查找不存在的属性时不会报错，而是返回该属性不存在。

class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age

   def __get__(self,item):        这个过程是重写函数
       print(f'{item}属性不存在')

魔法方法

1.先创建实例对象，再对于实例对象进行初始化

class Person:
    def __init__(self,name,age):
        print('调用初始方法')
        self.name=name
        self.age=age
        
__new__用来创建实例本身
cls 代表类本身
ay 创建出来的实例对象

   def __new__(cls,*args,**kwargs):  
       print('调用实例对象')
       ay=super().__new__(cls)
       return ay

anyan=('anyan',18)
moran=('moran',38)

→anyan is moran
→False

重写了new方法，直接调用super方法实例一个实例对象出来，创建出来的实例用变量ay接收

2.单例模式
类里面始终存在一个实例，不会同时出现多个实例。

让操作统一性。 new方法添加了if判断
例如:电脑回收站就是单例模式，loge也是

class Person:     类里面只能实例化一个对象
    def __init__(self,name,age):
        self.name=name
        self.age=age
    
    def __new__(cls,*args,**kwargs):
        if not hasattr(cls,'_instance'):   如果类里面没有_instance这个属性
        return cls._instance

anyan=('anyan',18)
moran=('moran',38)

→anyan is moran
→True

3.输出魔法方法
可以把地址值转为需要的数据(eg:元组)

str:是修改print()打印的样子 print()

repr:是修改直接打印的样子 直接回车

call:将实例对象变成可调用对象 直接加括号调用(eg:anyan())

class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __str__(self):
        return'this is str'
    
    def __repr__(self):
        return'this is repr'

    def __call__(self.num):
        num=num*10
        print(num)

anyan=('anyan',18)
moran=('moran',38)

协议

1.序列协议
有序，可下标取值
序列类型:列表，元组，字符串
dir(对象)

__getitem__
 
__len__长度方法，返回长度

class IndexTuple:
    def __init__(self,*rags):  *rags:初始化时通过不定长参数接收值
        self.values=tuple([i for i in rags])
        self.index=tuple(enumerate(self,values))

    def __len__(self): 长度方法，返回长度
        return len(self.values)
    def __getitem__(self.key):
        return self.index[key][1]  返回的是地址值，需要用到输出魔法方法
        
     def __repr__(self):  加输出魔法方法可以把地址值转为需要的数值类型
         return str(self.values)

通过枚举方法获取下标值

enumerate()函数可以将一个遍历对象组合成一个索引序列。同时列出数据下标和数据值

tu=IndexTuple('a','b','c')
tu.index
→(0,'a')

2.迭代器协议
迭代可遍历，与下标取值无关

__iter__:通过__iter__方法把类对象变成可迭代对象

__next__:通过__next__方法把可迭代对象变成迭代器，有next方法就是迭代器

raise StopIteration 主动抛出异常 ，停止迭代的意思

class Number:
    def __init__(self,end=10):
        self.start=0
        swlf.end=end
    
    def __iter__(self):
        return self
    def __next__(self):
        a=self.start   先保存初始值再循环
        if self.start＞= self.end:
            raise StopIteration
        self.start+=1
        return a

调用:for i in Number(10):
             print(i)

        

3.上下文协议

__enter__:只有with语句出现，__enter__方法就会被触发

__exit__:当__enter__方法执行完毕就会执行__exit__方法

time.time()返回当前时间的时间戳

def __exit__(self,exc_type,exc_val,exc_tb)
exc_type:异常类型
exc_val:异常值
exc_tb:追踪信息
只有当__enter__方法或者with下的代码块出现异常，才会有值，否则都为None

import time
class RunTime:
    def __enter__(self):
        self.start_time=time.time()
        return self.start_time
    def __exit__(self,exc_type,exc_val,exc_tb):
        self.end_time=time.time()
        self.run_time=self.end_time - self.start_time
        print(f'运行时间为:{self.run_time}')
       
with RunTime:
    for i in range(1000000):
        pass