面向对象高级提升和魔法方法、协议

面向对象高级

##class Person:

def init(self,name,age):

self.name = name

self.age = age

增删改查

hasattr(anyan,‘name’) 判断属性存不存在

getattr(anyan,‘name’) 获取属性的属性值

setattr(anyan,‘age’,3) 无则增，有则改

delattr(anyan,‘sex’) 删除属性

issubclass(Hunan,Person) 判断前面的类是不是后面类的子类

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

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

##class Person:

def init(self,name,age):

self.name = name

self.age = age

##anyan = Person(‘anyan’,18)

##class Hunan(Person):

pass

##if hasattr(anyan,‘sex’):

a = getattr(anyan,‘sex’)

##else:

setattr(anyan,‘sex’,‘female’)

##a = getattr(anyan,‘sex’) if hasattr(anyan,‘sex’) else setattr(anyan,‘sex’,‘female’)

属性调用过程

##class Person:

def init(self,name,age):

self.name = name

self.age = age

# item接收实例的属性

def getattr(self,item):

print(f’{item}属性不存在’)

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

##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 = Person(‘anyan’,18)
##moran = Person(‘moran’,38)

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

##class Person:

def init(self,name,age):

self.name = name

self.age = age

def new(cls,*args,**kwargs):

# 如果类里面没有_instance这个属性

if not hasattr(cls,’_instance’):

cls._instance = super().new(cls)

return cls._instance

##anyan = Person(‘anyan’,18)
##moran = Person(‘moran’,38)

输出魔法方法

__str__是修改print打印时的样子

__repr__是修改直接打印时的样子

##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 = Person(‘anyan’,18)
##moran = Person(‘moran’,38)

协议

序列协议：getitem，len

##class IndexTuple:

def init(self,*args):

self.values = tuple([i for i in args])

# 通过枚举方法获取下标值

# enumerate()函数可以将一个可遍历对象组合成一个索引序列，

# 同时列出数据下标和数据值

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)

迭代器协议:iter，next

##class Number:

def init(self,end=10):

self.start = 0

self.end = end

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

def iter(self):

return self

# 通过__next__方法把可迭代对象变成迭代器

def next(self):

a = self.start

if self.start >= self.end:

raise StopIteration # 主动抛出异常

self.start += 1

return a

上下文协议

import time
class RunTime:
# 只要with语句已出现，enter方法就会被触发
def enter(self):
# time.time()返回当前时间的时间戳
self.start_time = time.time()
return self.start_time

# 当__enter__方法执行完毕就会执行__exit__方法
# exc_type:异常类型
# exc_val:异常值
# exc_tb:追踪信息
#只有当__enter__方法或者with下的代码块出现异常，才会有值，否则都为None
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}')