__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‘}

__slots__:

由类产生的对象不再产生自身名称空间，可以节省内存,也可以限定产生的属性。

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__里面 ‘执行我啦’。

__enter__和__exit__：

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__”

metaclass：

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手动创建一个类