达内 python 是一种更纯粹的面向对象_python-----面向对象进阶

最新推荐文章于 2021-02-20 10:19:19 发布

shkpwbdkak

最新推荐文章于 2021-02-20 10:19:19 发布

阅读量241

点赞数

文章标签：达内 python 是一种更纯粹的面向对象

本文链接：https://blog.csdn.net/weixin_35828255/article/details/112900423

版权

本文详细介绍了Python面向对象编程中的反射机制，包括hasattr、getattr、setattr和delattr的使用，以及它们在代码中的实际应用。此外，文章还探讨了Python中自定义元类的原理和实现，展示了如何通过元类控制类的创建。同时，文章提到了装饰器的概念和使用，以及with语句中__enter__和__exit__方法的作用。通过对这些高级特性的讨论，帮助读者深入理解Python面向对象编程的高级技巧。

摘要由CSDN通过智能技术生成

一、反射

概念：主要是指程序可以访问、检测和修改它本身状态或者行为的一种能力(自省)

python面向对象中的反射：通过字符串的形式操作对象的相关属性。python中的一切事物皆对象(都可以使用反射)

一、四个可以实现自省的函数：

hasattr(obj，'属性名') 检测对象是否含有某属性

getattr(obj，‘属性名’，100)通过字符串类型获取对象的某个属性，不存在则会报错，可定义第三个参数的默认值，不存在则会显示第三个参数，不会报错。

setattr(obj，'属性名'，属性)设置属性，若属性不存在则会新添新的属性，存在则会修改为新的属性

delattr(obj，‘属性名’)删除对象的某个属性，不存在则会报错

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/1 13:09'

4 #class BlackMedium:

5 #feture='ugly'

6 #def __init__(self,name,addr):

7 #self.name=name

8 #self.addr=addr

9 #def rent_hourse(self):

10 #print('[%s]出租房子,不要去租!'%self.name)

11 #def sell_hourse(self):

12 #print('[%s]卖房子,不要去买!'%self.name)

13 #b=BlackMedium('万成置地','天露园')

14 #print(hasattr(b,'name')) #有没有name属性找的是对应的key

15 #print(hasattr(b,'addr'))

17 #print(getattr(b,'name')) #万成置地得到这个对象的属性值===相当于b.name

18 #getattr(b,'sell_hourse')() #同样也可以

19 #print(getattr(b,'age')) #没有这个属性就会报错，不过可以传一个默认值

20 #print(getattr(b,'age',23)) #没有这个属性值会显示默认的值，不会报错 23

22 #setattr(b,'name','小黑')

23 #print(b.__dict__) #name的值就从万成置地变为小黑修改了一个属性的值

24 #setattr(b,'age',5)

25 ## print(b.__dict__) #{'name': '万成置地', 'addr': '天露园', 'age': 5} 添加了一个属性

26 ##

27 ## delattr(b,'age')

28 ## print(b.__dict__) #删除了一个属性/2反射的优点：

二、反射的优点

1、通过反射，可以实现即插即用，定义接口的功能(可以事先把逻辑写好(只定义接口)，然后后期再去实现接口功能)

‘alex’应该写的代码

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/1 14:16'

4 classFtpClient:5 'ftp客户端，但没有实现功能'

6 def __init__(self,addr):7 self.addr=addr8 defload(self):9 print('上传照片')

‘listen’应该写的代码

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/1 14:16'

4 #1通过反射，可以实现即插即用，定义接口的功能(可以事先把主要逻辑写好(只定义接口)，后期再去实现接口功能。)

5 #from alex_module import FtpClient

6 #from alex_module import *

7 #f1=FtpClient('172.16.1.3')

8 #if hasattr(f1,'load'):

9 #f1.load() #'FtpClient' object has no attribute 'load' 报错，但不影响，两个人可以相互独立工作，等第一个人写好了，直接调用了

10 #else:

11 #print('没有load这个方法')

这样实现代码互不影响。

2、动态导入模块(基于反射当前的模块成员)

1 #2 动态导入模块底层基于反射包中__init__文件

2 #from hell.test import * #一导入模块直接运行模块中的内容

3 #from hell.test import * #内容中有私有的属性 _test1()

4 #from hell.test import test,_test1,test2 #这样就可以运行了 *对于私有的导不进去，只能一个一个把函数导进去

5 #test() #这个可以运行

6 #_test1() #这个运行不了

7 #test2()

8 #运行结果：

9 #----------》hello

10 #--->test1

11 #--->test2

12 #--->test3

14 #模块是一个字符换'hell.test' 怎么导入字符串模块

15 #module=__import__('hell.test')

16 #print(module) #只能识别到hell模块中不能再识别下一级模块

19 #import importlib

20 #m=importlib.import_module('hell.test') #可以识别到hell模块的下一级test

21 ## print(m)

三、__setattr__、__getattr__、__delattr__内置的方法

__getattr__在使用的时候，没有实例的这个属性的时候才会被触发，有实例的属性不会触发这个方法。------>>>最常用的方法

1 classFoo:2 country='china'

3 def __init__(self,name):4 self.name=name5 #def __getattr__(self, item): #item就是不存在的属性

6 #print('执行__getattr__')

7 f=Foo('alex') #设置一遍执行一遍

8 ## print(f.name)

9 ## print(f.age) #如果没有这个属性会触发__getattr__ 有这个属性则不会触发

__setattr__:在设置值得时候就会触发 -------------->设置属性的过程，可以里面自定义属性

1 classFoo:2 country='china'

3 def __init__(self,name):4 self.name=name5 #6 #def __setattr__(self, key, value):

7 #print('执行__setattr__')

#直到这没有意义不会添加属性到属性字典中，内置的__setattr__会添加属性字典中

8 ## self.key=value 错误用法

9 #self.__dict__[key]=value #在底层字典设置，本来就在底层操作字典

11 f=Foo('alex') #设置一遍执行一遍

12 #f.age=18

13 #f.sex='male'

14 #print(f.__dict__)

__delattr__删除属性的时候会触发

1 classFoo:2 country='china'

3 def __init__(self,name):4 self.name=name5

6 #7 def __delattr__(self, item):8 print('执行__delattr__')9 self.__dict__.pop(item)10 f=Foo('alex') #设置一遍执行一遍

11 print(f.__dict__)12 del f.name #只要删除就会触发

13 print(f.__dict__)

四、包装和授权

包装：python为我们提供了标准数据类型，以及丰富的内置方法，其实很多场景下，我们都需要基于标准的数据类型来定制我们自己的数据类型，新增或改写方法，这就需要继承和派生了(其他标准类型均可以通过下面的方式进行二次加工)

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/2 8:51'

4 #包装

5 #继承、派生、改写父类的方法

6 classList(list):7 #改写父类list的方法

8 defappend(self, object):9 if type(object) isstr:10 #return list.append(self,object) #调用父类的方法

11 return super().append(object) #不用传self

12 else:13 return '不是字符串类型，不能添加成功!'

14 #取中间值派生

15 defget_middle(self):16 mid_num=int(len(self)/2)17 returnself[mid_num]18

19 l=List('1234567')20 #l.append('b')

21 print(l.get_middle())

授权：授权是包装的一个特性，包装一个类型通常是对已存在的类型的一些定制，这种做法可以新建、修改或删除原有的功能，其他的保持原样。授权的过程，即是所有更新的功能都是由新类的某部分来处理，但已存在的功能就授权给对象默认属性。

实现授权的关键就是覆盖__getattr__方法

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/2 9:23'

4 importtime5 #授权

6 classFileHandle:7 def __init__(self,filename,mode,encoding='utf-8'):8 self.file=open(filename,mode,encoding=encoding) #类似于组合

9 self.mode=mode10 self.encoding=encoding11

12 #实现重写功能

13 #def write(self,line):

14 #print('不允许写入',line) #自己有这个方法先执行自己的方法

15 #实现加上时间的操作

16 defwrite(self,line):17 t=time.strftime('%Y-%m-%d %X')18 self.file.write('%s%s'%(t,line))19

20 #实现了继承功能

21 def __getattr__(self,item):22 #print('----->',item)

23 #print(type(item)) #str类型变为属性 getattr()可以做到

24 returngetattr(self.file,item)25

26 f=FileHandle('a.txt','r+')27 f.write('负载过大\n')28 f.write('内存不足\n')29 f.write('硬盘内存不足')30 #f.seek(0)

31 #print(f.read())

五、__getattrabute__用法

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/2 12:56'

4 classFoo:5 def __init__(self,name):6 self.name=name7 def __getattr__(self, item): #小弟

8 print('----->from getattr')9 def __getattribute__(self, item): #大哥

10 print('----------->from getattribute')11 raise AttributeError('抛出异常了!') #attribute和attr的一个通信

12 f=Foo('alex')13 #f.name #有这个属性执行getattribute

14 f.age #没有这个属性也执行 getattribute 没执行getattr 但是加上AttributeError之后，大哥和小弟之间就可以通话了，然后再去找attr，然后就执行attr，当没定义getattrate，系统就会调用自己的getattrate，然后看的是只执行了attr(其实内部已经执行了getattrabute)

六、__setitem__、__getitem__、__delitem__

字典设置属性

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/2 13:35'

4 #. 形式的操作是会触发__setattr__ __getattr__ __delattr__ 字典的形式是操作__setitem__ __getitem__ __delitem__

5 #都是以字典的形式找、删、改

6 classFoo:7 def __init__(self,name):8 self.name=name9 def __getitem__(self, item):10 print('--------->from getitem')11 return self.__dict__[item]12

13 def __setitem__(self, key, value):14 print('---->from setitem')15 self.__dict__[key]=value16

17 def __delitem__(self, key):18 print('----->from delitem')19 self.__dict__.pop(key)20

21 f=Foo('alex')22 f['age']=17 #触发setitem 添加一个新的属性age

23 print(f['name']) #触发getitem 寻找属性的时候

24 del f['age'] #会触发delitem 删除属性

25 print(f.__dict__)

七、__str__、__repr__、__format__ ====str() repr() format()

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/2 13:49'

4 #__str__方法

5 #class Foo:

6 #def __init__(self,name,age):

7 #self.name=name

8 #self.age=age

9 #def __str__(self):

10 #return '名字是%s,年龄是%s'%(self.name,self.age)

11 #12 #f=Foo('listen',18)

13 #print(f) #<__main__.foo object at>内存地址不添加__str__方法

14 #print(f) #添加了__str__方法 --》名字是listen,年龄是18 str(obj)===obj.__str__() 和len(l)===l.__len__() print打印其实是调用__str__()方法

16 #__repr__方法

17 classFoo:18 def __init__(self,name,age):19 self.name=name20 self.age=age21 def __repr__(self):22 return '名字n是%s,年龄a是%s'%(self.name,self.age)23

24 f=Foo('listen',18)25 print(f) #名字n是listen,年龄a是18 print一打印，先找__str__方法，没有定义的__str__方法如果有__repr__,再去用__repr__代替

__format__ 格式化字符串

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/2 14:40'

4 format_dic={5 'ymd':'{0.year}{0.month}{0.day}',6 'y:m:d':'{0.year}:{0.month}:{0.day}',7 'y-m-d':'{0.year}-{0.month}-{0.day}'

8 }9

10 classDate:11 def __init__(self,year,month,day):12 self.year=year13 self.month=month14 self.day=day15 def __format__(self, format_spec):16 #print('我开始执行了')

17 if not format_spec or format_spec not informat_dic:18 n=format_dic['y:m:d']19 returnn.format(self)20 m=format_dic[format_spec]21 returnm.format(self)22

24 d=Date(2018,12,2)25 #print(format(d,'2')) #得到的是一个format_spec

26 #ymd='{0.year}{0.month}{0.day}'.format(d) #format(d)===d.__format__()

27 #ydm='{0.year}:{0.month}:{0.day}'.format(d)

28 #dym='{0.year}-{0.month}-{0.day}'.format(d)

29 #print(ydm)

30 print(format(d,'y-m-d')) #2018-12-2 触发内部的__format__方法

31 print(format(d,'ymd')) #2018122

32 print(format(d,'asd'))33 print(format(d)) #2018:12:2

八、isinstance(obj,cls)和issubclass(sub,super)

isinstance(p,A) 判断p是否是类A的对象，返回布尔值

issubclass(B,A) 判断类B是否继承类A，即B是否是A的派生类返回布尔值。

1 classA:2 pass

3 classB(A):4 pass

5 p=A()6 print(isinstance(p,A)) #True

7 print(issubclass(B,A)) #True

九、__slots__

1、__slots__是什么：是一个类变量，变量值可以为列表、元组、或者可迭代对象，也可以为一个字符串(意味着所有实例只有一个数据属性)

2、引子：使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的而实例的属性是独立的)

3、使用__slots__优点：字典会占用大量内存，如果你有一个属性很少的类，但是有很多实例，为了节省内存可以使用__slots__取代实例的__dict__

当你定义__slots__后，__slots__就会为实例使用一种更紧凑的内部表示。实例通过一个很凶啊的固定大小的数组来构建，而不是为每个实例定义一个。

字典，这跟列表和元组很类似，在__slots__中列出的属性名在内部被映射到这个数组的小标上。使用__slots__一个不好的地方就是我们不能在给实例添加新的属性，只能使用在__slots__定义的属性。

4、注意事项：__slots__的很多特性依赖于普通字典的实现。另外，定义了__slots__后的类不再支持一些普通的特性，比如多继承，大多数情况下，你应该只在那些经常被使用到的用作数据结构的类上定义__slots__,比如在程序中需要创建某个类的成千上百个实例对象。

关于__slots__的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管可以达到这样的目的，但并不是它的初衷。更多的是用来作为一个内存优化的用具。

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/3 21:03'

4 ##类的属性很少但创建了好多实例为了防止内存利用率低，可这样节省内存取消实例字典的功能但类还有字典的功能

5 #class Foo:

6 ## __slots__ = 'name' #可以为字符串也可以为字典

7 #__slots__ = ['name','age']

8 ## f1=Foo()

9 #f2=Foo()

10 #f3=Foo()

11 ## f1.name='alex'

12 ## print(f1.name)

13 ## f1.age=18

14 ## print(f1.age) #会报错限制了实例的属性节省内存实例没有自己的属性只能根据类定义的__slots__属性添加自己的属性，把底层字典的功能取消掉

15 #f2.name='listen'

16 #f2.age=18

17 #f3.age=20

18 #19 #print(f3.age)

20 #21 #print(f2.name,f2.age)

22 #print(f2.__slots__)

十、__doc__

1 #__doc__属性不被继承

2 #class A:

3 #"这是文档描述信息"

4 #pass

5 #class B(A):

6 #pass

7 #print(A.__dict__)

8 #print(A.__doc__) #这是文档信息

9 #print(B.__doc__) #None

10 #print(B.__dict__) #{'__module__': '__main__', '__doc__': None}

十一、析构方法 __del__

__del__:析构方法，当对象在内存中被释放时，自动触发执行。此方法无需定义，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/3 21:42'

4 #class Foo:

5 #def __init__(self,name):

6 #self.name=name

7 #8 #def __del__(self):

9 #print('我执行了!')

10 #f=Foo('alex')

11 #del f

12 #print('---------------')

13 #result:

14 #我执行了!

15 #---------------

17 classFoo:18 def __init__(self,name):19 self.name=name20

21 def __del__(self):22 print('我执行了!')23 f=Foo('alex')24 delf.name25 print('---------------')26 #result:

27 #---------------

28 #我执行了! 删掉实例的属性时不会触发析构函数，删掉对象才会触发但是当程序执行完毕后垃圾回收所以会触发释放内存

十二、__call__

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

注：构造方法的执行是由创建对象触发的，即：对象=类名();而对于__call__方法的执行是由对象加()触发的，即对象() 类名()() 一切皆对象，其实类也是对象

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/3 21:53'

4 classFoo:5 def __call__(self, *args, **kwargs):6 print('我执行啦')7 f=Foo()8 f() #会触发实例的类的__call__方法我执行啦

9 Foo() #一切皆对象 Foo加()也会触发它下面的object类的__call方法

十三、__module__和__class__用法

__module__:表示当前操作的对象在那个模块下(import的模块直接用实例)

__class__:表示当前操作的对象的类是什么

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/3 21:26'

4 classFoo:5 def __init__(self,name,age):6 self.name=name7 self.age=age

引用上面的模块去创建对象

2 #_*_ encoding:utf-8 _*_

3 __author__ = 'listen'

4 __date__ = '2018/12/3 21:27'

5 from module_class.module importFoo6 f=Foo('alex',18)7 print(f.name)8 print(f.__module__) #module_class.module

9 print(f.__class__) #

十四、__iter__和__next__实现迭代器协议

1 #_*_ ecoding:utf-8 _*_

2 classA:3 def __init__(self,num):4 self.num=num5 def __iter__(self):6 returnself7 def __next__(self):8 if self.num == 5:9 raise StopIteration('异常终止')10 self.num+=1

11 returnself.num12 a=A(2)13 #print(a.__next__())

14 #print(a.__next__())

15 #print(a.__next__())

16 #print(a.__next__())

17 for i ina:18 print(i) #for 先调用__iter__方法，变为可迭代对象之后再内部执行__next__方法，但是内部可以到不满足条件终止，循环打印，捕捉异常退出

十五、描述符(__get__、__set__、__delete__)

描述符本质上就是一个新式类，在这个新式类中，至少实现了__get__()、__set__()、__delete__()方法中的一个，这也被称为描述符协议。

__get__():调用一个属性时，触发

__set__():为一个属性赋值时，触发

__delete__():采用del删除一个属性时，触发

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/4 20:45'

4 #这个类是一个描述符

5 classFoo:6 def __get__(self, instance, owner):7 print('get method')8 def __set__(self, instance, value):9 print('set method',instance,value)10 #instance.__dict__['x']=value

12 def __delete__(self, instance):13 print('delete method')14 #描述符是用来代理另外一个类的属性(必须把描述符定义到另一个类的类属性中，不能定义到构造函数中)，描述符只能用来定义描述其他的类，自己的类不行

15 #只要代理的属性统统归代理管，没有代理的属性统统和代理无关

16 classBar:17 x=Foo() #在何地

18 #def __init__(self,x):

19 #self.x=x ===b.x=10

20 b=Bar()21 b.x=10 #调用类属性并赋值 set method {'x': 10}

22 print(b.__dict__) #{} 空的 x被Foo代理了，所以为空因为__set__方法中什么都没有做，没有做底层字典的操作

23 #b.x #get method 调用类属性

24 #del b.x #delete method 删除类属性

描述符是干什么用的？

描述符的作用是用来定义另外一个类的属性的(必须把描述符定义成这个类的类属性，不能定义到构造函数中)，描述符只能用来代理除描述符以外的其他类

Bar这个类被Foo类代理----一般从实例对象中可以看出来

描述符分为两种：1、数据描述符：至少实现__get__和__set__

2、非数据描述符：没有实现__set__

注意事项：一、描述符本身应该定义为新式类，被代理的类也应该是新式类

二、必须把描述符定义成另一个类的类属性，不能定义到构造函数中

三、要严格遵守该优先级，优先级从高到低是：

类属性

数据描述符

实例属性

非数据描述符

找不到的属性触发__getattr__()

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/4 21:31'

4 classFoo:5 def __get__(self, instance, owner):6 print('get method')7 #def __set__(self, instance, value):

8 #print('set method',instance,value)

9 ## instance.__dict__['x']=value

10 #11 #def __delete__(self, instance):

12 #print('delete method')

13 classBar:14 x=Foo() #在何地

16 b=Bar()17 #print(Bar.x) #get method

18 #Bar.x=1

19 #print(Bar.x) #1

20 #print(Bar.__dict__) #里面有x=1属性说明类属性>数据描述符(有get和set方法)

22 #b.x #触发get method

23 #b.x=10 #触发 set method <__main__.bar object at> 10 并不是给实例重点添加一个属性

24 #print(b.__dict__) #{} 数据描述符> 实例

26 #b.x #触发 get method

27 #b.x=10

28 #print(b.__dict__) #{'x': 10} 实例>非数据描述符

30 b.x #get method

31 print(b.yyyyy) #触发__getattr__ 非数据>找不到

描述符的使用：

1、由于python是弱类型语言，所以不用定义属性的数据类型就可以直接使用，描述符可以实现类型的限制。

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/6 20:38'

4 #class Typed:

5 #def __get__(self, instance, owner):

6 #print('这是get方法')

7 #print('这是instance%s'%instance)

8 #print('这是owner%s'%owner)

9 #def __set__(self, instance, value):

10 #print('这是set方法')

11 #print('这是instance%s'%instance)

12 #print('这是owner%s'%value)

13 #def __delete__(self, instance):

14 #print('这是delete方法')

15 #print('这是instance%s'%instance)

16 #

17 #18 #class People:

19 #name=Typed()

20 #def __init__(self,name,age,salary):

21 #self.name=name

22 #self.age=age

23 #self.salary=salary

24 #p=People('alex',18,1000.6) # 这是set方法这是instance<__main__.people object at> 这是owneralex 赋值的所有者是附的值

25 #print(p) #<__main__.people object at>

26 #p.name #这是get方法这是instance<__main__.people object at> 这是owner 调用(对象的所有者是类)

27 #p.name='listen' #这是set方法这是instance<__main__.people object at> 这是ownerlisten

28 #print(p.__dict__) #{'age': 18, 'salary': 1000.6}

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/6 20:38'

5 #对传入属性的值类型限制 name只能传入字符串

6 #class Typed:

7 #def __init__(self,key):

8 #self.key=key

9 #def __get__(self, instance, owner):

10 #print('这是get方法')

11 #return instance.__dict__[self.key]

12 #13 #def __set__(self, instance, value):

14 #print('这是set方法')

15 #if not isinstance(value, str):

16 #raise TypeError('类型不是字符串')

17 #instance.__dict__[self.key]=value

18 #def __delete__(self, instance):

19 #print('这是delete方法')

20 #instance.__dict__.pop(self.key)

21 #22 #class People:

23 #name=Typed('name')

24 ## age = Typed('age')

25 #def __init__(self,name,age,salary):

26 #self.name=name

27 #self.age=age

28 #self.salary=salary

29 #p=People('alex',18,1000.6)

30 #print(p.__dict__) #{'name': 'alex', 'age': 18, 'salary': 1000.6}

31 #p=People(22,18,1000.6)

32 #print(p.__dict__) #TypeError: 类型不是字符串肯定加不到字典中

33 #p.name='listen'

34 #print(p.__dict__) #{'name': 'listen', 'age': 18, 'salary': 1000.6} 添加进去了

1 #再加一个限制age的类型

2 classTyped:3 def __init__(self,key,except_key):4 self.key=key5 self.except_key=except_key6 def __get__(self, instance, owner):7 print('这是get方法')8 return instance.__dict__[self.key]9

10 def __set__(self, instance, value):11 print('这是set方法')12 if notisinstance(value,self.except_key):13 raise TypeError('类型不是%s'%self.except_key)14 instance.__dict__[self.key]=value15 def __delete__(self, instance):16 print('这是delete方法')17 instance.__dict__.pop(self.key)18

19 classPeople:20 name=Typed('name',str)21 age = Typed('age',int)22 def __init__(self,name,age,salary):23 self.name=name24 self.age=age25 self.salary=salary26 #p=People('alex',18,1000.6) #这是set方法这是set方法

27 #p=People(10,18,1000.6) #TypeError: 类型不是

28 p=People('alex','j',1000.6) #TypeError: 类型不是

2、实现装饰器功能

基本的装饰器：

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/6 22:18'

4 #def deco(obj):

5 #obj.x=1

6 #obj.y=2

7 #obj.z=3

8 #return obj

9 #@deco

10 #class Foo:

11 #pass

12 #print(Foo.__dict__) #属性字典中有 x y z

13 #传的参数是活的

14 def Type(**kwargs): #在外面嵌套一个函数实现加参数的功能15 defdeco(obj):16 for key,val inkwargs.items():17 setattr(obj,key,val)18 returnobj19 returndeco20 @Type(age=17,name='alex')21 classFoo:22 pass

23 print(Foo.age,Foo.name) #17 alex

装饰器的补充(和描述符没关系，只是单纯的装饰器的补充):

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/8 10:13'

4 #class Dog:

5 #def __init__(self,name):

6 #self.name=name

7 #@property

8 #def like_wang(self):

9 #print( 'get汪汪汪')

10 #@like_wang.setter

11 #def like_wang(self,value):

12 #print('set汪汪汪',value)

13 #@like_wang.deleter

14 #def like_wang(self):

15 #print('del汪汪汪')

16 #17 #d=Dog('豆豆')

18 ## print(d.like_wang)

19 ## d.like_wang='wolf' #AttributeError: can't set attribute

20 #del d.like_wang

22 #商品的价格变动

23 #class Goods:

24 #def __init__(self,orign_price,zhekou):

25 #self.orign_price=orign_price

26 #self.zhekou=zhekou

27 #@property

28 #def price(self):

29 #return self.orign_price*self.zhekou

30 #@price.setter

31 #def price(self,val):

32 #self.orign_price=val

33 #34 #@price.deleter

35 #def price(self):

36 #del self.orign_price

37 #38 #39 #g=Goods(100,0.5)

40 ## print(g.price) #50

41 ## g.price=200

42 ## print(g.price) #100

43 #del g.price

44 #print(g.price)

47 #加上类型限制

48 classGoods:49 def __init__(self,orign_price,zhekou):50 self.orign_price=orign_price51 self.zhekou=zhekou52 @property53 defprice(self):54 return self.orign_price*self.zhekou55 @price.setter56 defprice(self,val):57 if val is notint:58 raise TypeError('此类型应该为int')59 self.orign_price=val60

61 @price.deleter62 defprice(self):63 delself.orign_price64 #a=property(get_price,set_price,del_price) 第2种使用方法

66 g=Goods(100,0.5)67 g.price='lll'

68 print(g.price) #此类型应该为int

69 #print(g.price) #50

70 #g.price=200

71 #print(g.price) #100

72 #print(g.a) #50

十六、__enter__和__exit__

文件的操作方式：

1 #此方法不需要自己关掉文件

2 with open('文件名','打开方式'，'编码方式') as f:3 '代码块' #文件操作

上述叫做上下文管理协议，即with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法

1 #_*_ encoding:utf-8 _*_

2 __author__ = 'listen'

3 __date__ = '2018/12/5 21:58'

4 classOpen:5 def __init__(self,name):6 self.name=name7 def __enter__(self):8 print('---->enter')9 returnself10 def __exit__(self, exc_type, exc_val, exc_tb):11 print('---------->exit')12 with Open('a') as f : #__enter__返回的值会给f 这一步是执行enter f=self 对象的实例化

13 print(f) #打印对象的地址

14 print(f.name) #a

15 print('----->')16 print('----->')17 print('----->') #中间都在执行文件的操作

18 print('----->')19 print('----->') #关闭文件执行完内部后会触发__exit__

20 print('==========>>')

在with的代码块中，打印未定义的变量，触发exit方法，待exit函数执行结束，代表with代码块也执行结束，报错信息打印，整个程序结束；但是在exit方法中加上return True，就会继续执行with代码块外的语句，让外部看不出里面有什么报错，隐藏报错信息。

1 classOpen:2 def __init__(self,name):3 self.name=name4 def __enter__(self):5 print('---->enter')6 returnself7 def __exit__(self, exc_type, exc_val, exc_tb): #exc_type 异常的类 exc_val 异常的值 exc_tb 异常的追踪信息8 print('---------->exit')9 print(exc_type) #

10 print(exc_val) #NameError: name 'adghh' is not defined name 'adghh' is not defined

11 print(exc_tb) #

12 returnTrue13 with Open('a') as f : #__enter__返回的值会给f 这一步是执行enter f=self

14 print(f) #打印对象的地址

15 print(f.name) #a

16 print(adghh) #打印未定义的变量触发__exit__程序会退出打印错误信息

17 print('----->') #关闭文件执行完内部后会触发__exit__

19 print('==========>>') #这将会被执行把错误吞掉除了内部知道有问题，外部看不出来，不影响外部程序的运行

小结：

1、with obj---->代表触发obj.__enter__(),拿到返回值

2、as f----->f=返回值

3、with obj as f ===f=obj.__enter__()