python进阶－面向对象编程五：类的内置方法
类的使用本质是调用类的内置方法
__getitem__， __setitem__，__delitem__，__delattr__
# __getitem__， __setitem__，__delitem__，__delattr__
# 对象的属性进行获取、修改、删除时候触发的内置方法
class Foo:
def __init__(self,name):
self.name=name
def __getitem__(self, item):
print(self.__dict__[item])
def __setitem__(self, key, value):
self.__dict__[key]=value
def __delitem__(self, key):
print('del obj[key]时,我执行')
self.__dict__.pop(key)
def __delattr__(self, item):
print('del obj.key时,我执行')
self.__dict__.pop(item)
f=Foo("adamander")
print(f.name)
print(f['name'])
f['age']=18
f['age1']=19
print(f['age'])
print(f.age1)
del f.age1
del f['age']
print(f.__dict__)
# 内置方法：__slots__
#使用类.xxx,或者对象.xxx,来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的字典是独立的)
#字典会占用大量的内存，如果有一个属性很少的类，但是实例很多的类，用__slots__来代替__dict__,限制对象属性数量，
# 对所有对象属性统一管理，
#节省内存.缺点是不能再给实例添加新属性,只能用里面有的。
class People:
__slots__ = ['x','y','z']
p=People()
p.x=10
p.y=20
p.z=30
print(p.x,p.y,p.z)
#实现迭代器协议的内置方法：__iter__,__next__
#实现迭代器协议的内置方法：__iter__,__next__
from collections import Iterable,Iterator
class Foo:
def __init__(self,start):
self.start=start
def __iter__(self):
return self
def __next__(self):
n=self.start
self.start+=1
return n
f=Foo(0)
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
#一直不停的往下加
# for i in f:
# print(i)
print("************************")
# 实现range类，__next__进行StopIteration处理
# 实现range类，__next__进行StopIteration处理
class Range:
def __init__(self,start,end):
self.start=start
self.end=end
def __iter__(self):
return self
def __next__(self):
if self.start==self.end:
raise StopIteration
n=self.start
self.start+=1
return n
for i in Range(3, 8):
print(i)
# r=Range(3,11)
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
析构方法___del__
# 析构方法___del__析构方法，当对象在内存中被释放时，自动触发执行。
# 注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，
# 因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
#垃圾回收机制，del 立即删除，不然等其他执行完毕，自动回收
import time
class Open:
def __init__(self,filename,mode='r',encoding='utf-8'):
self.file=open(filename,mode,encoding=encoding)
def __enter__(self):
print("enter=====>")
return self
def write(self,line):
t=time.strftime('%Y-%m-%d %T')
self.file.write('%s %s' %(t,line))
def __getattr__(self, item):
return getattr(self.file,item)
def __del__(self):
print("===>del")
def __exit__(self, exc_type, exc_val, exc_tb):
# print("exit")
# print("exc_type",exc_type)
# print("exc_val",exc_val)
# print("exc_tb",exc_tb)
self.file.close()
with Open('b.txt','w+') as f:
f.write("xxxx")
f.write("xxxx")
f.write("xxxx")
# __call__实例调用
# __call__实例调用
# __call__实例调用，没有他，实例是不可调用的
class People:
def __init__(self,name):
self.name=name
# def __call__(self, *args, **kwargs):
# pass
p=People("ada")
print(callable(People))
#True
print(callable(p))
#False,然而放开注释就是True
