python对象属性在引用时前面需要加()_python基础-面向对象进阶
實現(xiàn)授權(quán)的關(guān)鍵點就是覆蓋__getattr__方法
1、通過觸發(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) #能過字符串來找到，并通過return返回，就找到了read方法，
12
13 f1=FileHandle('a.txt','r')14 print(f1.file)15 print(f1.__dict__) #類的字典里，沒有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、往文件里面寫入內(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負載過高\n')21 f1.write('內(nèi)存剩余不足\n')22 f1.write('硬盤剩余不足\n')
執(zhí)行結(jié)果：
會創(chuàng)建一個a.txt的文件，并往里面寫入內(nèi)容：
1 2016-12-23 18:34:16 1111111111111111
2 2016-12-23 18:34:16cpu負載過高3 2016-12-23 18:34:16內(nèi)存剩余不足4 2016-12-23 18:34:16 硬盤剩余不足
七、isinstance(obj,cls)和issubclass(sub,super)
1、isinstance(obj,cls) 檢查是否obj是否是類cls的對象
示例：
1 classFoo(object):2 pass
3
4 obj =Foo()5
6 print(isinstance(obj,Foo))
執(zhí)行結(jié)果：
1 True
2、issubclass(sub,super)檢查sub類是否是supper類的派生類
示例：
1 classFoo(object):2 pass
3
4 classBar(Foo):5 pass
6
7 print(issubclass(Bar,Foo))
執(zhí)行結(jié)果：
1 True
八、__getattribute__
示例1：
不存在的屬性訪問，就會觸發(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ā)__getattr__
執(zhí)行結(jié)果：
1 10
2 執(zhí)行的是我
示例2：
不管是否存在，都會執(zhí)行__getattribute__方法
1 classFoo:2 def __init__(self,x):3 self.x=x4
5 def __getattribute__(self, item):6 print('不管是否存在，我都會執(zhí)行')7
8 f1=Foo(10)9 f1.x10 f1.xxxxxxx
執(zhí)行結(jié)果：
1 不管是否存在，我都會執(zhí)行2 不管是否存在，我都會執(zhí)行
示例:3：
1 classFoo:2 def __init__(self,x):3 self.x=x4
5 def __getattr__(self, item): #相當于監(jiān)聽大哥的異常，大哥拋出導(dǎo)常，他就會接收。
6 print('執(zhí)行的是我')7 #return self.__dict__[item]
8
9 def __getattribute__(self, item):10 print('不管是否存在，我都會執(zhí)行')11 raise AttributeError('拋出異常了')12
13 f1=Foo(10)14 f1.x #結(jié)果是：10 ，調(diào)用會觸發(fā)系統(tǒng)的
15 f1.xxxxxxx #如果不存在會觸發(fā)自己定義的
執(zhí)行結(jié)果：
1 不管是否存在，我都會執(zhí)行2 執(zhí)行的是我3 不管是否存在，我都會執(zhí)行4 執(zhí)行的是我
九、__setitem__,__getitem,__delitem__ ?(操作字典就用item的方式)
obj[‘屬性’]的方式去操作屬性時觸發(fā)的方法
__getitem__:obj['屬性'] 時觸發(fā)
__setitem__:obj['屬性']=屬性的值 時觸發(fā)
__delitem__:del obj['屬性'] 時觸發(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]時,我執(zhí)行')12 self.__dict__.pop(key)13 def __delattr__(self, item):14 print('del obj.key時,我執(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時,我執(zhí)行2
3 delobj[key]時,我執(zhí)行4
5 {'name': 'alex'}
View Code
十、__str__, __repr__，__format__
1、改變對象的字符串顯示__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__ 共存時的用法
1 #當str與repr共存時
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__沒有被定義,那么就會使用__repr__來代替輸出
注意:這倆方法的返回值必須是字符串,否則拋出異常
2、自定制格式化字符串__format__
format的用法
示例1：
1 x = '{0}{0}{0}'.format('dog')2 print(x)
執(zhí)行結(jié)果：
1 dogdogdog
不用__format__的方式實現(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__的方式實現(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__是什么？是一個類變量,變量值可以是列表,元祖,或者可迭代對象,也可以是一個字符串(意味著所有實例只有一個數(shù)據(jù)屬性)
2.引子:使用點來訪問屬性本質(zhì)就是在訪問類或者對象的__dict__屬性字典(類的字典是共享的,而每個實例的是獨立的)
3.為何使用__slots__:字典會占用大量內(nèi)存,如果你有一個屬性很少的類,但是有很多實例,為了節(jié)省內(nèi)存可以使用__slots__取代實例的__dict__ 當你定義__slots__后,__slots__就會為實例使用一種更加緊湊的內(nèi)部表示。實例通過一個很小的固定大小的數(shù)組來構(gòu)建,而不是為每個實例定義一個 字典,這跟元組或列表很類似。在__slots__中列出的屬性名在內(nèi)部被映射到這個數(shù)組的指定小標上。使用__slots__一個不好的地方就是我們不能再給 實例添加新的屬性了,只能使用在__slots__中定義的那些屬性名。
4.注意事項:__slots__的很多特性都依賴于普通的基于字典的實現(xiàn)。另外,定義了__slots__后的類不再 支持一些普通類特性了,比如多繼承。大多數(shù)情況下,你應(yīng)該 只在那些經(jīng)常被使用到 的用作數(shù)據(jù)結(jié)構(gòu)的類上定義__slots__比如在程序中需要創(chuàng)建某個類的幾百萬個實例對象 。 關(guān)于__slots__的一個常見誤區(qū)是它可以作為一個封裝工具來防止用戶給實例增加新的屬性。盡管使用__slots__可以達到這樣的目的,但是這個并不是它的初衷。更多的是用來作為一個內(nèi)存優(yōu)化工具。
__slots__的作用：節(jié)省內(nèi)存空間
1、一個key的情況
示例1：
1 #__slots__ (作用：就是節(jié)省內(nèi)存)
2 #一個key的值
3
4 classFoo:5 __slots__='name' #定義在類中的類變量，由這個類產(chǎn)生的實例，不在具有__dict__的屬性字典，限制了創(chuàng)建屬性
6
7 f1=Foo()8 f1.name='agon'
9 print(f1.name) #只能有一個name屬性
10 print(Foo.__slots__)11 print(f1.__slots__)
執(zhí)行結(jié)果：
1 agon2 name3 name
View Code
2、兩個key的情況
示例2：
1 #兩個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' #會報錯，加不上,#AttributeError: 'Foo' object has no attribute 'gender'
14
15 #只能定義__slots__提供的屬性(這里就定義了兩個屬性)大家都用一個屬性字典,優(yōu)勢就是節(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、它類的描述信息
示例：
1 classFoo:2 '我是描述信息'
3 pass
4
5 print(Foo.__doc__)
2、該屬性無法繼承
示例：
1 #__doc__ 該屬性無法繼承
2
3 classFoo:4 pass
5
6 classBar(Foo):7 pass
8
9 print(Foo.__dict__) #只要加上了__doc__,該屬性就無法繼承給子類
10 print(Bar.__dict__) #原理就是在底層字典里面，會加一個'__doc__': None,
十三、__module__和__class__
__module__ 表示當前操作的對象在那個模塊
__class__ ? ? 表示當前操作的對象的類是什么
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、輸出模塊和輸出類
1 from lib.aa importC2
3 obj =C()4 print obj.__module__ #輸出 lib.aa，即：輸出模塊
5 print obj.__class__ #輸出 lib.aa.C，即：輸出類
十四、__del__ 析構(gòu)方法(垃圾回收時自動觸發(fā))
析構(gòu)方法，當對象在內(nèi)存中被釋放時，自動觸發(fā)執(zhí)行。
注：此方法一般無須定義，因為Python是一門高級語言，程序員在使用時無需關(guān)心內(nèi)存的分配和釋放，因為此工作都是交給Python解釋器來執(zhí)行，所以，析構(gòu)函數(shù)的調(diào)用是由解釋器在進行垃圾回收時自動觸發(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 #刪除實例會觸發(fā)__del__
10 del f1.name #刪除實例的屬性不會觸發(fā)__del__
11 print('---------------->')
執(zhí)行結(jié)果：
1 ---------------->
2 我執(zhí)行啦
十五、__call__
示例：
1 classFoo:2 def __call__(self, *args, **kwargs):3 print('實例執(zhí)行啦 obj()')4
5 f1=Foo() #Foo下的__call__
6
7 f1() #abc下的__call__
執(zhí)行結(jié)果：
1 實例執(zhí)行啦 obj()
十六、?__next__和__iter__實現(xiàn)迭代器協(xié)議
一、什么是迭代器協(xié)議
1.迭代器協(xié)議是指：對象必須提供一個next方法，執(zhí)行該方法要么返回迭代中的下一項，要么就引起一個StopIteration異常，以終止迭代 (只能往后走不能往前退)
2.可迭代對象：實現(xiàn)了迭代器協(xié)議的對象(如何實現(xiàn)：對象內(nèi)部定義一個__iter__()方法)
3.協(xié)議是一種約定，可迭代對象實現(xiàn)了迭代器協(xié)議，python的內(nèi)部工具(如for循環(huán)，sum，min，max函數(shù)等)使用迭代器協(xié)議訪問對象。
二、python中強大的for循環(huán)機制
for循環(huán)的本質(zhì)：循環(huán)所有對象，全都是使用迭代器協(xié)議。
(字符串，列表，元組，字典，集合，文件對象)這些都不是可迭代對象，只不過在for循環(huán)式，調(diào)用了他們內(nèi)部的__iter__方法，把他們變成了可迭代對象
然后for循環(huán)調(diào)用可迭代對象的__next__方法去取值，而且for循環(huán)會捕捉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): #把一個對象就成一個可迭代對象，必須有__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án)下去.....18 下面部分省略.....
View Code
示例3：
1 classFoo:2 def __init__(self,n):3 self.n=n4
5 def __iter__(self): #把一個對象就成一個可迭代對象，必須有__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ù)列指的是這樣一個數(shù)列 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946........
這個數(shù)列從第3項開始，每一項都等于前兩項之和。
示例1:
1 1 2 (相當于1+1=2) #后面這個數(shù)是前兩個數(shù)之和
3 5 8 (相當于3+5=8) ? #后面這個數(shù)是前兩個數(shù)之和
用迭代器協(xié)議的方法實現(xiàn)：一次產(chǎn)生一個值
示例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__) ?(新式類中描述符在大型開發(fā)中常用，必須掌握。)
描述符是什么:描述符本質(zhì)就是一個新式類,在這個新式類中,至少實現(xiàn)了__get__(),__set__(),__delete__()三個方法中的一個,這也被稱為描述符協(xié)議。
1 class描述符：2 def __get__()：3 pass
4 def __set__()：5 pass
6 def __delete__()：7 pass
8
9 class類：10 name=描述符()11
12 obj=類()13 obj.name #get方法
14 obj.name='egon' #set方法
15 del obj.name #delete
描述符的三種方法：
__get__(): ?.調(diào)用一個屬性時,觸發(fā)
__set__(): ? .為一個屬性賦值時,觸發(fā)
__delete__(): ?采用del.刪除屬性時,觸發(fā)
1、定義一個描述符
示例1：
1 class Foo: #在python3中Foo是新式類,它實現(xiàn)了三種方法,這個類就被稱作一個描述符
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、描述符是干什么的:描述符的作用是用來代理另外一個類的屬性的(必須把描述符定義成這個類的類屬性，不能定義到構(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 #包含這三個方法的新式類稱為描述符,由這個類產(chǎn)生的實例進行屬性的調(diào)用/賦值/刪除,并不會觸發(fā)這三個方法
10 f1=Foo()11 f1.name='egon'
12 print(f1.name)13 delf1.name14 #疑問:何時,何地,會觸發(fā)這三個方法的執(zhí)行
3、描述符應(yīng)用之何時?何地?
示例3：
1 #描述符應(yīng)用之何時?何地?
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 #在何時？
19 b1=Bar()20 #b1.x #調(diào)用就會觸發(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__) #寫到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ù)描述符:至少實現(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ù)描述符:沒有實現(xiàn)__set__()方法
示例：
1 classFoo:2 def __get__(self, instance, owner):3 print('get')
5、注意事項:
一、描述符本身應(yīng)該定義成新式類,被代理的類也應(yīng)該是新式類
二、必須把描述符定義成另外一個類觸發(fā)的類屬性，不能為定義到構(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() #定義一個描述符
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ōu)先級,優(yōu)先級由高到底分別是
1.類屬性
2.數(shù)據(jù)描述符
3.實例屬性
4.非數(shù)據(jù)描述符
5.找不到的屬性觸發(fā)__getattr__()
類屬性>數(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()屬性，會觸發(fā)get方法
11
12 print(Bar.x) #類屬性比描述符有更高的優(yōu)先級，會觸發(fā)get方法
13 Bar.x=1 #自己定義了一個類屬性，并賦值給x,跟描述符沒有關(guān)系，所以他不會觸發(fā)描述符的方法
14 #print(Bar.__dict__)
15 print(Bar.x)
執(zhí)行結(jié)果：
1 ===>get方法2 None3 1
數(shù)據(jù)描述符>實例屬性
示例1：
1 #有g(shù)et,set就是數(shù)據(jù)描述符，數(shù)據(jù)描述符比實例屬性有更高的優(yōu)化級
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()屬性，會觸發(fā)get方法
13
14 b1=Bar() #在自己的屬性字典里面找，找不到就去類里面找，會觸發(fā)__get__方法
15 b1.x #調(diào)用一個屬性的時候觸發(fā)get方法
16 b1.x=1 #為一個屬性賦值的時候觸發(fā)set方法
17 del b1.x #采用del刪除屬性時觸發(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ù)據(jù)描述符>實例屬性
1 #類屬性>數(shù)據(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()屬性，會觸發(fā)get方法
13
14 b1=Bar() #實例化
15 Bar.x=11111111111111111 #不會觸發(fā)get方法
16 b1.x #會觸發(fā)get方法
17
18 del Bar.x #已經(jīng)給刪除，所以調(diào)用不了！報錯：AttributeError: 'Bar' object has no attribute 'x'
19 b1.x
非數(shù)據(jù)描述符
示例1：
1 #非數(shù)據(jù)描述符沒有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 #自己類中沒有，就會去Foo類中找，所以就會觸發(fā)__get__方法
執(zhí)行結(jié)果：
===>get方法
示例2：
1 #實例屬性>非數(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)用沒有的xxxxxxx，就會觸發(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方法，沒有返回值
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方法，會返回字典的值
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 #打印實例字典
28 print(p1.__dict__)29
30 #創(chuàng)建屬性，給name賦值，相當于修改了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 #打印實例屬性字典
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：
實現(xiàn)類型檢測的兩種方法：
方法一：用return的方式
1 #判斷他傳入的值是不是字符串類型
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方法，會返回字典的值
9
10 def __set__(self, instance, value):11 print('set方法')12 if notisinstance(value,str):13 print('你傳入的類型不是字符串，錯誤')14 return #return的作用就是終止這個屬性字典，讓他的值設(shè)置不進字典中。
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__里面有沒有'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類型
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 你傳入的類型不是字符串，錯誤6 {'salary': 13.3, 'age': 13}
方法二：用raise拋出異常的方式，判斷他傳入的值是不是字符串類型，(寫死了，不靈活)
1 #用拋出異常的方式，判斷他傳入的值是不是字符串類型
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方法，會返回字典的值
9
10 def __set__(self, instance, value):11 print('set方法')12 if notisinstance(value,str): #判斷是否是字符串類型13 #方法一：return的方式
14 # print('你傳入的類型不是字符串，錯誤')
15 # return #return的作用就是終止這個屬性字典，讓他的值設(shè)置不進字典中。
16 #方法二：
17 raise TypeError('你傳入的類型不是字符串') ##用拋出異常的方式，判斷他傳入的值是不是字符串類型
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__里面有沒有'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類型
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('你傳入的類型不是字符串')11 TypeError: 你傳入的類型不是字符串
類型檢測加強版
示例:4：用raise拋出異常的方式，判斷傳入的值是什么類型，同時可以判斷多個屬性(推薦寫法)
1 #用拋出異常的方式，判斷他傳入的值是什么類型 (不寫死的方式，判斷傳入值的類型)
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方法，會返回字典的值
10
11 def __set__(self, instance, value):12 print('set方法')13 if notisinstance(value,self.expected_type):14 raise TypeError('%s 你傳入的類型不是%s' %(self.key,self.expected_type)) #用拋出異常的方式，判斷他傳入的值是什么類型，同時可以判斷多個屬性的類型
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傳給代理，會觸發(fā)set方法
26 self.age=age #age傳給代理，會觸發(fā)set方法
27 self.salary=salary28
29 #name是字符串，age是整型，salary必須是浮點數(shù)
30 #正確的方式
31 p1=People('alex',13,13.3)32
33 #傳入錯誤的類型，會判斷傳入值的類型
34 #name要求傳入的srt,但這里傳入的是整型，所以會報錯，說你傳入的不是srt類型
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 你傳入的類型不是%s' %(self.key,self.expected_type)) #用拋出異常的方式，判斷他傳入的值是什么類型
10
11 TypeError: name 你傳入的類型不是
View Code
十八、__enter__和__exit__
1、操作文件寫法
1 with open('a.txt') as f:2 '代碼塊'
2、上述叫做上下文管理協(xié)議，即with語句，為了讓一個對象兼容with語句，必須在這個對象的類中聲明__enter__和__exit__方法
1 classOpen:2 def __init__(self,name):3 self.name=name4
5 def __enter__(self):6 print('出現(xiàn)with語句,對象的__enter__被觸發(fā),有返回值則賦值給as聲明的變量')7 #return self
8 def __exit__(self, exc_type, exc_val, exc_tb):9 print('with中代碼塊執(zhí)行完畢時執(zhí)行我啊')10
11
12 with Open('a.txt') as f: #with語句，觸發(fā)__enter__,返回值賦值給f13 print('=====>執(zhí)行代碼塊')14 #print(f,f.name)
執(zhí)行結(jié)果：
1 出現(xiàn)with語句,對象的__enter__被觸發(fā),有返回值則賦值給as聲明的變量2 =====>執(zhí)行代碼塊3 with中代碼塊執(zhí)行完畢時執(zhí)行我啊
3、執(zhí)行代碼塊
__exit__()中的三個參數(shù)分別代表異常類型，異常值和追溯信息,with語句中代碼塊出現(xiàn)異常，則with后的代碼都無法執(zhí)行
沒有異常的情況下，整個代碼塊運行完畢后去觸發(fā)__exit__,它的三個參數(shù)都會執(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、然后會執(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()返回值為True,那么異常會被清空，就好像啥都沒發(fā)生一樣，with后的語句正常執(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、有異常的時候，就會觸發(fā)__exit__方法10 print('執(zhí)行exit')11 print(exc_type)12 print(exc_val)13 print(exc_tb)14 return True #3、沒有return True就會報錯，如果有return True異常自己吃了，不報異常
15
16 with Foo('a.txt') as f:17 print(f)
18 print(assfsfdsfdsfdsfffsadfdsafdsafdsafdsafdsafdsafdsafdsad) #1、有異常的情況，他就會觸發(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í)行代碼塊
一：沒有異常的情況下，整個代碼塊運行完畢后去觸發(fā)__exit__,它的三個參數(shù)都為None
二：有異常的情況下，從異常出現(xiàn)的位置直接觸發(fā)__exit__
a：如果__exit__的返回值為True，代表吞掉了異常
b：如果__exit__的返回值不為True，代表吐出了異常
c：__exit__的的運行完畢就代表了整個with語句的執(zhí)行完畢
用途：
1.使用with語句的目的就是把代碼塊放入with中執(zhí)行，with結(jié)束后，自動完成清理工作，無須手動干預(yù)
2.在需要管理一些資源比如文件，網(wǎng)絡(luò)連接(TCP協(xié)議建連接、傳輸數(shù)據(jù)、關(guān)連接)和鎖(進程，線程)的編程環(huán)境中，可以在__exit__中定制自動釋放資源的機制，你無須再去關(guān)系這個問題，這將大有用處。
十九、類的裝飾器
示例1：類的裝飾器基本原理
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ù)運行')9 test() #運行test
執(zhí)行結(jié)果：
1 ===================
2 test函數(shù)運行
示例2：類的裝飾器基本原理
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語法糖的基本原理(語法糖可以在函數(shù)前面加，也可以在類的前面加)
9 classFoo: #類的裝飾器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語法糖可以在函數(shù)前面加，也可以在類的前面加
示例3：一切皆對象
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 #但沒有人會這么做，只是驗證一切皆對象
12 test.y=1
13 print(test.__dict__)
執(zhí)行結(jié)果：
1 {'x': 1, 'y': 1}
示例4：直接傳值并加到字典中
1 def Typed(**kwargs): #負責接收參數(shù)
2 def deco(obj): #局部作用域
3 obj.x=1
4 obj.y=2
5 obj.z=3
6 returnobj7 print('====>',kwargs) #外層傳了個字典進來，就是： 'y': 2, 'x': 1,
8 returndeco9
10 @Typed(x=1,y=2,z=3) #typed(x=1,y=2,z=3)--->deco 函數(shù)名加()就是運行Typed函數(shù)
11 classFoo:12 pass
執(zhí)行結(jié)果:
1 ====> {'y': 2, 'x': 1, 'z': 3}
示例5：類的裝飾器增強版
1 def Typed(**kwargs): #Type傳過來的參數(shù)，就是name='egon',kwargs包含的就是一個字典2 defdeco(obj):3 for key,val inkwargs.items(): #key=name,val=age4 setattr(obj,key,val) #obj=類名，key=name,val=age5 returnobj #返回類本身:obj,就相當于給類加了個屬性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
實現(xiàn)：類型檢測控制傳入的值是什么類型
1、用raise拋出異常的方式實現(xiàn)
2、用類加裝飾器實現(xiàn) (這種方法更高級)
示例6：類加裝飾器的應(yīng)用
示例如下：
1、給類加裝飾器，實現(xiàn)控制傳入的類型(推薦寫法) ?可以參考: ?示例:4：用raise拋出異常的方式，判斷傳入的值是什么類型，同時可以判斷多個屬性。
1 #給類加裝飾器，實現(xiàn)控制傳入的類型
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 傳入的類型不是%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è)置類屬性
27 returnobj28 returnwrapper29
30 #給類加裝飾器，加了裝飾器，指定了什么類型，就必須傳入什么類型的值，否則就會報錯
31 @deco(name=str,age=int,salary=float) #@wrapper ===>People=wrapper(People) #實現(xià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#傳入的是正確的類型，所以不會報錯。
41 p1 = People('alex', 13, 13.3)42 print(People.__dict__)43
44 #age設(shè)置成了int型，我們傳入的是字符串類型，所以會報錯：TypeError: age 傳入的類型不是
45 #p1=People('alex','13',13.3)
46 #print(People.__dict__)
執(zhí)行結(jié)果：
1 #傳入正確類型的值
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 #傳入錯誤類型的值，會報錯，并提示你傳入值的類型。
示例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：利用描述符實現(xiàn)延遲計算
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
二十、元類(metaclass)
1、示例：
1 classFoo:2 pass
3
4 f1=Foo() #f1是通過Foo類實例化的對象
python中一切皆是對象，類本身也是一個對象，當使用關(guān)鍵字class的時候，python解釋器在加載class的時候就會創(chuàng)建一個對象(這里的對象指的是類而非類的實例)
上例可以看出f1是由Foo這個類產(chǎn)生的對象，而Foo本身也是對象，那它又是由哪個類產(chǎn)生的呢？
1 classFoo:2 pass
3
4 f1=Foo()5
6 print(type(f1)) #
7 print(type(Foo)) #類的類就是
8
9 classBar:10 pass
11 print(type(Bar)) #
執(zhí)行結(jié)果：
1 #type函數(shù)可以查看類型，也可以用來查看對象的類，二者是一樣的。
2
3
4
2、什么是元類？
元類是類的類，是類的模板
元類是用來控制如何創(chuàng)建類的，正如類是創(chuàng)建對象的模板一樣
元類的實例為類，正如類的實例為對象(f1對象是Foo類的一個實例，Foo類是 type 類的一個實例)
type是python的一個內(nèi)建元類，用來直接控制生成類，python中任何class定義的類其實都是type類實例化的對象
3、創(chuàng)建類的兩種方式
方式一：
1 classFoo:2 pass
3 print(Foo)4 print(Foo.__dict__)
執(zhí)行結(jié)果：
1
2 {'__module__': '__main__', '__doc__': None, '__dict__': , '__weakref__': }
方式二：
1 #type就是類的類，用type()實例化的結(jié)果，就是產(chǎn)生一個類
2 #用type和class生成的類是一樣的效果。
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)的是類屬性
17 print(f1.name) #調(diào)name
18 f1.test() #調(diào)方法
執(zhí)行結(jié)果：
1
2 1
3 alex4 =======執(zhí)行的是test=====>
4、一個類沒有聲明自己的元類，默認他的元類就是type，除了使用元類type，用戶也可以通過繼承type來自定義元類。
示例:??自定制元類
1 classMyType(type):2 def __init__(self,a,b,c):3 print('元類的構(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 元類的構(gòu)造函數(shù)執(zhí)行
總結(jié)
以上是生活随笔為你收集整理的python对象属性在引用时前面需要加()_python基础-面向对象进阶的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： mysql合并多条纪录字段_Mysql应
- 下一篇： html表白照片墙,【原创】【申精】用p