python(描述符应用与类的装饰器)
__enter__和__exit__
数据描述符：至少实现__get__，__set__方法的
非数据描述符：没有__set__方法的
上下文管理协议（with语句）改写，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法。
# -*- coding: utf-8 -*-
class Open:
def __init__(self,name):
self.name=name
def __enter__(self):
print(‘出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量‘)
# return self
def __exit__(self, exc_type, exc_val, exc_tb):
print(‘with中代码块执行完毕时执行我啊‘)
with Open(‘b.txt‘) as f:
print(‘=====>执行代码块‘)
# print(f,f.name)# -*- coding: utf-8 -*-
class Open:
def __init__(self,name):
self.name=name
def __enter__(self):
print(‘出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量‘)
def __exit__(self, exc_type, exc_val, exc_tb):
print(‘with中代码块执行完毕时执行我啊‘)
#下面三个ext执行完毕就代表with代码块里的语句执行完毕，出现异常，下面的代码不再执行
print(exc_type) #异常类型
print(exc_val) #异常值
print(exc_tb) #追溯信息
with Open(‘b.txt‘) as f: #触发__enter__
print(‘=====>执行代码块‘)
raise AttributeError(‘***着火啦,救火啊***‘)
print(‘0‘*100) #------->不会执行用途：
1.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
2.在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制
描述符应用
控制输入类型
# -*- coding: utf-8 -*-
class Typed:
def __init__(self,key):
self.key=key
def __get__(self,instance,owner):
print(‘get方法‘)
# print(‘isinstance参数;‘,isinstance)
# print(‘owner参数;‘,owner)
return instance.__dict__[self.key]
def __set__(self,instance,value):
print(‘set方法‘)
# print(‘isinstance参数;‘,instance)
# print(‘owner参数;‘,value)
#通过初始化函数写活了
if not isinstance(value,str):
print(‘输入不是字符串‘)
else:
instance.__dict__[self.key]=value
def __delete__(self,instance):
print(‘delete方法‘)
# print(‘isinstance参数;‘, instance)
instance.__dict__.pop(self.key)
class people:
name=Typed(‘name‘)
# age=Typed(‘age‘)
def __init__(self,name,age,salary):
self.name=name
self.age=age
self.salary=salary
p1=people("bob",22,5000)
p1.name
print(p1.__dict__) #没有name属性，他被数据描述符代理了
del p1.name
print(p1.__dict__)
p2=people(1,22,5000)进一步改进
# -*- coding: utf-8 -*-
class Typed:
def __init__(self,key,expected_type):
self.key=key
self.expected_type=expected_type
def __get__(self,instance,owner):
# print(‘get方法‘)
# print(‘isinstance参数;‘,isinstance)
# print(‘owner参数;‘,owner)
return instance.__dict__[self.key]
def __set__(self,instance,value):
# print(‘set方法‘)
# print(‘isinstance参数;‘,instance)
# print(‘owner参数;‘,value)
#通过初始化函数写活了
if not isinstance(value,self.expected_type):
print(‘输入不是%s‘%self.expected_type)
else:
instance.__dict__[self.key]=value
def __delete__(self,instance):
print(‘delete方法‘)
# print(‘isinstance参数;‘, instance)
instance.__dict__.pop(self.key)
class people:
name=Typed(‘name‘,str)
age=Typed(‘age‘,int)
salary=Typed(‘salary‘,float)
def __init__(self,name,age,salary):
self.name=name
self.age=age
self.salary=salary
p1=people("bob",22,5000.0)
p1.name
print(p1.__dict__) #没有name属性，他被数据描述符代理了
del p1.name
print(p1.__dict__)
p2=people(1,22,5000.0)类的装饰器
初级（没有参数）：
# -*- coding: utf-8 -*-
def decorate(cls):
print(‘类的装饰器开始运行啦------>‘)
return cls
@decorate #无参:People=decorate(People)
class People:
def __init__(self,name,age,salary):
self.name=name
self.age=age
self.salary=salary
print(self.age,self.name,self.salary)
p1=People(‘egon‘,18,3333.3) ------------恢复内容开始------------
__enter__和__exit__
数据描述符：至少实现__get__，__set__方法的
非数据描述符：没有__set__方法的
上下文管理协议（with语句）改写，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法。
# -*- coding: utf-8 -*-
class Open:
def __init__(self,name):
self.name=name
def __enter__(self):
print(‘出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量‘)
# return self
def __exit__(self, exc_type, exc_val, exc_tb):
print(‘with中代码块执行完毕时执行我啊‘)
with Open(‘b.txt‘) as f:
print(‘=====>执行代码块‘)
# print(f,f.name)# -*- coding: utf-8 -*-
class Open:
def __init__(self,name):
self.name=name
def __enter__(self):
print(‘出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量‘)
def __exit__(self, exc_type, exc_val, exc_tb):
print(‘with中代码块执行完毕时执行我啊‘)
#下面三个ext执行完毕就代表with代码块里的语句执行完毕，出现异常，下面的代码不再执行
print(exc_type) #异常类型
print(exc_val) #异常值
print(exc_tb) #追溯信息
with Open(‘b.txt‘) as f: #触发__enter__
print(‘=====>执行代码块‘)
raise AttributeError(‘***着火啦,救火啊***‘)
print(‘0‘*100) #------->不会执行用途：
1.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
2.在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制
描述符应用
控制输入类型
# -*- coding: utf-8 -*-
class Typed:
def __init__(self,key):
self.key=key
def __get__(self,instance,owner):
print(‘get方法‘)
# print(‘isinstance参数;‘,isinstance)
# print(‘owner参数;‘,owner)
return instance.__dict__[self.key]
def __set__(self,instance,value):
print(‘set方法‘)
# print(‘isinstance参数;‘,instance)
# print(‘owner参数;‘,value)
#通过初始化函数写活了
if not isinstance(value,str):
print(‘输入不是字符串‘)
else:
instance.__dict__[self.key]=value
def __delete__(self,instance):
print(‘delete方法‘)
# print(‘isinstance参数;‘, instance)
instance.__dict__.pop(self.key)
class people:
name=Typed(‘name‘)
# age=Typed(‘age‘)
def __init__(self,name,age,salary):
self.name=name
self.age=age
self.salary=salary
p1=people("bob",22,5000)
p1.name
print(p1.__dict__) #没有name属性，他被数据描述符代理了
del p1.name
print(p1.__dict__)
p2=people(1,22,5000)进一步改进
# -*- coding: utf-8 -*-
class Typed:
def __init__(self,key,expected_type):
self.key=key
self.expected_type=expected_type
def __get__(self,instance,owner):
# print(‘get方法‘)
# print(‘isinstance参数;‘,isinstance)
# print(‘owner参数;‘,owner)
return instance.__dict__[self.key]
def __set__(self,instance,value):
# print(‘set方法‘)
# print(‘isinstance参数;‘,instance)
# print(‘owner参数;‘,value)
#通过初始化函数写活了
if not isinstance(value,self.expected_type):
print(‘输入不是%s‘%self.expected_type)
else:
instance.__dict__[self.key]=value
def __delete__(self,instance):
print(‘delete方法‘)
# print(‘isinstance参数;‘, instance)
instance.__dict__.pop(self.key)
class people:
name=Typed(‘name‘,str)
age=Typed(‘age‘,int)
salary=Typed(‘salary‘,float)
def __init__(self,name,age,salary):
self.name=name
self.age=age
self.salary=salary
p1=people("bob",22,5000.0)
p1.name
print(p1.__dict__) #没有name属性，他被数据描述符代理了
del p1.name
print(p1.__dict__)
p2=people(1,22,5000.0)类的装饰器
初级（没有参数）：
# -*- coding: utf-8 -*-
def decorate(cls):
print(‘类的装饰器开始运行啦------>‘)
return cls
@decorate #无参:People=decorate(People)
class People:
def __init__(self,name,age,salary):
self.name=name
self.age=age
self.salary=salary
print(self.age,self.name,self.salary)
p1=People(‘egon‘,18,3333.3) ------------恢复内容开始------------
__enter__和__exit__
数据描述符：至少实现__get__，__set__方法的
非数据描述符：没有__set__方法的
上下文管理协议（with语句）改写，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法。
# -*- coding: utf-8 -*-
class Open:
def __init__(self,name):
self.name=name
def __enter__(self):
print(‘出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量‘)
# return self
def __exit__(self, exc_type, exc_val, exc_tb):
print(‘with中代码块执行完毕时执行我啊‘)
with Open(‘b.txt‘) as f:
print(‘=====>执行代码块‘)
# print(f,f.name)# -*- coding: utf-8 -*-
class Open:
def __init__(self,name):
self.name=name
def __enter__(self):
print(‘出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量‘)
def __exit__(self, exc_type, exc_val, exc_tb):
print(‘with中代码块执行完毕时执行我啊‘)
#下面三个ext执行完毕就代表with代码块里的语句执行完毕，出现异常，下面的代码不再执行
print(exc_type) #异常类型
print(exc_val) #异常值
print(exc_tb) #追溯信息
with Open(‘b.txt‘) as f: #触发__enter__
print(‘=====>执行代码块‘)
raise AttributeError(‘***着火啦,救火啊***‘)
print(‘0‘*100) #------->不会执行用途：
1.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
2.在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制
描述符应用
控制输入类型
# -*- coding: utf-8 -*-
class Typed:
def __init__(self,key):
self.key=key
def __get__(self,instance,owner):
print(‘get方法‘)
# print(‘isinstance参数;‘,isinstance)
# print(‘owner参数;‘,owner)
return instance.__dict__[self.key]
def __set__(self,instance,value):
print(‘set方法‘)
# print(‘isinstance参数;‘,instance)
# print(‘owner参数;‘,value)
#通过初始化函数写活了
if not isinstance(value,str):
print(‘输入不是字符串‘)
else:
instance.__dict__[self.key]=value
def __delete__(self,instance):
print(‘delete方法‘)
# print(‘isinstance参数;‘, instance)
instance.__dict__.pop(self.key)
class people:
name=Typed(‘name‘)
# age=Typed(‘age‘)
def __init__(self,name,age,salary):
self.name=name
self.age=age
self.salary=salary
p1=people("bob",22,5000)
p1.name
print(p1.__dict__) #没有name属性，他被数据描述符代理了
del p1.name
print(p1.__dict__)
p2=people(1,22,5000)进一步改进
# -*- coding: utf-8 -*-
class Typed:
def __init__(self,key,expected_type):
self.key=key
self.expected_type=expected_type
def __get__(self,instance,owner):
# print(‘get方法‘)
# print(‘isinstance参数;‘,isinstance)
# print(‘owner参数;‘,owner)
return instance.__dict__[self.key]
def __set__(self,instance,value):
# print(‘set方法‘)
# print(‘isinstance参数;‘,instance)
# print(‘owner参数;‘,value)
#通过初始化函数写活了
if not isinstance(value,self.expected_type):
print(‘输入不是%s‘%self.expected_type)
else:
instance.__dict__[self.key]=value
def __delete__(self,instance):
print(‘delete方法‘)
# print(‘isinstance参数;‘, instance)
instance.__dict__.pop(self.key)
class people:
name=Typed(‘name‘,str)
age=Typed(‘age‘,int)
salary=Typed(‘salary‘,float)
def __init__(self,name,age,salary):
self.name=name
self.age=age
self.salary=salary
p1=people("bob",22,5000.0)
p1.name
print(p1.__dict__) #没有name属性，他被数据描述符代理了
del p1.name
print(p1.__dict__)
p2=people(1,22,5000.0)类的装饰器
初级（没有参数）：
# -*- coding: utf-8 -*-
def decorate(cls):
print(‘类的装饰器开始运行啦------>‘)
return cls
@decorate #无参:People=decorate(People)
class People:
def __init__(self,name,age,salary):
self.name=name
self.age=age
self.salary=salary
print(self.age,self.name,self.salary)
p1=People(‘egon‘,18,3333.3) 进阶（有参数）
# -*- coding: utf-8 -*-
def typeassert(**kwargs):
def decorate(cls):
print(‘2------>‘)
for key,value in kwargs.items():
setattr(cls,key,value)
return cls
print(‘1------>‘, kwargs)
return decorate
@typeassert() #name=str,age=int,salary=float
#有参:1.运行typeassert(...)返回结果是decorate,此时参数都传给kwargs 2.People=decorate(People)
class People:
pass
# def __init__(self,name,age,salary):
# self.name=name
# self.age=age
# self.salary=salary
print(People.__dict__)
@typeassert(hobby=‘ball‘)
class bar():
pass#添加了hobby属性
print(bar.__dict__)可添加不定个数属性的示例：
# -*- coding: utf-8 -*-
class Typed:
def __init__(self,name,expected_type):
self.name=name
self.expected_type=expected_type
def __get__(self, instance, owner):
print(‘get--->‘,instance,owner)
if instance is None:
return self
return instance.__dict__[self.name]
def __set__(self, instance, value):
print(‘set--->‘,instance,value)
if not isinstance(value,self.expected_type):
raise TypeError(‘Expected %s‘ %str(self.expected_type))
instance.__dict__[self.name]=value
def __delete__(self, instance):
print(‘delete--->‘,instance)
instance.__dict__.pop(self.name)
def typeassert(**kwargs):
def decorate(cls):
print(‘类的装饰器开始运行啦------>‘,kwargs)
for name,expected_type in kwargs.items():
setattr(cls,name,Typed(name,expected_type))
return cls
return decorate
@typeassert(name=str,age=int,salary=float)#在此添加要增加的属性
#有参:1.运行typeassert(...)返回结果是decorate,此时参数都传给kwargs 2.People=decorate(People)
class People:
def __init__(self,name,age,salary):
self.name=name
self.age=age
self.salary=salary
print(People.__dict__)
p1=People(‘egon‘,18,3333.3) 自定制property
装饰器可以是函数，也可以是类类型。
# -*- coding: utf-8 -*-
class Lazyproperty:
def __init__(self,func):
self.func=func
def __get__(self, instance, owner):
print(‘这是我们自己定制的静态属性,r1.area实际是要执行r1.area()‘)
if instance is None:
return self
return self.func(instance) #此时你应该明白,到底是谁在为你做自动传递self的事情
class Room:
def __init__(self,name,width,length):
self.name=name
self.width=width
self.length=length
@Lazyproperty #area=Lazyproperty(area) 相当于定义了一个类属性,即描述符
def area(self):
return self.width * self.length
r1=Room(‘alex‘,1,1)
print(r1.area) #将r1.area传参数写在Lazyproperty中的__get__里应用：自制property实现延迟计算功能
# -*- coding: utf-8 -*-
class Lazyproperty:
def __init__(self,func):
self.func=func
def __get__(self, instance, owner):
print(‘这是我们自己定制的静态属性,r1.area实际是要执行r1.area()‘)
if instance is None:
return self
else:
print(‘--->‘)
value=self.func(instance)
setattr(instance,self.func.__name__,value) #计算一次就缓存到实例的属性字典中
return value
# 如果加了set,将该非数据描述符变为数据描述符，优先级高于实列属性，缓存能力丧失
# def __set__(self, instance, value):
# print(‘hahahahahah‘)
class Room:
def __init__(self,name,width,length):
self.name=name
self.width=width
self.length=length
@Lazyproperty #area=Lazyproperty(area) 相当于‘定义了一个类属性,即描述符‘
def area(self):
return self.width * self.length
r1=Room(‘alex‘,1,1)
print(r1.area) #先从自己的属性字典找,没有再去类的中找,然后出发了area的__get__方法
print(r1.area) #先从自己的属性字典找,找到了,是上次计算的结果,这样就不用每执行一次都去计算property补充：一个静态属性property本质就是实现了get，set，delete三种方法
# -*- coding: utf-8 -*-
class Foo:
@property
def AAA(self):
print(‘get的时候运行我啊‘)
@AAA.setter
def AAA(self,value):
print(‘set的时候运行我啊‘)
@AAA.deleter
def AAA(self):
print(‘delete的时候运行我啊‘)
#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA=‘aaa‘
del f1.AAA应用（类型检测）
# -*- coding: utf-8 -*-
class People:
def __init__(self,name):
self.name=name #实例化就触发property
@property
def name(self):
# return self.name #无限递归
print(‘get------>‘)
return self.DouNiWan
@name.setter
def name(self,value):
print(‘set------>‘)
if not isinstance(value,str):
raise TypeError(‘必须是字符串类型‘)
self.DouNiWan=value
@name.deleter
def name(self):
print(‘delete------>‘)
del self.DouNiWan
p1=People(‘alex‘) #self.name实际是存放到self.DouNiWan里
print(p1.name)
print(p1.__dict__)
p1.name=1元类
所有定义的类都是由type产生的。
# -*- coding: utf-8 -*-
class foo:
pass
print(type(foo))定义类的两种方法
# -*- coding: utf-8 -*-
class foo:
pass
print(type(foo))
print(foo)
def __init__(self,name,age):
self.name=name
self.age=age
def test(self):
print(‘=======>‘)
Foo=type(‘foo1‘,(object,),{‘x‘:1,‘__init__‘:__init__,‘test‘:test})
print(Foo)
print(Foo.__dict__)
foo_1=Foo(‘alex‘,22)
foo_1.test()自定义元类（详情查看连接）