實(shí)現(xiàn)授權(quán)的關(guān)鍵點(diǎn)就是覆蓋__getattr__方法

1、通過(guò)觸發(fā)__getattr__方法，找到read方法

示例1:

1 importtime2 classFileHandle:3 def __init__(self,filename,mode='r',encoding='utf-8'):4 self.file=open(filename,mode,encoding=encoding)5 self.mode=mode6 self.encoding=encoding7

8 def __getattr__(self, item):9 print(item,type(item))10 self.file.read #self.file里面有read方法

11 return getattr(self.file,item) #能過(guò)字符串來(lái)找到，并通過(guò)return返回，就找到了read方法，

12

13 f1=FileHandle('a.txt','r')14 print(f1.file)15 print(f1.__dict__) #類(lèi)的字典里，沒(méi)有read方法，就觸發(fā)了__getattr__方法

16 print(f1.read) #找到了read方法

17

18 sys_f=open('b.txt','w+')19 print('---->',getattr(sys_f,'read')) #找到了read方法

執(zhí)行結(jié)果：

1 <_io.textiowrapper name="a.txt" mode="r" encoding="utf-8">

2

3 read

4

5

6

7 {'encoding': 'utf-8', 'file': <_io.textiowrapper name="a.txt" mode="r" encoding="utf-8">, 'mode': 'r'}8

9 ---->

View Code

2、往文件里面寫(xiě)入內(nèi)容

示例2：

1 importtime2 classFileHandle:3 def __init__(self,filename,mode='r',encoding='utf-8'):4 #self.filename=filename

5 self.file=open(filename,mode,encoding=encoding)6 self.mode=mode7 self.encoding=encoding8 defwrite(self,line):9 print('------------>',line)10 t=time.strftime('%Y-%m-%d %X')11 self.file.write('%s %s' %(t,line))12

13 def __getattr__(self, item):14 #print(item,type(item))

15 #self.file.read

16 returngetattr(self.file,item)17

18 f1=FileHandle('a.txt','w+')19 f1.write('1111111111111111\n')20 f1.write('cpu負(fù)載過(guò)高\(yùn)n')21 f1.write('內(nèi)存剩余不足\n')22 f1.write('硬盤(pán)剩余不足\n')

執(zhí)行結(jié)果：

會(huì)創(chuàng)建一個(gè)a.txt的文件，并往里面寫(xiě)入內(nèi)容：

1 2016-12-23 18:34:16 1111111111111111

2 2016-12-23 18:34:16cpu負(fù)載過(guò)高3 2016-12-23 18:34:16內(nèi)存剩余不足4 2016-12-23 18:34:16 硬盤(pán)剩余不足

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

1、isinstance(obj,cls) 檢查是否obj是否是類(lèi)cls的對(duì)象

示例：

1 classFoo(object):2 pass

3

4 obj =Foo()5

6 print(isinstance(obj,Foo))

執(zhí)行結(jié)果：

1 True

2、issubclass(sub,super)檢查sub類(lèi)是否是supper類(lèi)的派生類(lèi)

示例：

1 classFoo(object):2 pass

3

4 classBar(Foo):5 pass

6

7 print(issubclass(Bar,Foo))

執(zhí)行結(jié)果：

1 True

八、__getattribute__

示例1：

不存在的屬性訪(fǎng)問(wèn)，就會(huì)觸發(fā)__getattr__方法

1 classFoo:2 def __init__(self,x):3 self.x=x4

5 def __getattr__(self, item):6 print('執(zhí)行的是我')7 #return self.__idct__[item]

8

9 f1=Foo(10)10 print(f1.x)11 f1.xxxxxx #不存在的屬性訪(fǎng)問(wèn)，觸發(fā)__getattr__

執(zhí)行結(jié)果：

1 10

2 執(zhí)行的是我

示例2：

不管是否存在，都會(huì)執(zhí)行__getattribute__方法

1 classFoo:2 def __init__(self,x):3 self.x=x4

5 def __getattribute__(self, item):6 print('不管是否存在，我都會(huì)執(zhí)行')7

8 f1=Foo(10)9 f1.x10 f1.xxxxxxx

執(zhí)行結(jié)果：

1 不管是否存在，我都會(huì)執(zhí)行2 不管是否存在，我都會(huì)執(zhí)行

示例:3：

1 classFoo:2 def __init__(self,x):3 self.x=x4

5 def __getattr__(self, item): #相當(dāng)于監(jiān)聽(tīng)大哥的異常，大哥拋出導(dǎo)常，他就會(huì)接收。

6 print('執(zhí)行的是我')7 #return self.__dict__[item]

8

9 def __getattribute__(self, item):10 print('不管是否存在，我都會(huì)執(zhí)行')11 raise AttributeError('拋出異常了')12

13 f1=Foo(10)14 f1.x #結(jié)果是：10 ，調(diào)用會(huì)觸發(fā)系統(tǒng)的

15 f1.xxxxxxx #如果不存在會(huì)觸發(fā)自己定義的

執(zhí)行結(jié)果：

1 不管是否存在，我都會(huì)執(zhí)行2 執(zhí)行的是我3 不管是否存在，我都會(huì)執(zhí)行4 執(zhí)行的是我

九、__setitem__,__getitem,__delitem__ ?(操作字典就用item的方式)

obj[‘屬性’]的方式去操作屬性時(shí)觸發(fā)的方法

__getitem__:obj['屬性'] 時(shí)觸發(fā)

__setitem__:obj['屬性']=屬性的值 時(shí)觸發(fā)

__delitem__:del obj['屬性'] 時(shí)觸發(fā)

示例1：

1 classFoo:2

3 def __getitem__(self, item):4 print('getitem',item)5 return self.__dict__[item]6

7 def __setitem__(self, key, value):8 print('setitem')9 self.__dict__[key]=value10

11 def __delitem__(self, key):12 print('delitem')13 self.__dict__.pop(key)14

15 f1=Foo()16 print(f1.__dict__)17 f1['name']='agon'

18 f1['age']=18

19 print('====>',f1.__dict__)20

21 del f1['name']22 print(f1.__dict__)23

24 print(f1,['age'])

執(zhí)行結(jié)果：

1 {}2

3 setitem4

5 setitem6

7 ====> {'age': 18, 'name': 'agon'}8

9 delitem10

11 {'age': 18}12

13 <__main__.foo object at> ['age']

View Code

示例2：

1 classFoo:2 def __init__(self,name):3 self.name=name4

5 def __getitem__(self, item):6 print(self.__dict__[item])7

8 def __setitem__(self, key, value):9 self.__dict__[key]=value10 def __delitem__(self, key):11 print('del obj[key]時(shí),我執(zhí)行')12 self.__dict__.pop(key)13 def __delattr__(self, item):14 print('del obj.key時(shí),我執(zhí)行')15 self.__dict__.pop(item)16

17 f1=Foo('sb')18 f1['age']=18

19 f1['age1']=19

20 delf1.age121 del f1['age']22 f1['name']='alex'

23 print(f1.__dict__)

執(zhí)行結(jié)果：

1 delobj.key時(shí),我執(zhí)行2

3 delobj[key]時(shí),我執(zhí)行4

5 {'name': 'alex'}

View Code

十、__str__, __repr__，__format__

1、改變對(duì)象的字符串顯示__str__,__repr__ ?(只能是字符串的值，不能是非字符串的值)

示例1：

1 l = list('hello')2 print(1)3

4 file=open('test.txt','w')5 print(file)

執(zhí)行結(jié)果：

1 1

2 <_io.textiowrapper name="test.txt" mode="w" encoding="cp936">

View Code

示例2：

__str__方法

1 #自制str方法

2 classFoo:3 def __init__(self,name,age):4 self.name=name5 self.age=age6

7 def __str__(self):8 return '名字是%s 年齡是%s' %(self.name,self.age)9

10 f1=Foo('age',18)11 print(f1) #str(f1)---->f1.__str__()

12

13 x=str(f1)14 print(x)15

16 y=f1.__str__()17 print(y)

執(zhí)行結(jié)果：

1 名字是age 年齡是182 名字是age 年齡是183 名字是age 年齡是18

View Code

示例3：

__repe__方法

1 #觸發(fā)__repr__方法,用在解釋器里輸出

2 classFoo:3 def __init__(self,name,age):4 self.name=name5 self.age=age6

7 def __repr__(self):8 return '名字是%s 年齡是%s' %(self.name,self.age)9

10 f1=Foo('agon',19)11 print(f1)

執(zhí)行結(jié)果：

1 名字是agon 年齡是19

示例4：

__str__和__repe__ 共存時(shí)的用法

1 #當(dāng)str與repr共存時(shí)

2 classFoo:3 def __init__(self,name,age):4 self.name=name5 self.age=age6

7 def __str__(self):8 return '名字是%s 年齡是%s' %(self.name,self.age)9

10 def __repr__(self):11 return '名字是%s 年齡是%s' %(self.name,self.age)12

13 f1=Foo('egon',19)14 #repr(f1)--->f1.__repr__()

15 print(f1) #str(f1)--->f1.__str__()---->f1.__repr__()

執(zhí)行結(jié)果：

1 <__main__.foo object at>

View Code

總結(jié)：

str函數(shù)或者print函數(shù)--->obj.__str__()

repr或者交互式解釋器--->obj.__repr__()

如果__str__沒(méi)有被定義,那么就會(huì)使用__repr__來(lái)代替輸出

注意:這倆方法的返回值必須是字符串,否則拋出異常

2、自定制格式化字符串__format__

format的用法

示例1：

1 x = '{0}{0}{0}'.format('dog')2 print(x)

執(zhí)行結(jié)果：

1 dogdogdog

不用__format__的方式實(shí)現(xiàn)

示例2：

1 classDate:2 def __init__(self,year,mon,day):3 self.year=year4 self.mon=mon5 self.day=day6

7 d1=Date(2016,12,26)8

9 x = '{0.year}{0.mon}{0.day}'.format(d1)10 y = '{0.year}:{0.mon}:{0.day}'.format(d1)11 z = '{0.year}-{0.mon}-{0.day}'.format(d1)12 print(x)13 print(y)14 print(z)

執(zhí)行結(jié)果：

1 20161226

2 2016:12:26

3 2016-12-26

用__format__的方式實(shí)現(xiàn)

示例3：

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

7 classDate:8 def __init__(self,year,month,day):9 self.year=year10 self.month=month11 self.day=day12

13 def __format__(self, format_spec):14 print('我執(zhí)行啦')15 print('----->',format_spec)16 if not format_spec or format_spec not informat_dic:17 format_spec='ymd'

18 fmt=format_dic[format_spec]19 returnfmt.format(self)20

21 d1=Date(2016,12,29)22 #print(format(d1)) #d1.__format__()

23 #print(format(d1))

24

25 print(format(d1,'ymd'))26 print(format(d1,'y:m:d'))27 print(format(d1,'m-d-y'))28 print(format(d1,'m-d:y'))29 print('===========>',format(d1,'sdsdddsfdsfdsfdsfdsfsdfdsfsdfds'))

執(zhí)行結(jié)果：

1 我執(zhí)行啦2 ----->ymd3 2016:12:29

4 我執(zhí)行啦5 ----->y:m:d6 2016:12:29

7 我執(zhí)行啦8 -----> m-d-y9 12-29-2016

10 我執(zhí)行啦11 -----> m-d:y12 2016:12:29

13 我執(zhí)行啦14 ----->sdsdddsfdsfdsfdsfdsfsdfdsfsdfds15 ===========> 2016:12:29

View Code

十一、?__slots__ ?(慎用)

1.__slots__是什么？是一個(gè)類(lèi)變量,變量值可以是列表,元祖,或者可迭代對(duì)象,也可以是一個(gè)字符串(意味著所有實(shí)例只有一個(gè)數(shù)據(jù)屬性)

2.引子:使用點(diǎn)來(lái)訪(fǎng)問(wèn)屬性本質(zhì)就是在訪(fǎng)問(wèn)類(lèi)或者對(duì)象的__dict__屬性字典(類(lèi)的字典是共享的,而每個(gè)實(shí)例的是獨(dú)立的)

3.為何使用__slots__:字典會(huì)占用大量?jī)?nèi)存,如果你有一個(gè)屬性很少的類(lèi),但是有很多實(shí)例,為了節(jié)省內(nèi)存可以使用__slots__取代實(shí)例的__dict__ 當(dāng)你定義__slots__后,__slots__就會(huì)為實(shí)例使用一種更加緊湊的內(nèi)部表示。實(shí)例通過(guò)一個(gè)很小的固定大小的數(shù)組來(lái)構(gòu)建,而不是為每個(gè)實(shí)例定義一個(gè) 字典,這跟元組或列表很類(lèi)似。在__slots__中列出的屬性名在內(nèi)部被映射到這個(gè)數(shù)組的指定小標(biāo)上。使用__slots__一個(gè)不好的地方就是我們不能再給 實(shí)例添加新的屬性了,只能使用在__slots__中定義的那些屬性名。

4.注意事項(xiàng):__slots__的很多特性都依賴(lài)于普通的基于字典的實(shí)現(xiàn)。另外,定義了__slots__后的類(lèi)不再 支持一些普通類(lèi)特性了,比如多繼承。大多數(shù)情況下,你應(yīng)該 只在那些經(jīng)常被使用到 的用作數(shù)據(jù)結(jié)構(gòu)的類(lèi)上定義__slots__比如在程序中需要?jiǎng)?chuàng)建某個(gè)類(lèi)的幾百萬(wàn)個(gè)實(shí)例對(duì)象 。 關(guān)于__slots__的一個(gè)常見(jiàn)誤區(qū)是它可以作為一個(gè)封裝工具來(lái)防止用戶(hù)給實(shí)例增加新的屬性。盡管使用__slots__可以達(dá)到這樣的目的,但是這個(gè)并不是它的初衷。更多的是用來(lái)作為一個(gè)內(nèi)存優(yōu)化工具。

__slots__的作用：節(jié)省內(nèi)存空間

1、一個(gè)key的情況

示例1：

1 #__slots__ (作用：就是節(jié)省內(nèi)存)

2 #一個(gè)key的值

3

4 classFoo:5 __slots__='name' #定義在類(lèi)中的類(lèi)變量，由這個(gè)類(lèi)產(chǎn)生的實(shí)例，不在具有__dict__的屬性字典，限制了創(chuàng)建屬性

6

7 f1=Foo()8 f1.name='agon'

9 print(f1.name) #只能有一個(gè)name屬性

10 print(Foo.__slots__)11 print(f1.__slots__)

執(zhí)行結(jié)果：

1 agon2 name3 name

View Code

2、兩個(gè)key的情況

示例2：

1 #兩個(gè)key的情況

2 classFoo:3 __slots__=['name','age']4

5 f1=Foo()6

7 print(Foo.__slots__)8 print(f1.__slots__)9 f1.name='egon'

10 f1.age=17

11 print(f1.name)12 print(f1.age)13 #f1.gender='male' #會(huì)報(bào)錯(cuò)，加不上,#AttributeError: 'Foo' object has no attribute 'gender'

14

15 #只能定義__slots__提供的屬性(這里就定義了兩個(gè)屬性)大家都用一個(gè)屬性字典,優(yōu)勢(shì)就是節(jié)省內(nèi)存

16 f2=Foo()17 print(f2.__slots__)18 f2.name='alex'

19 f2.age=18

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

執(zhí)行結(jié)果：

1 ['name', 'age']2 ['name', 'age']3 egon4 17

5 ['name', 'age']6 alex7 18

十二、__doc__

1、它類(lèi)的描述信息

示例：

1 classFoo:2 '我是描述信息'

3 pass

4

5 print(Foo.__doc__)

2、該屬性無(wú)法繼承

示例：

1 #__doc__ 該屬性無(wú)法繼承

2

3 classFoo:4 pass

5

6 classBar(Foo):7 pass

8

9 print(Foo.__dict__) #只要加上了__doc__,該屬性就無(wú)法繼承給子類(lèi)

10 print(Bar.__dict__) #原理就是在底層字典里面，會(huì)加一個(gè)'__doc__': None,

十三、__module__和__class__

__module__ 表示當(dāng)前操作的對(duì)象在那個(gè)模塊

__class__ ? ? 表示當(dāng)前操作的對(duì)象的類(lèi)是什么

1、創(chuàng)建lib/aa.py

1 #!/usr/bin/env python

2 #-*- coding:utf-8 -*-

3

4 classC:5

6 def __init__(self):7 self.name = ‘SB'8

9 lib/aa.py

2、輸出模塊和輸出類(lèi)

1 from lib.aa importC2

3 obj =C()4 print obj.__module__ #輸出 lib.aa，即：輸出模塊

5 print obj.__class__ #輸出 lib.aa.C，即：輸出類(lèi)

十四、__del__ 析構(gòu)方法(垃圾回收時(shí)自動(dòng)觸發(fā))

析構(gòu)方法，當(dāng)對(duì)象在內(nèi)存中被釋放時(shí)，自動(dòng)觸發(fā)執(zhí)行。

注：此方法一般無(wú)須定義，因?yàn)镻ython是一門(mén)高級(jí)語(yǔ)言，程序員在使用時(shí)無(wú)需關(guān)心內(nèi)存的分配和釋放，因?yàn)榇斯ぷ鞫际墙唤oPython解釋器來(lái)執(zhí)行，所以，析構(gòu)函數(shù)的調(diào)用是由解釋器在進(jìn)行垃圾回收時(shí)自動(dòng)觸發(fā)執(zhí)行的。

1 classFoo:2 def __init__(self,name):3 self.name=name4 def __del__(self):5 print('我執(zhí)行啦')6

7 f1=Foo('alex')8

9 #del f1 #刪除實(shí)例會(huì)觸發(fā)__del__

10 del f1.name #刪除實(shí)例的屬性不會(huì)觸發(fā)__del__

11 print('---------------->')

執(zhí)行結(jié)果：

1 ---------------->

2 我執(zhí)行啦

十五、__call__

示例：

1 classFoo:2 def __call__(self, *args, **kwargs):3 print('實(shí)例執(zhí)行啦 obj()')4

5 f1=Foo() #Foo下的__call__

6

7 f1() #abc下的__call__

執(zhí)行結(jié)果：

1 實(shí)例執(zhí)行啦 obj()

十六、?__next__和__iter__實(shí)現(xiàn)迭代器協(xié)議

一、什么是迭代器協(xié)議

1.迭代器協(xié)議是指：對(duì)象必須提供一個(gè)next方法，執(zhí)行該方法要么返回迭代中的下一項(xiàng)，要么就引起一個(gè)StopIteration異常，以終止迭代 (只能往后走不能往前退)

2.可迭代對(duì)象：實(shí)現(xiàn)了迭代器協(xié)議的對(duì)象(如何實(shí)現(xiàn)：對(duì)象內(nèi)部定義一個(gè)__iter__()方法)

3.協(xié)議是一種約定，可迭代對(duì)象實(shí)現(xiàn)了迭代器協(xié)議，python的內(nèi)部工具(如for循環(huán)，sum，min，max函數(shù)等)使用迭代器協(xié)議訪(fǎng)問(wèn)對(duì)象。

二、python中強(qiáng)大的for循環(huán)機(jī)制

for循環(huán)的本質(zhì)：循環(huán)所有對(duì)象，全都是使用迭代器協(xié)議。

(字符串，列表，元組，字典，集合，文件對(duì)象)這些都不是可迭代對(duì)象，只不過(guò)在for循環(huán)式，調(diào)用了他們內(nèi)部的__iter__方法，把他們變成了可迭代對(duì)象

然后for循環(huán)調(diào)用可迭代對(duì)象的__next__方法去取值，而且for循環(huán)會(huì)捕捉StopIteration異常，以終止迭代。

示例1：

1 #迭代器協(xié)議

2

3 classFoo:4 pass

5

6 l = list('hello')7 for i in l: #for循環(huán)本質(zhì)就是調(diào)用他：f1.__iter__() == iter(f1)

8 print(i)

執(zhí)行結(jié)果：

1 h2 e3 l4 l5 o

View Code

示例2：

1 classFoo:2 def __init__(self,n):3 self.n=n4

5 def __iter__(self): #把一個(gè)對(duì)象就成一個(gè)可迭代對(duì)象，必須有__iter__

6 returnself7

8 def __next__(self):9 self.n+=1

10 returnself.n11

12 f1=Foo(10)13 #for i in f1: #for循環(huán)本質(zhì)就是調(diào)用他：f1.__iter__() == iter(f1)

14 #print(i)

15

16 print(f1.__next__())17 print(next(f1))18 print(next(f1))19 print(next(f1))20 print(next(f1))21 print(next(f1))22

23

24 for i in f1: #for循環(huán)本質(zhì)就是調(diào)用他：f1.__iter__() == iter(f1)

25 print(i)

執(zhí)行結(jié)果：

1 11

2 12

3 13

4 14

5 15

6 16

7 17

8 18

9 19

10 20

11 21

12 22

13 23

14 24

15 25

16 26

17 會(huì)一直無(wú)限循環(huán)下去.....18 下面部分省略.....

View Code

示例3：

1 classFoo:2 def __init__(self,n):3 self.n=n4

5 def __iter__(self): #把一個(gè)對(duì)象就成一個(gè)可迭代對(duì)象，必須有__iter__

6 returnself7

8 def __next__(self):9 if self.n == 13:10 raise StopIteration('終止了')11 self.n+=1

12 returnself.n13

14

15 f1=Foo(10)16

17 #print(f1.__next__())

18 #print(f1.__next__())

19 #print(f1.__next__())

20 #print(f1.__next__())

21

22 for i in f1: #f1.__iter__() == iter(f1)

23 print(i) #obj.__next__()

執(zhí)行結(jié)果：

1 11

2 12

3 13

View Code

三、斐波那契數(shù)列

什么是斐波那契數(shù)列？

斐波那契數(shù)列指的是這樣一個(gè)數(shù)列 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946........

這個(gè)數(shù)列從第3項(xiàng)開(kāi)始，每一項(xiàng)都等于前兩項(xiàng)之和。

示例1:

1 1 2 (相當(dāng)于1+1=2) #后面這個(gè)數(shù)是前兩個(gè)數(shù)之和

3 5 8 (相當(dāng)于3+5=8) ? #后面這個(gè)數(shù)是前兩個(gè)數(shù)之和

用迭代器協(xié)議的方法實(shí)現(xiàn)：一次產(chǎn)生一個(gè)值

示例2：

1 #斐波那契數(shù)列

2 classFib:3 def __init__(self):4 self._a=1

5 self._b=1

6

7 def __iter__(self):8 returnself9 def __next__(self):10 if self._a > 100:11 raise StopIteration('終止了') # >100 就拋出異常12 self._a,self._b=self._b,self._a +self._b #1+1=b; a,b=b,a(等于交換值)13 returnself._a14

15 f1=Fib()16 print(next(f1))17 print(next(f1))18 print(next(f1))19 print(next(f1))20 print(next(f1))21 print('==================================')22 for i inf1:23 print(i)

執(zhí)行結(jié)果：

1 1

2 2

3 3

4 5

5 8 #print(next(f1))

6 ==================================

7 13 #for循環(huán)的值

8 21

9 34

10 55

11 89

12 144

十七、描述符(__get__,__set__,__delete__) ?(新式類(lèi)中描述符在大型開(kāi)發(fā)中常用，必須掌握。)

描述符是什么:描述符本質(zhì)就是一個(gè)新式類(lèi),在這個(gè)新式類(lèi)中,至少實(shí)現(xiàn)了__get__(),__set__(),__delete__()三個(gè)方法中的一個(gè),這也被稱(chēng)為描述符協(xié)議。

1 class描述符：2 def __get__()：3 pass

4 def __set__()：5 pass

6 def __delete__()：7 pass

8

9 class類(lèi)：10 name=描述符()11

12 obj=類(lèi)()13 obj.name #get方法

14 obj.name='egon' #set方法

15 del obj.name #delete

描述符的三種方法：

__get__(): ?.調(diào)用一個(gè)屬性時(shí),觸發(fā)

__set__(): ? .為一個(gè)屬性賦值時(shí),觸發(fā)

__delete__(): ?采用del.刪除屬性時(shí),觸發(fā)

1、定義一個(gè)描述符

示例1：

1 class Foo: #在python3中Foo是新式類(lèi),它實(shí)現(xiàn)了三種方法,這個(gè)類(lèi)就被稱(chēng)作一個(gè)描述符

2 def __get__(self,instance,owner):3 print('get方法')4 def __set__(self, instance, value):5 print('set方法')6 def __delete__(self, instance):7 print('delete方法')

2、描述符是干什么的:描述符的作用是用來(lái)代理另外一個(gè)類(lèi)的屬性的(必須把描述符定義成這個(gè)類(lèi)的類(lèi)屬性，不能定義到構(gòu)造函數(shù)中)

示例2：

1 classFoo:2 def __get__(self,instance,owner):3 print('===>get方法')4 def __set__(self, instance, value):5 print('===>set方法')6 def __delete__(self, instance):7 print('===>delete方法')8

9 #包含這三個(gè)方法的新式類(lèi)稱(chēng)為描述符,由這個(gè)類(lèi)產(chǎn)生的實(shí)例進(jìn)行屬性的調(diào)用/賦值/刪除,并不會(huì)觸發(fā)這三個(gè)方法

10 f1=Foo()11 f1.name='egon'

12 print(f1.name)13 delf1.name14 #疑問(wèn):何時(shí),何地,會(huì)觸發(fā)這三個(gè)方法的執(zhí)行

3、描述符應(yīng)用之何時(shí)?何地?

示例3：

1 #描述符應(yīng)用之何時(shí)?何地?

2

3 #描述符Str

4 classFoo:5 def __get__(self,instance,owner):6 print('===>get方法')7 def __set__(self, instance, value):8 print('===>set方法')9 def __delete__(self, instance):10 print('===>delete方法')11

12

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

15

16 print(Bar.__dict__)17

18 #在何時(shí)？

19 b1=Bar()20 #b1.x #調(diào)用就會(huì)觸發(fā)上面的get方法

21 #b1.x=1 #賦值

22 #del b1.x

23 print(b1.x) #觸發(fā)了描述器里面的get方法，得到None

24 b1.x=1 #觸發(fā)了描述器里面的set方法,得到{}

25 print(b1.__dict__) #寫(xiě)到b1的屬性字典中

26

27 del b1.x #打印===>delete方法

執(zhí)行結(jié)果：

1 {'x': <__main__.foo object at>, '__weakref__': , '__dict__': , '__doc__': None, '__module__': '__main__'}2

3 ===>get方法4

5 None6

7 ===>set方法8

9 {}10

11 ===>delete方法

View Code

4、描述符分兩種

一、數(shù)據(jù)描述符:至少實(shí)現(xiàn)了__get__()和__set__()兩種方法

示例：

1 classFoo:2 def __set__(self, instance, value):3 print('set')4 def __get__(self, instance, owner):5 print('get')

二、非數(shù)據(jù)描述符:沒(méi)有實(shí)現(xiàn)__set__()方法

示例：

1 classFoo:2 def __get__(self, instance, owner):3 print('get')

5、注意事項(xiàng):

一、描述符本身應(yīng)該定義成新式類(lèi),被代理的類(lèi)也應(yīng)該是新式類(lèi)

二、必須把描述符定義成另外一個(gè)類(lèi)觸發(fā)的類(lèi)屬性，不能為定義到構(gòu)造函數(shù)中

示例：

1 classFoo:2 def __get__(self,instance,owner):3 print('===>get方法')4 def __set__(self, instance, value):5 print('===>set方法')6 def __delete__(self, instance):7 print('===>delete方法')8

9 classBar:10 x=Foo() #定義一個(gè)描述符

11 def __init__(self,n):12 self.x=n13

14 b1=Bar(10) #觸發(fā)set方法

15 print(b1.__dict__)

執(zhí)行結(jié)果：

1 ===>set方法2 {}

三、要嚴(yán)格遵循該優(yōu)先級(jí),優(yōu)先級(jí)由高到底分別是

1.類(lèi)屬性

2.數(shù)據(jù)描述符

3.實(shí)例屬性

4.非數(shù)據(jù)描述符

5.找不到的屬性觸發(fā)__getattr__()

類(lèi)屬性>數(shù)據(jù)描述符

示例：

1 classFoo:2 def __get__(self,instance,owner):3 print('===>get方法')4 def __set__(self, instance, value):5 print('===>set方法')6 def __delete__(self, instance):7 print('===>delete方法')8

9 classBar:10 x=Foo() #調(diào)用foo()屬性，會(huì)觸發(fā)get方法

11

12 print(Bar.x) #類(lèi)屬性比描述符有更高的優(yōu)先級(jí)，會(huì)觸發(fā)get方法

13 Bar.x=1 #自己定義了一個(gè)類(lèi)屬性，并賦值給x,跟描述符沒(méi)有關(guān)系，所以他不會(huì)觸發(fā)描述符的方法

14 #print(Bar.__dict__)

15 print(Bar.x)

執(zhí)行結(jié)果：

1 ===>get方法2 None3 1

數(shù)據(jù)描述符>實(shí)例屬性

示例1：

1 #有g(shù)et,set就是數(shù)據(jù)描述符，數(shù)據(jù)描述符比實(shí)例屬性有更高的優(yōu)化級(jí)

2

3 classFoo:4 def __get__(self,instance,owner):5 print('===>get方法')6 def __set__(self, instance, value):7 print('===>set方法')8 def __delete__(self, instance):9 print('===>delete方法')10

11 classBar:12 x = Foo() #調(diào)用foo()屬性，會(huì)觸發(fā)get方法

13

14 b1=Bar() #在自己的屬性字典里面找，找不到就去類(lèi)里面找，會(huì)觸發(fā)__get__方法

15 b1.x #調(diào)用一個(gè)屬性的時(shí)候觸發(fā)get方法

16 b1.x=1 #為一個(gè)屬性賦值的時(shí)候觸發(fā)set方法

17 del b1.x #采用del刪除屬性時(shí)觸發(fā)delete方法

執(zhí)行結(jié)果:

1 1 ===>get方法2 2 ===>set方法3 3 ===>delete方法

示例2：

1 classFoo:2 def __get__(self,instance,owner):3 print('===>get方法')4

5 def __set__(self, instance, value):6 pass

7

8 classBar:9 x =Foo()10

11 b1=Bar()12 b1.x=1 #觸發(fā)的是非數(shù)據(jù)描述符的set方法

13 print(b1.__dict__)

執(zhí)行結(jié)果：

1 {} #數(shù)據(jù)描述符>實(shí)例屬性

類(lèi)屬性>數(shù)據(jù)描述符>實(shí)例屬性

1 #類(lèi)屬性>數(shù)據(jù)描述符>實(shí)例屬性

2

3 classFoo:4 def __get__(self,instance,owner):5 print('===>get方法')6 def __set__(self, instance, value):7 print('===>set方法')8 def __delete__(self, instance):9 print('===>delete方法')10

11 classBar:12 x = Foo() #調(diào)用foo()屬性，會(huì)觸發(fā)get方法

13

14 b1=Bar() #實(shí)例化

15 Bar.x=11111111111111111 #不會(huì)觸發(fā)get方法

16 b1.x #會(huì)觸發(fā)get方法

17

18 del Bar.x #已經(jīng)給刪除，所以調(diào)用不了！報(bào)錯(cuò)：AttributeError: 'Bar' object has no attribute 'x'

19 b1.x

非數(shù)據(jù)描述符

示例1：

1 #非數(shù)據(jù)描述符沒(méi)有set方法

2 classFoo:3 def __get__(self,instance,owner):4 print('===>get方法')5

6 def __delete__(self, instance):7 print('===>delete方法')8

9 classBar:10 x =Foo()11

12 b1=Bar()13 b1.x #自己類(lèi)中沒(méi)有，就會(huì)去Foo類(lèi)中找，所以就會(huì)觸發(fā)__get__方法

執(zhí)行結(jié)果：

===>get方法

示例2：

1 #實(shí)例屬性>非數(shù)據(jù)描述符

2 classFoo:3 def __get__(self,instance,owner):4 print('===>get方法')5

6 classBar:7 x =Foo()8

9 b1=Bar()10 b1.x=1

11 print(b1.__dict__) #在自己的屬性字典里面，{'x': 1}

執(zhí)行結(jié)果：

1 {'x': 1}

非數(shù)據(jù)描述符>找不到

1 #非數(shù)據(jù)描述符>找不到

2

3 classFoo:4 def __get__(self,instance,owner):5 print('===>get方法')6

7 classBar:8 x =Foo()9 def __getattr__(self, item):10 print('------------>')11

12 b1=Bar()13 b1.xxxxxxxxxxxxxxxxxxx #調(diào)用沒(méi)有的xxxxxxx，就會(huì)觸發(fā)__getattr__方法

執(zhí)行結(jié)果：

1 ------------> #解發(fā)__getattr__方法

四、描述符應(yīng)用

示例1：

1 classTyped: #有__get__，__set__,__delete__ 就是：數(shù)據(jù)描述符2 def __get__(self, instance,owner):3 print('get方法')4 print('instance參數(shù)【%s】' %instance)5 print('owner參數(shù)【%s】' %owner)6

7 def __set__(self, instance, value):8 print('set方法')9 print('instance參數(shù)【%s】' %instance)10 print('value參數(shù)【%s】' %value)11

12 def __delete__(self, instance):13 print('delete方法')14 print('instance參數(shù)【%s】'%instance)15

16

17 classPeople:18 name=Typed() #設(shè)置代理(代理的就是name屬性)19 def __init__(self,name,age,salary):20 self.name=name #觸發(fā)的是代理

21 self.age=age22 self.salary=salary23

24 p1=People('alex',13,13.3)25 #'alex' #觸發(fā)set方法

26 p1.name #觸發(fā)get方法，沒(méi)有返回值

27 p1.name='age' #觸發(fā)set方法

28 print(p1.__dict__) #{'salary': 13.3, 'age': 13}

執(zhí)行結(jié)果：

1 set方法2 instance參數(shù)【<__main__.people object at>】3 value參數(shù)【alex】4 get方法5 instance參數(shù)【<__main__.people object at>】6 owner參數(shù)【】7 set方法8 instance參數(shù)【<__main__.people object at>】9 value參數(shù)【age】10 {'salary': 13.3, 'age': 13}

View Code

示例2：給字典屬性傳值

1 #給字典里面?zhèn)魅胫?/p>

2 classTyped:3 def __init__(self,key):4 self.key=key5

6 def __get__(self, instance, owner):7 print('get方法')8 return instance.__dict__[self.key] #觸發(fā)get方法，會(huì)返回字典的值

9

10 def __set__(self, instance, value):11 print('set方法')12 instance.__dict__[self.key]=value #存在p1的屬性字典里面

13

14 def __delete__(self, instance):15 print('delete方法')16 instance.__dict__.pop(self.key)17

18 classPeople:19 name=Typed('name') #name屬性被Typed給代理了，t1._set_() self._set__()

20 def __init__(self,name,age,salary):21 self.name=name22 self.age=age23 self.salary=salary24

25 p1=People('alex',13,13.3)26

27 #打印實(shí)例字典

28 print(p1.__dict__)29

30 #創(chuàng)建屬性，給name賦值，相當(dāng)于修改了name字典的值

31 p1.name='egon' #觸發(fā)的是set方法

32 print(p1.__dict__)33

34 #刪除name屬性

35 print(p1.__dict__)36 del p1.name #觸發(fā)的是delete方法

37 print(p1.__dict__)

執(zhí)行結(jié)果：

1 #打印實(shí)例屬性字典

2 set方法3 {'age': 13, 'salary': 13.3, 'name': 'alex'}4

5 #修改name字典的值

6 set方法7 {'age': 13, 'salary': 13.3, 'name': 'egon'}8

9 #刪除name屬性

10 delete方法11 {'age': 13, 'salary': 13.3}

示例3：

實(shí)現(xiàn)類(lèi)型檢測(cè)的兩種方法：

方法一：用return的方式

1 #判斷他傳入的值是不是字符串類(lèi)型

2 classTyped:3 def __init__(self,key):4 self.key=key5

6 def __get__(self, instance, owner):7 print('get方法')8 return instance.__dict__[self.key] #觸發(fā)get方法，會(huì)返回字典的值

9

10 def __set__(self, instance, value):11 print('set方法')12 if notisinstance(value,str):13 print('你傳入的類(lèi)型不是字符串，錯(cuò)誤')14 return #return的作用就是終止這個(gè)屬性字典，讓他的值設(shè)置不進(jìn)字典中。

15 instance.__dict__[self.key]=value #存在p1的屬性字典里面

16

17 def __delete__(self, instance):18 print('delete方法')19 instance.__dict__.pop(self.key)20

21 classPeople:22 name=Typed('name') #name屬性被Typed給代理了，t1._set_() self._set__()

23 def __init__(self,name,age,salary):24 self.name=name25 self.age=age26 self.salary=salary27

28 #正常的情況下__dict__里面有沒(méi)有'name':'alex'

29 p1=People('alex',13,13.3)30 print(p1.__dict__) #觸發(fā)set方法，得到的值是{'salary': 13.3, 'name': 'alex', 'age': 13}

31

32 #不正常的情況下，修改'name':213 不等于字符串，改成了int類(lèi)型

33 p1=People(213,13,13.3)34 print(p1.__dict__) #觸發(fā)set方法，得到的值是{'salary': 13.3, 'name': 'alex', 'age': 13}

執(zhí)行結(jié)果：

1 set方法2 {'salary': 13.3, 'age': 13, 'name': 'alex'}3

4 set方法5 你傳入的類(lèi)型不是字符串，錯(cuò)誤6 {'salary': 13.3, 'age': 13}

方法二：用raise拋出異常的方式，判斷他傳入的值是不是字符串類(lèi)型，(寫(xiě)死了，不靈活)

1 #用拋出異常的方式，判斷他傳入的值是不是字符串類(lèi)型

2 classTyped:3 def __init__(self,key):4 self.key=key5

6 def __get__(self, instance, owner):7 print('get方法')8 return instance.__dict__[self.key] #觸發(fā)get方法，會(huì)返回字典的值

9

10 def __set__(self, instance, value):11 print('set方法')12 if notisinstance(value,str): #判斷是否是字符串類(lèi)型13 #方法一：return的方式

14 # print('你傳入的類(lèi)型不是字符串，錯(cuò)誤')

15 # return #return的作用就是終止這個(gè)屬性字典，讓他的值設(shè)置不進(jìn)字典中。

16 #方法二：

17 raise TypeError('你傳入的類(lèi)型不是字符串') ##用拋出異常的方式，判斷他傳入的值是不是字符串類(lèi)型

18 instance.__dict__[self.key]=value #存在p1的屬性字典里面

19

20 def __delete__(self, instance):21 print('delete方法')22 instance.__dict__.pop(self.key)23

24 classPeople:25 name=Typed('name') #name屬性被Typed給代理了，t1._set_() self._set__()

26 def __init__(self,name,age,salary):27 self.name=name28 self.age=age29 self.salary=salary30

31 #正常的情況下__dict__里面有沒(méi)有'name':'alex'

32 #p1=People('alex',13,13.3)

33 #print(p1.__dict__) #觸發(fā)set方法，得到的值是{'salary': 13.3, 'name': 'alex', 'age': 13}

34

35 #不正常的情況下，修改'name':213 不等于字符串，改成了int類(lèi)型

36 p1=People(213,13,13.3)37 print(p1.__dict__) #觸發(fā)set方法，得到的值是{'salary': 13.3, 'name': 'alex', 'age': 13}

執(zhí)行結(jié)果：

1 Traceback (most recent call last):2 set方法3 File "D:/python/day28/5-1.py", line 219, in

4 {'name': 'alex', 'age': 13, 'salary': 13.3}5 set方法6 p1=People(213,13,13.3)7 File "D:/python/day28/5-1.py", line 210, in __init__

8 self.name=name9 File "D:/python/day28/5-1.py", line 200, in __set__

10 raise TypeError('你傳入的類(lèi)型不是字符串')11 TypeError: 你傳入的類(lèi)型不是字符串

類(lèi)型檢測(cè)加強(qiáng)版

示例:4：用raise拋出異常的方式，判斷傳入的值是什么類(lèi)型，同時(shí)可以判斷多個(gè)屬性(推薦寫(xiě)法)

1 #用拋出異常的方式，判斷他傳入的值是什么類(lèi)型 (不寫(xiě)死的方式，判斷傳入值的類(lèi)型)

2 classTyped:3 def __init__(self,key,expected_type):4 self.key=key5 self.expected_type=expected_type6

7 def __get__(self, instance, owner):8 print('get方法')9 return instance.__dict__[self.key] #觸發(fā)get方法，會(huì)返回字典的值

10

11 def __set__(self, instance, value):12 print('set方法')13 if notisinstance(value,self.expected_type):14 raise TypeError('%s 你傳入的類(lèi)型不是%s' %(self.key,self.expected_type)) #用拋出異常的方式，判斷他傳入的值是什么類(lèi)型，同時(shí)可以判斷多個(gè)屬性的類(lèi)型

15 instance.__dict__[self.key]=value #存在p1的屬性字典里面

16

17 def __delete__(self, instance):18 print('delete方法')19 instance.__dict__.pop(self.key)20

21 classPeople:22 name=Typed('name',str) #name設(shè)置代理Typed

23 age=Typed('age',int) #age設(shè)置代理Typed

24 def __init__(self,name,age,salary):25 self.name=name #alex傳給代理，會(huì)觸發(fā)set方法

26 self.age=age #age傳給代理，會(huì)觸發(fā)set方法

27 self.salary=salary28

29 #name是字符串，age是整型，salary必須是浮點(diǎn)數(shù)

30 #正確的方式

31 p1=People('alex',13,13.3)32

33 #傳入錯(cuò)誤的類(lèi)型，會(huì)判斷傳入值的類(lèi)型

34 #name要求傳入的srt,但這里傳入的是整型，所以會(huì)報(bào)錯(cuò)，說(shuō)你傳入的不是srt類(lèi)型

35 p1=People(213,13,13.3)

執(zhí)行結(jié)果：

1 set方法2 File "D:/python/day28/5-1.py", line 220, in

3 p1=People(213,13,13.3)4 set方法5 File "D:/python/day28/5-1.py", line 210, in __init__

6 set方法7 self.name=name8 File "D:/python/day28/5-1.py", line 199, in __set__

9 raise TypeError('%s 你傳入的類(lèi)型不是%s' %(self.key,self.expected_type)) #用拋出異常的方式，判斷他傳入的值是什么類(lèi)型

10

11 TypeError: name 你傳入的類(lèi)型不是

View Code

十八、__enter__和__exit__

1、操作文件寫(xiě)法

1 with open('a.txt') as f:2 　　'代碼塊'

2、上述叫做上下文管理協(xié)議，即with語(yǔ)句，為了讓一個(gè)對(duì)象兼容with語(yǔ)句，必須在這個(gè)對(duì)象的類(lèi)中聲明__enter__和__exit__方法

1 classOpen:2 def __init__(self,name):3 self.name=name4

5 def __enter__(self):6 print('出現(xiàn)with語(yǔ)句,對(duì)象的__enter__被觸發(fā),有返回值則賦值給as聲明的變量')7 #return self

8 def __exit__(self, exc_type, exc_val, exc_tb):9 print('with中代碼塊執(zhí)行完畢時(shí)執(zhí)行我啊')10

11

12 with Open('a.txt') as f: #with語(yǔ)句，觸發(fā)__enter__,返回值賦值給f13 print('=====>執(zhí)行代碼塊')14 #print(f,f.name)

執(zhí)行結(jié)果：

1 出現(xiàn)with語(yǔ)句,對(duì)象的__enter__被觸發(fā),有返回值則賦值給as聲明的變量2 =====>執(zhí)行代碼塊3 with中代碼塊執(zhí)行完畢時(shí)執(zhí)行我啊

3、執(zhí)行代碼塊

__exit__()中的三個(gè)參數(shù)分別代表異常類(lèi)型，異常值和追溯信息,with語(yǔ)句中代碼塊出現(xiàn)異常，則with后的代碼都無(wú)法執(zhí)行

沒(méi)有異常的情況下，整個(gè)代碼塊運(yùn)行完畢后去觸發(fā)__exit__,它的三個(gè)參數(shù)都會(huì)執(zhí)行

1 classFoo:2 def __init__(self,name):3 self.name=name4

5 def __enter__(self):6 print('執(zhí)行enter')

7 returnself #2、拿到的結(jié)果是self，并賦值給f8

9 def __exit__(self, exc_type, exc_val, exc_tb): #4、觸發(fā)__exit__,然后執(zhí)行print()10 print('執(zhí)行exit')11 print(exc_type)12 print(exc_val)13 print(exc_tb)14

15

16 with Foo('a.txt') as f: #1、with觸發(fā)的是__enter__,拿到的結(jié)果是self并賦值給f;17 print(f) #3、然后會(huì)執(zhí)行with代碼塊，執(zhí)行完畢后

18 print(assfsfdsfdsfdsfffsadfdsafdsafdsafdsafdsafdsafdsafdsad)

19 print(f.name)

20 print('000000000000000000000000000000000000000000000000000000')

執(zhí)行結(jié)果：

1 執(zhí)行enter2 Traceback (most recent call last):3 <__main__.foo object at>

4 File "D:/python/day28/s1.py", line 56, in

5 執(zhí)行exit6 print(assfsfdsfdsfdsfffsadfdsafdsafdsafdsafdsafdsafdsafdsad) #觸發(fā)__exit__

7

8 NameError: name 'assfsfdsfdsfdsfffsadfdsafdsafdsafdsafdsafdsafdsafdsad' is notdefined9 name 'assfsfdsfdsfdsfffsadfdsafdsafdsafdsafdsafdsafdsafdsad' is notdefined10

View Code

4、有返回值

如果__exit()返回值為T(mén)rue,那么異常會(huì)被清空，就好像啥都沒(méi)發(fā)生一樣，with后的語(yǔ)句正常執(zhí)行

1 classFoo:2 def __init__(self,name):3 self.name=name4

5 def __enter__(self):6 print('執(zhí)行enter')

7 returnself8 '''class、異常值、追蹤信息'''

9 def __exit__(self, exc_type, exc_val, exc_tb): #2、有異常的時(shí)候，就會(huì)觸發(fā)__exit__方法10 print('執(zhí)行exit')11 print(exc_type)12 print(exc_val)13 print(exc_tb)14 return True #3、沒(méi)有return True就會(huì)報(bào)錯(cuò)，如果有return True異常自己吃了，不報(bào)異常

15

16 with Foo('a.txt') as f:17 print(f)

18 print(assfsfdsfdsfdsfffsadfdsafdsafdsafdsafdsafdsafdsafdsad) #1、有異常的情況，他就會(huì)觸發(fā)__exit__

19 print(f.name) #不執(zhí)行這行，直接打印下面那行

20 print('000000000000000000000000000000000000000000000000000000') #4、最后打印這行

執(zhí)行結(jié)果：

1 執(zhí)行enter2 <__main__.foo object at>

3 執(zhí)行exit4

5 name 'assfsfdsfdsfdsfffsadfdsafdsafdsafdsafdsafdsafdsafdsad' is notdefined6

7 000000000000000000000000000000000000000000000000000000

View Code

總結(jié)：

with obj as f:

'代碼塊'

1.with obj ---->觸發(fā)obj.__enter__(),拿到返回值

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

3.with obj as f 等同于 f=obj.__enter__()

4.執(zhí)行代碼塊

一：沒(méi)有異常的情況下，整個(gè)代碼塊運(yùn)行完畢后去觸發(fā)__exit__,它的三個(gè)參數(shù)都為None

二：有異常的情況下，從異常出現(xiàn)的位置直接觸發(fā)__exit__

a：如果__exit__的返回值為T(mén)rue，代表吞掉了異常

b：如果__exit__的返回值不為T(mén)rue，代表吐出了異常

c：__exit__的的運(yùn)行完畢就代表了整個(gè)with語(yǔ)句的執(zhí)行完畢

用途：

1.使用with語(yǔ)句的目的就是把代碼塊放入with中執(zhí)行，with結(jié)束后，自動(dòng)完成清理工作，無(wú)須手動(dòng)干預(yù)

2.在需要管理一些資源比如文件，網(wǎng)絡(luò)連接(TCP協(xié)議建連接、傳輸數(shù)據(jù)、關(guān)連接)和鎖(進(jìn)程，線(xiàn)程)的編程環(huán)境中，可以在__exit__中定制自動(dòng)釋放資源的機(jī)制，你無(wú)須再去關(guān)系這個(gè)問(wèn)題，這將大有用處。

十九、類(lèi)的裝飾器

示例1：類(lèi)的裝飾器基本原理

1 #示例1

2 defdeco(func): #高階函數(shù)3 print('===================')4 return func #fuc=test

5

6 @deco #裝飾器test=deco(test)

7 deftest():8 print('test函數(shù)運(yùn)行')9 test() #運(yùn)行test

執(zhí)行結(jié)果：

1 ===================

2 test函數(shù)運(yùn)行

示例2：類(lèi)的裝飾器基本原理

1 defdeco(obj):2 print('============',obj)3 obj.x=1 #增加屬性

4 obj.y=2

5 obj.z=3

6 returnobj7

8 @deco #Foo=deco(Foo) #@deco語(yǔ)法糖的基本原理(語(yǔ)法糖可以在函數(shù)前面加，也可以在類(lèi)的前面加)

9 classFoo: #類(lèi)的裝飾器10 pass

11

12 print(Foo.__dict__) #加到屬性字典中

執(zhí)行結(jié)果：

1 ============

2 {'__module__': '__main__', 'z': 3, 'x': 1, '__dict__': , '__doc__': None, '__weakref__': , 'y': 2}

用法總結(jié)：@deco語(yǔ)法糖可以在函數(shù)前面加，也可以在類(lèi)的前面加

示例3：一切皆對(duì)象

1 defdeco(obj):2 print('==========',obj)3 obj.x=1

4 obj.y=2

5 obj.z=3

6 returnobj7

8 #@deco #Foo=deco(test)

9 deftest():10 print('test函數(shù)')11 test.x=1 #但沒(méi)有人會(huì)這么做，只是驗(yàn)證一切皆對(duì)象

12 test.y=1

13 print(test.__dict__)

執(zhí)行結(jié)果：

1 {'x': 1, 'y': 1}

示例4：直接傳值并加到字典中

1 def Typed(**kwargs): #負(fù)責(zé)接收參數(shù)

2 def deco(obj): #局部作用域

3 obj.x=1

4 obj.y=2

5 obj.z=3

6 returnobj7 print('====>',kwargs) #外層傳了個(gè)字典進(jìn)來(lái)，就是： 'y': 2, 'x': 1,

8 returndeco9

10 @Typed(x=1,y=2,z=3) #typed(x=1,y=2,z=3)--->deco 函數(shù)名加()就是運(yùn)行Typed函數(shù)

11 classFoo:12 pass

執(zhí)行結(jié)果:

1 ====> {'y': 2, 'x': 1, 'z': 3}

示例5：類(lèi)的裝飾器增強(qiáng)版

1 def Typed(**kwargs): #Type傳過(guò)來(lái)的參數(shù)，就是name='egon',kwargs包含的就是一個(gè)字典2 defdeco(obj):3 for key,val inkwargs.items(): #key=name,val=age4 setattr(obj,key,val) #obj=類(lèi)名，key=name,val=age5 returnobj #返回類(lèi)本身:obj,就相當(dāng)于給類(lèi)加了個(gè)屬性6 returndeco7

8 @Typed(x=1,y=2,z=3) #1、typed(x=1,y=2,z=3)--->deco 2、@deco--->Foo=deco(Foo)

9 classFoo:10 pass

11 print(Foo.__dict__)12

13 @Typed(name='egon') #@deco---->Bar=deco(Bar),重新賦值給了Bar14 classBar:15 pass

16 print(Bar.name) #最后打印name,就得到egon

執(zhí)行結(jié)果：

1 {'y': 2, '__dict__': , 'z': 3, '__weakref__': , '__module__': '__main__','x': 1, '__doc__': None}2

3 egon

實(shí)現(xiàn)：類(lèi)型檢測(cè)控制傳入的值是什么類(lèi)型

1、用raise拋出異常的方式實(shí)現(xiàn)

2、用類(lèi)加裝飾器實(shí)現(xiàn) (這種方法更高級(jí))

示例6：類(lèi)加裝飾器的應(yīng)用

示例如下：

1、給類(lèi)加裝飾器，實(shí)現(xiàn)控制傳入的類(lèi)型(推薦寫(xiě)法) ?可以參考: ?示例:4：用raise拋出異常的方式，判斷傳入的值是什么類(lèi)型，同時(shí)可以判斷多個(gè)屬性。

1 #給類(lèi)加裝飾器，實(shí)現(xiàn)控制傳入的類(lèi)型

2

3 classTyped:4 def __init__(self,key,expected_type):5 self.key=key6 self.expected_type=expected_type7

8 def __get__(self, instance, owner):9 print('get方法')10 return instance.__dict__[self.key]11

12 def __set__(self, instance, value):13 print('set方法')14 if notisinstance(value,self.expected_type):15 raise TypeError('%s 傳入的類(lèi)型不是%s' %(self.key,self.expected_type))16 instance.__dict__[self.key]=value17

18 def __delete__(self, instance):19 print('delete方法')20 instance.__dict__.pop(self.key)21

22 def deco(**kwargs): #kwargs={'name':str,'age':int}

23 def wrapper(obj): #obj=People

24 for key,val in kwargs.items(): #(('name',str),('age',int))

25 #print(obj,key)

26 setattr(obj,key,Typed(key,val)) #給People設(shè)置類(lèi)屬性

27 returnobj28 returnwrapper29

30 #給類(lèi)加裝飾器，加了裝飾器，指定了什么類(lèi)型，就必須傳入什么類(lèi)型的值，否則就會(huì)報(bào)錯(cuò)

31 @deco(name=str,age=int,salary=float) #@wrapper ===>People=wrapper(People) #實(shí)現(xiàn)這個(gè)功能的重點(diǎn)在這里

32 classPeople:33 #name=Typed('name',int)

34 def __init__(self,name,age,salary):35 self.name=name36 self.age=age37 self.salary=salary38

39 #name=srt,age=int,salary=float

40#傳入的是正確的類(lèi)型，所以不會(huì)報(bào)錯(cuò)。

41 p1 = People('alex', 13, 13.3)42 print(People.__dict__)43

44 #age設(shè)置成了int型，我們傳入的是字符串類(lèi)型，所以會(huì)報(bào)錯(cuò)：TypeError: age 傳入的類(lèi)型不是

45 #p1=People('alex','13',13.3)

46 #print(People.__dict__)

執(zhí)行結(jié)果：

1 #傳入正確類(lèi)型的值

2

3 set方法4 set方法5 set方法6 {'__doc__': None, 'name': <__main__.typed object at>, '__dict__': , '__module__': '__main__', '__init__': , 'salary': <__main__.typed object at>, '__weakref__': , 'age': <__main__.typed object at>}7

8 #傳入錯(cuò)誤類(lèi)型的值，會(huì)報(bào)錯(cuò)，并提示你傳入值的類(lèi)型。

示例7：利用描述自定制property

1 classLazyproperty:2 def __init__(self,func):3 print('===========>',func)4 self.func=func5 def __get__(self,instance,owner):6 print('get')7 print('instance')8 print('owner')9 res=self.func(instance)10 returnres11 classRoom:12 def __init__(self,name,width,length):13 self.name=name14 self.width=width15 self.length=length16 @Lazyproperty17 defarea(self):18 return self.width *self.length19

20 r1=Room('廁所',1,1)21 print(r1.area)

執(zhí)行結(jié)果：

1 get2 instance3 owner4 1

示例8：利用描述符實(shí)現(xiàn)延遲計(jì)算

1 classLazyproperty:2 def __init__(self,func):3 print('===========>',func)4 self.func=func5 def __get__(self,instance,owner):6 print('get')7 print('instance')8 print('owner')9 res=self.func(instance)10 returnres11 classRoom:12 def __init__(self,name,width,length):13 self.name=name14 self.width=width15 self.length=length16 @Lazyproperty17 defarea(self):18 return self.width *self.length19

20 r1=Room('廁所',1,1)21 print(r1.area)

示例9：非數(shù)據(jù)描述符

1 classLazyproperty:2 def __init__(self,func):3 self.func=func4

5 def __get__(self, instance, owner):6 print('get')7

8 if instance isNone:9 returnself10 res=self.func(instance)11 setattr(instance,self.func.__name__,res)12 returnres13

14 classRoom:15 def __init__(self,name,width,length):16 self.name=name17 self.width=width18 self.length=length19

20 @Lazyproperty21 defarea(self):22 return self.width *self.length23 @property24 defareal(self):25 return self.width *self.length26

27 r1=Room('廁所',1,1)28

29 print(r1.area)30 print(r1.__dict__)31

32 print(r1.area)33 print(r1.area)34 print(r1.area)35 print(r1.area)36 print(r1.area)37 print(r1.area)38 print(r1.area)39 print(r1.area)

執(zhí)行結(jié)果：

1 get2 1

3 {'area': 1, 'length': 1, 'name': '廁所', 'width': 1}4 1

5 1

6 1

7 1

8 1

9 1

10 1

11 1

二十、元類(lèi)(metaclass)

1、示例：

1 classFoo:2 pass

3

4 f1=Foo() #f1是通過(guò)Foo類(lèi)實(shí)例化的對(duì)象

python中一切皆是對(duì)象，類(lèi)本身也是一個(gè)對(duì)象，當(dāng)使用關(guān)鍵字class的時(shí)候，python解釋器在加載class的時(shí)候就會(huì)創(chuàng)建一個(gè)對(duì)象(這里的對(duì)象指的是類(lèi)而非類(lèi)的實(shí)例)

上例可以看出f1是由Foo這個(gè)類(lèi)產(chǎn)生的對(duì)象，而Foo本身也是對(duì)象，那它又是由哪個(gè)類(lèi)產(chǎn)生的呢？

1 classFoo:2 pass

3

4 f1=Foo()5

6 print(type(f1)) #

7 print(type(Foo)) #類(lèi)的類(lèi)就是

8

9 classBar:10 pass

11 print(type(Bar)) #

執(zhí)行結(jié)果：

1 #type函數(shù)可以查看類(lèi)型，也可以用來(lái)查看對(duì)象的類(lèi)，二者是一樣的。

2

3

4

2、什么是元類(lèi)？

元類(lèi)是類(lèi)的類(lèi)，是類(lèi)的模板

元類(lèi)是用來(lái)控制如何創(chuàng)建類(lèi)的，正如類(lèi)是創(chuàng)建對(duì)象的模板一樣

元類(lèi)的實(shí)例為類(lèi)，正如類(lèi)的實(shí)例為對(duì)象(f1對(duì)象是Foo類(lèi)的一個(gè)實(shí)例，Foo類(lèi)是 type 類(lèi)的一個(gè)實(shí)例)

type是python的一個(gè)內(nèi)建元類(lèi)，用來(lái)直接控制生成類(lèi)，python中任何class定義的類(lèi)其實(shí)都是type類(lèi)實(shí)例化的對(duì)象

3、創(chuàng)建類(lèi)的兩種方式

方式一：

1 classFoo:2 pass

3 print(Foo)4 print(Foo.__dict__)

執(zhí)行結(jié)果：

1

2 {'__module__': '__main__', '__doc__': None, '__dict__': , '__weakref__': }

方式二：

1 #type就是類(lèi)的類(lèi)，用type()實(shí)例化的結(jié)果，就是產(chǎn)生一個(gè)類(lèi)

2 #用type和class生成的類(lèi)是一樣的效果。

3

4 def __init__(self,name,age):5 self.name=name6 self.age=age7

8 deftest(self):9 print('=======執(zhí)行的是test=====>')10

11 FFo=type('FFo',(object,),{'x':1,'__init__':__init__,'test':test})12 print(FFo)13 #print(FFo.__dict__)

14

15 f1=FFo('alex',18)16 print(f1.x) #調(diào)的是類(lèi)屬性

17 print(f1.name) #調(diào)name

18 f1.test() #調(diào)方法

執(zhí)行結(jié)果：

1

2 1

3 alex4 =======執(zhí)行的是test=====>

4、一個(gè)類(lèi)沒(méi)有聲明自己的元類(lèi)，默認(rèn)他的元類(lèi)就是type，除了使用元類(lèi)type，用戶(hù)也可以通過(guò)繼承type來(lái)自定義元類(lèi)。

示例:??自定制元類(lèi)

1 classMyType(type):2 def __init__(self,a,b,c):3 print('元類(lèi)的構(gòu)造函數(shù)執(zhí)行')4

5 def __call__(self, *args, **kwargs):6 obj=object.__new__(self) #object.__new__(Foo)-->f1

7 self.__init__(obj,*args,**kwargs) #Foo.__init__(f1,*arg,**kwargs)

8 returnobj9

10 class Foo(metaclass=MyType): #Foo=MyType(Foo,'Foo',(),{})---》__init__

11 def __init__(self,name):12 self.name=name #f1.name=name

13 f1=Foo('alex')

執(zhí)行結(jié)果：

1 元類(lèi)的構(gòu)造函數(shù)執(zhí)行

總結(jié)

以上是生活随笔為你收集整理的python对象属性在引用时前面需要加()_python基础-面向对象进阶的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。