标签：方法 名称 dict 程序 信息 == %x ada 是什么
__setitem__ __getitem__ __delitem__
把对象操作属性模拟成字典的格式：
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)
f1=Foo(‘sb‘)
f1[‘age‘]=18
f1[‘age1‘]=19
del f1.age1
del f1[‘age‘]
f1[‘name‘]=‘alex‘
print(f1.__dict__)
>>>:
del obj.key时,我执行
del obj[key]时,我执行
{‘name‘: ‘alex‘}
class Foo:
__slots__=[‘name‘,‘age‘,‘sex‘] #限定绑定的对象只有3个属性
p = Foo()
p.age = 18
# print(p.__dict__) #打印p对象字典会报错，提示‘Foo‘ object has no attribute ‘__dict__‘
p.sex = ‘male‘
p.name = ‘Mitsui‘
print(p.name,p.sex,p.age)
__next__和__iter__：（实现迭代器协议）
class My_range:
def __init__(self,start,end):
self.start = start
self.end = end
def __iter__(self):
return self
def __next__(self):
n = self.start
self.start += 1
if n == self.end:
raise StopIteration
return n
f = My_range(1,10)
for i in f:
print(i)
__doc__： 查看注释信息 无法被继承
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
__del__ 析构方法，当对象在内存中被释放时，自动触发执行。
class Foo: def __del__(self): print(‘执行我啦‘) f1=Foo() del f1 print(‘------->‘) >>>>: 执行我啦 #del 对象被释放，所以运行了里面的print -------> #如果没有del f1 则会先运行------>然后整个程序运行结束 也会打印__del__里面 ‘执行我啦’。
import time
class Open:
def __init__(self,filepath,mode=‘r‘,encode=‘utf8‘):
self.f = open(filepath,mode=mode,encoding=encode)
def __enter__(self):
return self #(‘出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量‘) #这里return self 而不是self.f 是因为self.f是原本open功能的句柄，return self.f 下面引用f.write 将是应用原本文件写功能，而不是自己定制的write，所以return self 赋给 f，f.write则会调用自己定制的write
def write(self, line): # 定制自己的文件写功能
print(‘f自己的write‘,line)
t=time.strftime(‘%Y-%m-%d %X‘) #得到一个格式输出的时间 年Y月m日d 时分秒X
self.f.write(‘%s %s‘ %(t,line))
def __getattr__(self, item):
return getattr(self.f,item)
def __exit__(self, exc_type, exc_val, exc_tb):
self.f.close() #with 代码结束时执行，仿原本的with open 起到一个关闭文件的作用
with Open(‘b.txt‘,‘w+‘)as f:
f.write(‘自己的日志写功能‘)
f.seek(0)
print(f.read())
1.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
2.在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，你无须再去关系这个问题，这将大有用处
__call__
构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo: def __init__(self): pass def __call__(self, *args, **kwargs): print(‘__call__‘) obj = Foo() obj() #对象加（）触发__call__ 打印输出“__call__”
1.首先看看一个类是如何生成的：
1 # 自定义一个类： 2 def run(self): 3 print(‘%s is running‘ % self.name) #定义一个函数run 4 class_name = ‘Foo‘ #定义类名 5 class_dic={ #定义类里边的__dic__ 参数 6 ‘name‘:‘Mitsui‘, 7 ‘run‘:run 8 } 9 bases = (object,) 10 Foo = type(class_name,bases,class_dic) #type手动创建一个类
标签：方法 名称 dict 程序 信息 == %x ada 是什么
原文地址：http://www.cnblogs.com/mitsui/p/6764036.html
