#item 对象加中括号属性的时候才会调用到这几个内置函数,实至都是在对象或者类中对名称空间进行操作
#__setitem__   赋予新值的时候会触发这个函数
#__delitem__   删除的时候会触发这个函数
#__getitem__   查询的时候会触发这个函数
class People:
    def __init__(self,name):
        self.name=name

    def __getitem__(self, item):
        print("get")
        return self.__dict__[item]

    def __setitem__(self, key, value):
        print("set")
        self.__dict__[key]=value

    def __delitem__(self, key):
        self.__dict__.pop(key)

p=People("egon")
p["name"]           #触发__getitem__
p["age"]=123        #触发__setitem__
print(p["age"])

#__next__和__iter__方法实现迭代器协议
#示例一个类似range的函数

class Range:
    def __init__(self,start,end,num):
        self.start=start
        self.end=end
        self.num=num

    def __iter__(self):
        return self                   #迭代器返回的是其本身

    def __next__(self):
        if self.start>=self.end:
            raise StopIteration
        n=self.start                  #设置n是为了初始化self。start的值可以等于0
        self.start+=self.num
        return n
r=Range(0,10,3)

for i in r:                          #for可自动帮我捕捉到异常，使得程序不报错
    print(i)

class Foo:

    def __del__(self):
        print(‘执行我啦‘)

f1=Foo()
# del f1
print(‘------->‘)

#输出结果
------->
执行我啦





#为何啊？？？

class Foo:
    def __enter__(self):
        print("执行enter")

    def __exit__(self, exc_type, exc_val, exc_tb):
        return None

with Foo() as f:
    print("=======>")
    raise TypeError("cuowu")       #定义一个异常，用来触发__exit__

print("=======>22222")             #__exit__返回一个True的时候执行，不然就不执行

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print(‘__call__‘)


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

def run():
    print("runing")

class_name="People"
bases=(object,)
class_dict={
    "x":1,               #定义一个数据类型
    "run":run,           #定义一个函数类型
}

People=type(class_name,bases,class_dict)
print(People)

class Foo:
    pass
f1=Foo() #f1是通过Foo类实例化的对象
#type函数可以查看类型，也可以用来查看对象的类，二者是一样的
print(type(f1)) # 输出：<class ‘__main__.Foo‘>     表示，obj 对象由Foo类创建
print(type(Foo)) # 输出：<type ‘type‘> 

1 class Foo:
2     def func(self):
3         print(‘from func‘)

1 def func(self):
2         print(‘from func‘)
3 x=1
4 Foo=type(‘Foo‘,(object,),{‘func‘:func,‘x‘:1})

class Mytype(type):
    def __init__(self,class_name,bases=None,dict=None):
        print("Mytype init--->")
        print(class_name,type(class_name))
        print(bases)
        print(dict)

    def __call__(self, *args, **kwargs):
        print(‘Mytype call---->‘,self,args,kwargs)
        obj=self.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj

class Foo(object,metaclass=Mytype):#in python3
    #__metaclass__ = MyType #in python2
    x=1111111111
    def __init__(self,name):
        self.name=name

    def __new__(cls, *args, **kwargs):
        return super().__new__(cls)
        # return object.__new__(cls) #同上


f1=Foo(‘name‘)
print(f1.__dict__)

‘‘‘
1.__slots__是什么:是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)
2.引子:使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的是独立的)
3.为何使用__slots__:字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__dict__
当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个
字典,这跟元组或列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给
实例添加新的属性了,只能使用在__slots__中定义的那些属性名。
4.注意事项:__slots__的很多特性都依赖于普通的基于字典的实现。另外,定义了__slots__后的类不再 支持一些普通类特性了,比如多继承。大多数情况下,你应该
只在那些经常被使用到 的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象 。
关于__slots__的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管使用__slots__可以达到这样的目的,但是这个并不是它的初衷。           更多的是用来作为一个内存优化工具。

‘‘‘
class Foo:
    __slots__=‘x‘


f1=Foo()
f1.x=1
f1.y=2#报错
print(f1.__slots__) #f1不再有__dict__

class Bar:
    __slots__=[‘x‘,‘y‘]
    
n=Bar()
n.x,n.y=1,2
n.z=3#报错