==== __del__ 功能演示 ====

class MetaClass(type):   元类必须继承type
    name = 元类"

    __del__(self):
        执行元类中的__del__)


class MyClass(object,metaclass=MetaClass):
    author = 云崖__init__(self,name):
        self.name = name
        执行了 __init__ )


    执行del...)

m1 = MyClass(Yunya)
del m1.name


执行了 __init__ 
执行元类中的__del__
执行del...
"""

 ==== __del__ 应用场景 ====
#需求: 定制一个文件读写的类，带有自动close功能。

 FileHandle(object):
    __init__(self,filename,mode=rt",encoding=utf-8):
        self.file = open(file=filename,mode=mode,encoding=encoding)


    发起系统调用，清理open()打开的系统内存资源...)
        self.file.close()   防止忘记关闭

f = FileHandle(1.txt)
content = f.file.read()
(content)
======>)


apple 10 3
tesla 100000 1
mac 3000 2
lenovo 30000 3
chicken 10 3
======>
发起系统调用，清理open()打开的系统内存资源...
"""

 ==== __getattr__ __setattr__ __delattr__功能演示 ====

__getattr__执行元类中的__getattr__)

    __setattr__执行元类中的__setattr__return super(MetaClass,1)">(key,value)

    __delattr__执行元类中的__delattr__(item)


执行__getattr__执行__setattr__ self.key=value #这就无限递归了,你好好想想
        self.__dict__[key] = value

    执行__delattr__ del self.item #无限递归了
        del self.__dict__[item]


 ==== 对类对象的attr操作 ==== 对自定义的元类进行__getattr__与__delattr__的方法的定制时，无法直接操纵底层__dict__。需要调用父类或type元类中的这2种方法
(MyClass.name)
print(MyClass.sex)   执行元类中的 __getattr__ 属性不存在
MyClass.name = metaclass"   执行元类中的 __setattr__ 设置属性
del MyClass.name   执行元类中的 __delattr__ 删除属性

 ==== 对实例对象的attr操作 ====
m1 = MyClass(")   新增，对应类中的 __setattr__ 设置属性
(m1.name)
print(m1.sex)   执行类中的 __getattr__ 属性不存在
m1.name = 小帅哥 执行 类中的 __setattr__ 设置属性
del m1.name   执行类中的 __delattr__ 删除属性


元类
执行元类中的__getattr__
None
执行元类中的__setattr__
执行元类中的__delattr__
执行__setattr__
执行了 __init__ 
Yunya
执行__getattr__
None
执行__setattr__
执行__delattr__
"""

 ==== 注意事项：__getattribute__ 与 __getattr__ 共存 ====

 Foo:
    __getattr__(self,item):   如果存在__getattr__，则会捕获到AttributeError的异常。
        '只有在__getattribute__抛出AttributeError后才会执行__getattr__' return self.__dict__[item]

    __getattribute__不管属性是否存在都会执行__getattribute__')   有则返回，无则抛出异常
        raise AttributeError(你查找的属性不存在 当查找属性不存在时，抛出 AttributeError后才会执行__getattr__，否则只会执行AttributeError..

f1=Foo()
(f1.xxxxxx)


当__getattribute__与__getattr__同时存在,只会执行__getattrbute__,除非__getattribute__在执行过程中抛出异常AttributeError


不管属性是否存在都会执行__getattribute__
只有在__getattribute__抛出AttributeError后才会执行__getattr__
None
"""

 ==== __getattr__ 应用场景 ==== 需求: 定制一个文件读写的类，要求写的每一行都加上时间显示的功能

 time

):
        self.__file = open(file=filename,1)">encoding)

    def write(self,content):
        data = time.strftime(%Y-%m-%d : %X)
        self.__file.write({0}:{1}n.format(data,content))

    return getattr(self.__file,item)   相当于拿到文件句柄中的某一个方法并返回

    (self):
        self.__file.close() (f.read())


apple 10 3
tesla 100000 1
mac 3000 2
lenovo 30000 3
chicken 10 3
"""

 ==== __getitem__ __setitem__ __delitem__功能演示 ====

__getitem__执行元类中的__getitem__if hasattr(MetaClass,item):
            return getattr(MetaClass,item)
        return self.[item]

    __setitem__执行元类中的__setitem__)
        setattr(self,1)">__delitem__执行元类中的__delitem__)
        delattr(self,item)


执行__getitem__执行__setitem__执行__delitem__ ==== 对类对象的item操作 ====
print(MyClass[name"])   执行元类中的__getitem__ 获取属性
MyClass["] =  执行元类中的 __setitem__ 设置属性
del MyClass["]   执行元类中的 __delitem__ 删除属性

 ==== 对实例对象的item操作 ====
m1 = MyClass( 新增，对应类中的 __setitem__ 设置属性
print(m1[ 执行__getitem__  获取属性
m1[ 执行 类中的 __setitem__ 设置属性
del m1[ 执行类中的 __delitem__ 删除属性


执行元类中的__getitem__
元类
执行元类中的__setitem__
执行元类中的__delitem__
执行了 __init__ 
执行__getitem__
Yunya
执行__setitem__
执行__delitem__
"""

 ==== 注意事项：__getitem__ 代替 __iter__ ====

__getitem__(self,1)"> __getitem__可以隐式的创建迭代器
        pass    如果不实现该方法或者 __iter__ 方法。会抛出异常： TypeError: 'Foo' object is not iterable


f1=print(iter(f1))   可以看见，没有实现__iter__方法也能创建迭代器





<iterator object at 0x000001DF109802E0>
"""

 ==== 扩展:__getitem__如何区分切片与取值 ====


通过实现双下getitem方法后我们的类其实就能进行迭代。
当然这是残缺不全的，要想真正的让我们的类变的和列表一样具有切片和取值功能。
我们需要对双下getitem进行更加详细的重写
"""

from numbers import Integral  取值操作全部来源于该类

 My_list(object):
     args
     <class '__main__.My_list'>
        if isinstance(item,Integral): 如果是取值操作
            return cls(self.args[item])返回新的My_list实例,注意必须是可迭代形式
        elif isinstance(item,slice): 若是切片操作
            return cls(self.args[item])  返回新的My_list实例
    __repr__ str(self.args)

l = My_list([1,3])
print(l[1print(l[0:2])


2
[1,2]
"""

 ==== __str__ 功能演示 ====

 MyClass(object):

     name

    __str__(self):   注意：__str__必须返回str类型
         str(self.name)

m1 = MyClass(print(m1)   云崖

 ==== __repr__ 功能演示 ==== ==== 交互式环境下 ====

>>>  MyClass(object):
...      name
...     __repr__(self):   注意：__repr__必须返回str类型
...              str(self.name)
...
>>> m1 = MyClass()
>>> m1
云崖
>>>

 ==== __format__ 功能演示 ====

date_dic = {
    ymd': {0.year}:{0.month}:{0.day},dmy{0.day}/{0.month}/{0.year}mdy{0.month}-{0.day}-{0.year} Date:
     year
        self.month = month
        self.day = day

    __format__if not format_spec or format_spec not in date_dic:
            format_spec = 
        fmt = date_dic[format_spec]
        return fmt.format(self)   self.year:self.month:self.day


d1 = Date(2016,12,29(format(d1))
{0:mdy}.format(d1))


2016:12:29
12-29-2016
"""

 ==== __enter__ __exit__ 功能演示 ====

 Open:
    name

    __enter__出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量 return self
    __exit__with中代码块执行完毕时执行我啊)


with Open(a.txt) as f:
    =====>执行代码块)
     print(f,f.name)


出现with语句,有返回值则赋值给as声明的变量
=====>执行代码块
with中代码块执行完毕时执行我啊
"""

 ==== with代码块中的异常由__exit__接管 ====

(exc_type)
        (exc_val)
        (exc_tb)
         如果返回False代表不处理这些异常


with Open(***着火啦,救火啊***0'*100) ------------------------------->不会执行

"""
__exit__中的异常    

 ==== __exit__返回True代表捕捉异常 ====

return True   返回True代表捕捉异常



with Open(------------------------------->会执行

"""