#上下文协议：文件操作时使用with执行
# with open('a.txt','w',encoding='utf-8') as f1:
# with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法
# class Open:
# def __init__(self,name):
# self.name = name
# def __enter__(self):
# print('如果出现with语句，__enter__就被触发')
# def __exit__(self, exc_type, exc_val, exc_tb):
# print('with语句一旦执行完毕，__exit__就会被触发')
# with Open('a.txt') as f1:
# print('各种执行代码块')
# 如果出现with语句，__enter__就被触发
# 各种执行代码块
# with语句一旦执行完毕，__exit__就会被触发
########################################################################################################
# __exit__()中的三个参数分别代表异常类型，异常值和追溯信息,with语句中代码块出现异常，则with后的代码都无法执行
# class Open:
# def __init__(self,name):
# self.name = name
# def __enter__(self):
# print('如果出现with语句，__enter__就被触发')
# def __exit__(self, exc_type, exc_val, exc_tb):
# print('with语句一旦执行完毕，__exit__就会被触发')
# with Open('a.txt') as f1:
# print('各种执行代码块')
# raise AttributeError ('抛出一个超级异常')
# print('我就不会被执行了')
# 如果出现with语句，__enter__就被触发
# 各种执行代码块
# with语句一旦执行完毕，__exit__就会被触发
# Traceback (most recent call last):
# File "F:/Python/PythonLeaning/每日学习打卡/Day28.py", line 27, in <module>
# raise AttributeError ('抛出一个超级异常')
# AttributeError: 抛出一个超级异常
########################################################################################################
# class Open:
# def __init__(self,name):
# self.name = name
# def __enter__(self):
# print('如果出现with语句，__enter__就被触发')
# def __exit__(self, exc_type, exc_val, exc_tb):
# print('with语句一旦执行完毕，__exit__就会被触发')
# return True #执行时即使报错也当错误不存在
# with Open('a.txt') as f1:
# print('各种执行代码块')
# raise AttributeError ('抛出一个超级异常')
# print('我就会继续被执行了，因为__exit__被加了return True')
########################################################################################################
# 用途或者说好处：
# 1.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
# 2.在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，
# 你无须再去关系这个问题，这将大有用处
########################################################################################################
# NameError:异常类-->class
# name 'asda' is not defined-->异常值
# Traceback -->追溯信息
########################################################################################################
#描述符
# 一、描述符本身应该定义成新式类(继承了object类)，被代理的类也应该是新式类
# 二、必须把描述符定义成这类的类属性，不能低昂一道构造函数中
# 三、要严格遵循优先级
# python是弱类型语言：不用定义变量的类型就可以使用
# def test(x):
# print('---->',x)
# test('a')
# test(1)
# 为python加上类型检测：
# class Typed:
# def __init__(self,key,excepted_type):
# self.key= key
# self.excepted = excepted_type
# def __get__(self, instance, owner):
# print('get方法')
# # print('instance 参数【%s】'%instance)
# # print('owner 参数【%s】'%owner)
# return instance.__dict__[self.key]
# def __set__(self, instance, value):
# print('set方法')
# # print('instance 参数【%s】'%instance)
# # print('value 参数【%s】'%value)
# # print('---->',instance)
# if not isinstance(value,self.excepted):
# print('你传入的类型不是字符串，错误')
# return
# else:
# instance.__dict__[self.key] = value
# class People:
# name = Typed('name',str)
# age = Typed('age',int)
# # age = Typed('age')
# def __init__(self,name,age,salary):
# self.name = name #触发的是被代理，而不是实例化
# self.age = age
# self.salary = salary
# # p1 = People('panda',18,2100.1245)
# p2 = People(9527,18,29213)
# # print(p1.name)
# # p2 = People(1,10,20)
# # print(p1.__dict__)
# # print(p1.name)
# print(p2.name)
########################################################################################################
# 类的装饰器原理
# def deco(obj):
# print('----------->>>>',obj)
# obj.x = 1
# obj.y = 2
# obj.x = 3
# return obj
# # @deco #dtest = deco(test)
# # def test():
# # print('test函数运行')
# # test()
# @deco #Foo = deco(Foo)
# class Foo:
# pass
# f1 = Foo()
# print(Foo.__dict__)
########################################################################################################
# def Typed(*args,**kwargs):
# def deco(obj):
# print('---->>',kwargs)
# print('---->>', obj)
# for key ,val in kwargs.items():
# setattr(obj,key,val)
# return obj
# print('==>',kwargs)
# return deco
# @Typed(x = 1,y = 2,z = 3)
# class Foo:
# pass
# print(Foo.__dict__)
# @Typed(name = 'egg')
# class Bar:
# pass
# 用装饰器为类增加一个数据属性
########################################################################################################
# 再看property
# 一个静态属性property本质就是实现了get，set，delete三种方法
# class Lazyproperty:
# def __init__(self,func):
# self.func = func
# def __get__(self, instance, owner):
# print('我是get方法')
# if instance is None:
# return self
# res = self.func(instance)
# setattr(instance,self.func.__name__,res)
# return res
# class Room:
# def __init__(self,name,width,length):
# self.name = name
# self.width = width
# self.length = length
# @ Lazyproperty #area = property(area) 给Room添加了一个类对象
# def area(self):
# return self.width * self.length
# @property #test = property(test)
# def area1(self):
# return self.width * self.length
# @property
# def test(self):
# return ('返回一个值')
# r1 = Room('toilet',1,2)
# #实例调用
# # print(r1.area)
# # print(Room.__dict__)
# # 类调用
# #print(Room.area)
# print(r1.area)
# print(r1.__dict__)
# print(r1.area)
# print(r1.area)
# print(r1.area)
# print(r1.test)
#函数运行时要把实例本身传入，而不是类
#描述符用来代理类的属性
# 类调用的instance传入的是None，实例调用的instance传入的是self
########################################################################################################
# 延迟计算的功能：对于已经运行的函数，将结果存储在内存中，下一次调用方法的时候就不再运行函数而是直接调用
# (本质就是把一个函数属性利用装饰器原理做成一个描述符：类的属性字典中函数名为key，value为描述符类产生的对象)
# 描述符是很多高级库和框架的重要工具之一，描述符是通常使用到装饰器或者元类的大型框架中的一个组件
# class Foo:
# @property
# def AAA(self):
# print('get的时候运行我')
# return self
# @AAA.setter
# def AAA(self,value):
# print('set的时候运行我',value)
# @AAA.deleter
# def AAA(self,value):
# print('delete的时候运行我')
# f1 = Foo()
# f1.AAA = 'aaa'
########################################################################################################
# class Foo:
# def get_AAA(self):
# print('get的时候运行我')
# return self
# def set_AAA(self,value):
# print('set的时候运行我')
# def del_AAA(self):
# print('delete的时候运行我')
# AAA = property(get_AAA,set_AAA,del_AAA)
# # 只有属性在AAA定义property后才能定义AAA，setter，AAA，delete
# f1 = Foo()
# f1.AAA = 'aaa'
########################################################################################################
# metaclass--->元类
# class Foo:
# pass
# f1 = Foo() #f1是通过Foo实例化对象
# python中一切皆是对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会创建一个对象
# (这里的对象指的是类而非类的实例)
# f1是Foo这个类产生的对象，而Foo本身也是对象
# print(type(f1))
# print(type(Foo))
#————————————————————————————————————————————————————#
# 什么是元类？
# 元类是类的类，是类的模板
# 元类是用来控制如何创建类的，正如类是创建对象的模板一样
# 元类的实例为类，正如类的实例对象(f1对象是Foo类的一个实例，Foo类是type类的一个实例)
# type是python的一个內建元类，用来控制生成类，python中任何class定义的类其实都是type实例化的对象
# type(类名，object，属性字典)
# class Foo:
# def __init__(self,name):
# self.name = name
# pass
# print(Foo)
# def __init__(self,name,age):
# self.name = name
# self.age = age
# FFo = type('FFo',(object,),{'x':1,'__init__':__init__})
# print(FFo)
# print(FFo.__dict__)
# f1 = FFo('alex',19)
# print(f1.name)
# class MyType(type):
# def __init__(self,a,b,c):
# print('元素的构造函数执行')
# # print(a)
# # print(b)
# # print(c)
# def __call__(self, *args, **kwargs):
# print('====>')
# print(self)
# print(*args,**kwargs)
# obj = object.__new__(self)
# self.__init__(obj,*args,**kwargs) #实际在执行Foo.__init__()
# class Foo(metaclass=MyType): #type('Foo',(object),{}) MyType传入了4个参数
# def __init__(self,name):
# self.name = name
# f1 = Foo('OneName')
# 练习一：在元类中控制把自定义类的数据属性都变成大写