4 總結(jié)

運(yùn)算符重載的應(yīng)用場(chǎng)景
往往是面向?qū)ο髮?shí)現(xiàn)的類，需要做大量的運(yùn)算，而運(yùn)算符是這種運(yùn)算在數(shù)學(xué)上最常見(jiàn)的表達(dá)方式，int 類中，幾乎實(shí)現(xiàn)了所有操作符，可以作為參考

7 容器相關(guān)方法

1 簡(jiǎn)介

2 實(shí)例

#!/usr/local/bin/python3.6
#coding:utf-8
class  Item:
    def __init__(self,name,*args):
        self.name=name
        self.lst=list(args)
    def  __len__(self):
        return len(self.lst)
    def __iter__(self):
        return iter(self.lst)  # 此處返回是一個(gè)迭代器,必須是一個(gè)迭代器
    def __add__(self, other):  # 此處使用+ 號(hào)返回一個(gè)列表
        self.lst.append(other)
        return self
    def __getitem__(self, index):  # 此處應(yīng)用于列表時(shí)，表示為索引，此處應(yīng)用于字典時(shí)，表示key
        if  index   > len(self.lst):
            print ('Key Error')
        else:
            return self.lst[index]
    def __setitem__(self, index, value): # 此處表示修改屬性列表中的值
        if  index   > len(self.lst):
            print ('Key Error')
        else:
            self.lst[index]=value
            return   self
    # def __missing__(self, key): # 此方法只能適用于字典的處理
    #     pass
    def  __repr__(self):
        return str(self.lst)  # 此處對(duì)其進(jìn)行可視化處理
a=Item('MySQL',12,3,45,678,8909)
print (len(a))
# 此處調(diào)用了__iter__方法
for i  in a:
    print (i)
print ('++++++++++++++++')
print (a[2])  # 此處調(diào)用了__getitem__方法，用于獲取值
a+10  # 此處使用__add__方法進(jìn)行加入，此處追加到列表的末尾
print (a[-1])  # 獲取列表的最后一個(gè)元素，則得到此值
a[1]=20  # 使用__setitem__方法修改屬性
print (a[1])  #返回對(duì)應(yīng)位置的值
a+10+20+30+40  # 此處進(jìn)行連加操作，因?yàn)槠鋋dd方法返回是self,因此每次賦值后都會(huì)增加
print (a)

結(jié)果如下

8 可調(diào)用對(duì)象

1 簡(jiǎn)介

在python中一切皆對(duì)象，函數(shù)也不例外
可調(diào)用對(duì)象
方法
__call__類中出現(xiàn)該方法，實(shí)例就可以像函數(shù)一樣調(diào)用，
可調(diào)用對(duì)象： 定義一個(gè)類，并實(shí)例化得到其實(shí)例，將實(shí)例像函數(shù)一樣調(diào)用。調(diào)用是實(shí)例的，不是類的。

2 實(shí)例

#!/usr/local/bin/python3.6
#coding:utf-8
def  foo():
    print (foo.__module__,foo.__name__)

foo.__call__()# 此處的方法和下面的相同，皆是調(diào)用該函數(shù)
foo()
print (dir(foo))

結(jié)果如下

函數(shù)的可調(diào)用原因是函數(shù)實(shí)現(xiàn)了\call()方法

#!/usr/local/bin/python3.6
#coding:utf-8
def  foo():
    print (foo.__module__,foo.__name__)

print (foo.__call__) # 此處返回一個(gè)函數(shù)對(duì)象是一個(gè)wrapper
foo.__call__()# 此處的方法和下面的相同，皆是調(diào)用該函數(shù)
foo()

結(jié)果如下

#!/usr/local/bin/python3.6
#coding:utf-8
class  A:
    def __init__(self):
        self.x=1
    def __call__(self, *args):  # 此處的第一個(gè)是self，表明其是給實(shí)例使用的，并不是給類使用的
        return   args  # 此處返回一個(gè)元組

print (A()(12344))  # 此處第一個(gè)括號(hào)是實(shí)例化，第二個(gè)是傳遞參數(shù)并調(diào)用實(shí)例

3 練習(xí)

利用封裝完成斐波那契額數(shù)列

方法1

#!/usr/local/bin/python3.6
#coding:utf-8
class  A:
    def  __call__(self,num):
        a,b=0,1
        for  i in  range(num):
            print (b)
            a,b=b,a+b
A()(10)

結(jié)果如下

方法2

#!/usr/local/bin/python3.6
#coding:utf-8
class  A:
    def __init__(self):
        self.lst=[1,1,2]
    def  __call__(self,num):
        if  num < 3:
            return   self.lst[:num]
        else:
            for  i in range(num-3):
                self.lst.append(self.lst[-1]+self.lst[-2])
            return  self.lst
print (A()(10))

結(jié)果如下

添加功能如下

#!/usr/bin/poython3.6
#conding:utf-8
class  A:
    def __init__(self):
        self.lst=[1,1,2]
    def  __len__(self):
        return len(self.lst)
    def  __call__(self,x):
        if  len(self.lst)  >  x:
            return  self.lst[:x]
        for  i  in   range(2,x):
            self.lst.append(self.lst[i]+self.lst[i-1])
        return  self.lst
    def __getitem__(self, item):
        if item < 0:
            return  None
        if  len(self) > item:
            return self.lst[item]
    def __iter__(self):
        return  iter(self.lst)

a=A()
print (a(10))
print (a[4])
for x in a:
    print (x)

結(jié)果如下

9 上下文管理

1 推導(dǎo)過(guò)程

文件IO操作可以對(duì)文件對(duì)象進(jìn)行上下文管理，使用with...as語(yǔ)法
推導(dǎo)過(guò)程

#!/usr/bin/poython3.6
#conding:utf-8
# 此處為默認(rèn)的上下文管理
# with   open('test')  as f:
#     pass

class A:
    pass

with  A()  as  f:
    pass

結(jié)果如下

提示需要添加 __enter__屬性
添加如下

#!/usr/bin/poython3.6
#conding:utf-8
# 此處為默認(rèn)的上下文管理
# with   open('test')  as f:
#     pass

class A:
    def  __enter__(self):
        pass

with  A()  as  f:
    pass

結(jié)果如下

提示需要添加 __exit__屬性

#!/usr/bin/poython3.6
#conding:utf-8
# 此處為默認(rèn)的上下文管理
# with   open('test')  as f:
#     pass

class A:
    def  __enter__(self):
        pass
    def  __exit__(self, exc_type, exc_val, exc_tb):
        pass
with  A()  as  f:
    pass

結(jié)果如下

#!/usr/bin/poython3.6
#conding:utf-8
class A:
    def  __enter__(self):
        print ('__enter__')
    def  __exit__(self, exc_type, exc_val, exc_tb):
        print ('__exit__')
with  A()  as  f:
    pass

由此圖可知，其調(diào)用順序是先調(diào)用_enter_，后調(diào)用_exit_

2 屬性

exit 中變量的含義：
1 exc_type： 異常類型，如果沒(méi)有異常，則返回是None
2 exc_tb:異常追蹤信息，如果沒(méi)有異常，則是None
3 exc_va ：異常對(duì)應(yīng)的值，如果沒(méi)異常，則是None
此處的return 用于壓制異常，若此處是False,則會(huì)拋出異常，等效True 或 False

缺少了enter 進(jìn)不去，缺少了exitc出不來(lái)

#!/usr/bin/poython3.6
#conding:utf-8
class A:
    def  __init__(self):
        print ('init instance')
    def  __enter__(self):
        print ('__enter__')
        return 1
    def  __exit__(self, exc_type, exc_val, exc_tb):
        print ('__exit__')
p=A()
with  p  as  f:  # 此處的p是__enter__的返回值，是f的參數(shù)，若此處__enter__無(wú)return，則默認(rèn)返回為None，無(wú)意義
    print (p==f) # 此處用于比較p和f的關(guān)系 
    print (p is f)
    print (p)
    print (f)

上述結(jié)論如下：
實(shí)例化對(duì)象的時(shí)候，并不會(huì)調(diào)用enter，進(jìn)入with語(yǔ)句塊會(huì)調(diào)用__enter__方法，然后執(zhí)行語(yǔ)句體，最后離開(kāi)with語(yǔ)句塊的時(shí)候，調(diào)用__exit__方法

with 可以開(kāi)啟一個(gè)上下文運(yùn)行環(huán)境，在執(zhí)行前做一些準(zhǔn)備工作，執(zhí)行后做一些收尾工作。

3 上下文管理對(duì)異常的處理方式

#!/usr/bin/poython3.6
#conding:utf-8
class A:
    def  __init__(self):
        print ('init instance')
    def  __enter__(self):
        print ('__enter__')
        return 1
    def  __exit__(self, exc_type, exc_val, exc_tb):
        print ('__exit__')
p=A()
with  p  as  f:  # 此處的p是__enter__的返回值，是f的參數(shù)，若此處__enter__無(wú)return，則默認(rèn)返回為None，無(wú)意義
    raise Exception('Error')  # 此處拋出異常,一般的，拋出異常后，語(yǔ)句將不會(huì)再次執(zhí)行
    print (p==f) # 此處用于比較p和f的關(guān)系
    print (p is f)
    print (p)
    print (f)

結(jié)果如下

由此證明，當(dāng)異常拋出時(shí)，exit對(duì)應(yīng)的語(yǔ)句仍然會(huì)被執(zhí)行。

#!/usr/bin/poython3.6
#conding:utf-8
import  sys
class A:
    def  __init__(self):
        print ('init instance')
    def  __enter__(self):
        print ('__enter__')
        return 1
    def  __exit__(self, exc_type, exc_val, exc_tb):
        print ('__exit__')
p=A()
with  p  as  f:  # 此處的p是__enter__的返回值，是f的參數(shù)，若此處__enter__無(wú)return，則默認(rèn)返回為None，無(wú)意義
    sys.exit()  # 此處的是直接退出
    print (p==f) # 此處用于比較p和f的關(guān)系
    print (p is f)
    print (p)
    print (f)

結(jié)果如下

上述證明，此處滿足上述清理工作，上下文管理非常安全，能夠保證變量的順利清除工作。

#!/usr/bin/poython3.6
#conding:utf-8
import  sys
class A:
    def  __init__(self):
        print ('init instance')
    def  __enter__(self):
        print ('__enter__')
        return self
    def  __exit__(self, exc_type, exc_val, exc_tb):
        print ('__exit__')
        print (exc_tb) #追蹤信息
        print (exc_type)  # 類型
        print (exc_val)  # 值
        return  1  # 此處設(shè)置為1 是壓制異常，不讓其出現(xiàn)
p=A()
with  p  as  f:  # 此處的p是__enter__的返回值，是f的參數(shù)，若此處__enter__無(wú)return，則默認(rèn)返回為None，無(wú)意義
    raise   Exception('Error1234454')
    print (p==f) # 此處用于比較p和f的關(guān)系
    print (p is f)
    print (p)
    print (f)

結(jié)果如下

4 通過(guò)此方法進(jìn)行函數(shù)執(zhí)行時(shí)長(zhǎng)計(jì)算

之前的計(jì)算時(shí)長(zhǎng)方式

#!/usr/bin/poython3.6
#conding:utf-8
import  datetime
import  time
import  sys
def  wapper(fn):
    def _wapper(*args,**kwargs):
        start_time=datetime.datetime.now()
        ret  =  fn(*args,**kwargs)
        delta=(datetime.datetime.now()-start_time).total_seconds()
        print ("{} 函數(shù)的執(zhí)行時(shí)間為: {}".format(fn.__name__,delta))
        return  ret
    return  _wapper
@wapper
def  add(x,y):
    time.sleep(2)
    return  x+y

add(4,5)

結(jié)果如下

使用上下文管理的方式統(tǒng)計(jì)函數(shù)執(zhí)行時(shí)間

#!/usr/bin/poython3.6
#conding:utf-8
import  datetime
import  time
class Timer:
    def  __init__(self,fn):
        self.fn=fn
    def  __enter__(self):
        self.start_time=datetime.datetime.now()
        return  self.fn  # 此處對(duì)應(yīng)的是as前面的值
    def __exit__(self, exc_type, exc_val, exc_tb):
        delat=(datetime.datetime.now()-self.start_time).total_seconds()
        print ("函數(shù){} 的執(zhí)行時(shí)間為: {}".format(self.fn.__name__,delat))
        return  1
def  add(x,y):
    return  x+y
p=Timer(add)
with   p  as f:  # 此處調(diào)用的是__enter__的返回值，重命名為f
    time.sleep(2)
    print (f(4,5))

結(jié)果如下

5 類裝飾器的應(yīng)用

#!/usr/bin/poython3.6
#conding:utf-8
import  datetime
import time
from functools import  wraps
class A:
    def __init__(self,fn):
        self.fn=fn
    def __call__(self,*args,**kwargs):  #實(shí)例調(diào)用支持的方法
        self.start_time=datetime.datetime.now()
        ret = self.fn(*args,**kwargs)
        delta=(datetime.datetime.now()-self.start_time).total_seconds()
        print ("{} 函數(shù)的執(zhí)行時(shí)間為: {}".format(self.fn.__name__,delta))
        return  ret
@A   #add=A(add)
def add(x,y):
    time.sleep(2)
    return  x+y
print  (add(10,20))

結(jié)果如下

6 進(jìn)行屬性覆蓋如下

#!/usr/bin/poython3.6
#conding:utf-8
import  datetime
import time
from functools import  wraps
class A:
    def __init__(self,fn):
        self.fn=fn
    def __call__(self,*args,**kwargs):  #實(shí)例調(diào)用支持的方法
        self.start_time=datetime.datetime.now()
        ret = self.fn(*args,**kwargs)
        delta=(datetime.datetime.now()-self.start_time).total_seconds()
        print ("{} 函數(shù)的執(zhí)行時(shí)間為: {}".format(self.fn.__name__,delta))
        return  ret
@A   #add=A(add)
def add(x,y):
    '''this is function'''
    time.sleep(2)
    return  x+y
print  (add(10,20))
print  (add.__doc__) # 此處打印出文檔

結(jié)果如下

#!/usr/bin/poython3.6
#conding:utf-8
import  datetime
import time
from functools import  wraps
class A:
    def __init__(self,fn):
        self.__doc__=fn.__doc__  # 此處只能進(jìn)行部分的屬性覆蓋操作
        self.__name__=fn.__name__
        self.fn=fn
    def __call__(self,*args,**kwargs):  #實(shí)例調(diào)用支持的方法
        self.start_time=datetime.datetime.now()
        ret = self.fn(*args,**kwargs)
        delta=(datetime.datetime.now()-self.start_time).total_seconds()
        print ("{} 函數(shù)的執(zhí)行時(shí)間為: {}".format(self.fn.__name__,delta))
        return  ret
@A   #add=A(add)
def add(x,y):
    '''this is function'''
    time.sleep(2)
    return  x+y
print  (add(10,20))
print  (add.__doc__) # 此處打印出文檔

結(jié)果如下

#!/usr/bin/poython3.6
#conding:utf-8
import  datetime
import time
from functools import  wraps
class A:
    def __init__(self,fn):
        wraps(fn)(self)  # 調(diào)用此方法完成屬性的覆蓋操作，此處第一個(gè)是原函數(shù)，后面是現(xiàn)在的函數(shù)
        self.fn=fn
    def __call__(self,*args,**kwargs):  #實(shí)例調(diào)用支持的方法
        self.start_time=datetime.datetime.now()
        ret = self.fn(*args,**kwargs)
        delta=(datetime.datetime.now()-self.start_time).total_seconds()
        print ("{} 函數(shù)的執(zhí)行時(shí)間為: {}".format(self.fn.__name__,delta))
        return  ret
@A   #add=A(add)
def add(x,y):
    '''this is function'''
    time.sleep(2)
    return  x+y
print  (add(10,20))
print  (add.__doc__) # 此處打印出文檔

結(jié)果如下

7 contextlib.contextmanager

是一個(gè)裝飾器實(shí)現(xiàn)上下文管理，裝飾一個(gè)函數(shù)，而不像類一樣可以實(shí)現(xiàn)__enter__和__exit__方法

對(duì)下面的函數(shù)有要求，必須有yield，也就是這個(gè)函數(shù)必須返回一個(gè)和生成器，且只有一個(gè)yield的值。

#!/usr/bin/poython3.6
#conding:utf-8
import   contextlib
@contextlib.contextmanager
def foo():
    print ('enter')
    yield
    print ('exit')

with  foo() as f:
    pass

結(jié)果如下

#!/usr/bin/poython3.6
#conding:utf-8
import   contextlib
@contextlib.contextmanager
def foo():
    print ('enter')
    yield  [1,2,34,56,5867,856,867,]  # 此處相當(dāng)分界線，用于分割上面和下面的執(zhí)行
    print ('exit')

with  foo() as f:
    print (f)

#!/usr/bin/poython3.6
#conding:utf-8
import   contextlib
@contextlib.contextmanager
def foo():
    print ('enter')
    yield  [1,2,34,56,5867,856,867,]  # 此處相當(dāng)分界線，用于分割上面和下面的執(zhí)行
    print ('12344exit')

with  foo() as f:
    try:
        raise Exception
    finally:
        print ('exit')
    print (f)

結(jié)果如下

修改異常捕獲如下

#!/usr/bin/poython3.6
#conding:utf-8
import   contextlib
@contextlib.contextmanager
def foo():
    print ('enter')
    try:
        yield  [1,2,34,56,5867,856,867,]  # 此處相當(dāng)分界線，用于分割上面和下面的執(zhí)行
    finally:  # 放置在此處能夠執(zhí)行后面的相關(guān)操作
        print ('12344exit')

with  foo() as f:
    raise  Exception
    print (f)

結(jié)果如下

總結(jié)： 如果業(yè)務(wù)邏輯簡(jiǎn)單可以使用函數(shù)加裝飾器的方式，如果業(yè)務(wù)復(fù)雜，用類的方式加__enter__和__exit__更方便

8 上下文的應(yīng)用場(chǎng)景

1 增強(qiáng)功能
在代碼執(zhí)行的前后增加代碼，以增強(qiáng)其功能，類似裝飾器的功能

2 資源管理
打開(kāi)了資源需要關(guān)閉，例如文件對(duì)象，網(wǎng)絡(luò)鏈接，數(shù)據(jù)庫(kù)鏈接等

3 權(quán)限驗(yàn)證

在執(zhí)行代碼之前，做權(quán)限的驗(yàn)證，在enter中處理
在代碼進(jìn)入的時(shí)候進(jìn)行處理，在權(quán)限出去則不管

10 反射

1 概述

運(yùn)行時(shí)：區(qū)別于編譯時(shí)，指的是程序被加載到內(nèi)存中執(zhí)行的時(shí)候。

反射：python中，能夠通過(guò)一個(gè)對(duì)象，找出其type,class,attribute或method的能力，成為反射或自醒。

具有反射能力的函數(shù)type(),isinstance(),callable()(查看對(duì)象能否被調(diào)用),dir(),getattr()

2 內(nèi)建函數(shù)

object 可以是類或?qū)嵗?
語(yǔ)法格式:
getattr(object,name[,default]) : 通過(guò)name 返回object的屬性值，當(dāng)屬性不存在時(shí)，將使用default返回，如果沒(méi)有default，則拋出attributeError，name 必須位字符串 

setattr(object,name,value) object 的屬性存在，則覆蓋，若不存在，則新增。

hasattr(object,name)  判斷對(duì)象是否有這個(gè)名字屬性，name必須時(shí)字符串

3 實(shí)例

#!/usr/bin/poython3.6
#conding:utf-8
class  A:
    x=10
    def __init__(self):
        self.x=5

setattr(A,'y',20)  # 動(dòng)態(tài)添加類屬性位y=20
print (A.__dict__)  # 打印屬性信息列表
a=A()
setattr(a,'z',100)  # 實(shí)例動(dòng)態(tài)增加屬性
print (getattr(A,'y')) # 查看增加的屬性是否存在
print (getattr(A,'x'))  # 定義屬性是否存在
print (getattr(a,'y'))  # 查看實(shí)例中是否存在該屬性
print (a.__dict__) # 查看實(shí)例屬性信息中是否具有'z'屬性
print (A.__dict__)  # 打印屬性信息列表，此處查看當(dāng)實(shí)例屬性信息增加后，類屬性信息是否增加

if hasattr(a,'z'):
    print ("{} 函數(shù)存在此屬性 {}".format('a','y'))

結(jié)果如下

進(jìn)階

#!/usr/bin/poython3.6
#conding:utf-8
class  A:
    x=10
    def __init__(self,y):
        self.x=5
        self.y=y
a=A(20)
setattr(A,'printf',lambda  self: 1 ) #此處增加一個(gè)類的屬性，并通過(guò)參數(shù)調(diào)用

setattr(a,'myclass',lambda  : 10 ) # 此處增加一個(gè)實(shí)例屬性
print (a.printf())  # 打印此類的屬性結(jié)果如下
print (getattr(a,'printf')())  # 因?yàn)榇颂幨呛瘮?shù)，因此需要通過(guò)()來(lái)進(jìn)行調(diào)用
print (getattr(a,'myclass')())
if not  hasattr(A,'sub'):  # 此處添加一個(gè)類的函數(shù)屬性，實(shí)現(xiàn)函數(shù)之前的差運(yùn)算
    setattr(A,'sub',lambda self,other : A(self.y- other.y) )
if not  hasattr(A,'add'): # 此處添加一個(gè)類的屬性，實(shí)現(xiàn)函數(shù)之間的和的計(jì)算
    setattr(A,'add',lambda self,other: (self.y + other.y))
print (a.__dict__)
print (A.__dict__)
b1=A(10)
b2=A(20)
print (b2.sub(b1))
print (b1.add(b2))

結(jié)果如下

注意：
這種動(dòng)態(tài)增加屬性的方式是運(yùn)行時(shí)改變類或者實(shí)例的方式，比裝飾器和Mixin更加靈活，其具有更大的使用用途

4 實(shí)例應(yīng)用

實(shí)現(xiàn)分發(fā)器
簡(jiǎn)單雛形

#!/usr/bin/poython3.6
#conding:utf-8
class  Dispatcher:
    def cmd1(self):  # 此處在內(nèi)部定義一個(gè)方法
        print ('cmd10')
    def run(self):  # 此處用于執(zhí)行
        while True:
            cmd=input("plase  input str:")  #退出程序命令
            if  cmd.strip() == 'q'  or  cmd.strip() == 'quit':
                return
            getattr(self,cmd.strip(),self.__defaltfun)()  # 此處用于獲取該方法，若不存在，則執(zhí)行默認(rèn)程序
    def __defaltfun(self):
        print ('default')
a=Dispatcher()
a.run()

結(jié)果如下

#!/usr/bin/poython3.6
#conding:utf-8
class  Dispatcher:
    def cmd1(self):  # 此處在內(nèi)部定義一個(gè)方法
        print ('cmd10')
    def  reg(self,cmd,fn):
        if isinstance(cmd,str):
            setattr(self.__class__,cmd.strip(),fn)  # 此處使用的是類，若是實(shí)例化，則需要進(jìn)行下面將self傳入進(jìn)去的方式進(jìn)行調(diào)用
        else:
            print ('TypeError')
    def run(self):
        while True:
            cmd = input("plase  input str:")
            if  cmd.strip()  == 'q'  or  cmd.strip() == 'quit':
                return
            getattr(self,cmd.strip(),self.defaultfun)()
    def defaultfun(self):
        print ('default')

a=Dispatcher()
a.reg('cmd2',lambda  self :print (2)) 
a.reg('cmd3',lambda  self :print (3))
a.run()

結(jié)果如下

5 反射相關(guān)魔術(shù)方法

實(shí)例如下：

#!/usr/bin/poython3.6
#conding:utf-8

class  Base:
    a=5

class A(Base):
    m=6
    def __init__(self,x):
        print ('init')
        self.x=x  #此處定義了屬性，所以下面的__setattr__被執(zhí)行了一次，初始化先執(zhí)行，之后__setattr__這個(gè)屬性再執(zhí)行一次
    def __getattr__(self, item):#針對(duì)上述無(wú)法查找到的屬性，則執(zhí)行此屬性，可配置其值為None來(lái)彌補(bǔ)此屬性值
        print ('__getattr__',item)
        self.__dict__[item]=None
    def __setattr__(self, key, value): #設(shè)置一個(gè)屬性時(shí)，一定要執(zhí)行，至于是否生效，則另當(dāng)別論
        print ('__setattr__',key,value)
    def __delattr__(self, item): #此處在刪除一個(gè)實(shí)例的屬性進(jìn)行的操作，只要實(shí)例能找到，都能夠刪除
        print ('__delattr__',item)
A.n=50 # 此處是正常的添加類屬性，不會(huì)產(chǎn)生其他的報(bào)錯(cuò)
a=A(20)
print (a.__dict__)
a.b  # 針對(duì)不存在的屬性進(jìn)行調(diào)用
a.x=30 # 設(shè)置實(shí)例的屬性變化
a.c=200 #添加一個(gè)不存在的屬性
del  a.a # 刪除一個(gè)實(shí)例的屬性
print (a.__dict__)

結(jié)果如下

#!/usr/bin/poython3.6
#conding:utf-8

class  Base:
    a=5

class A(Base):
    m=6
    def __init__(self,x):
        print ('init')
        self.x=x  #此處定義了屬性，所以下面的__setattr__被執(zhí)行了一次，初始化先執(zhí)行，之后__setattr__這個(gè)屬性再執(zhí)行一次
    def __getattr__(self, item):#針對(duì)上述無(wú)法查找到的屬性，則執(zhí)行此屬性，可配置其值為None來(lái)彌補(bǔ)此屬性值
        print ('__getattr__',item)
        self.__dict__[item]=None
    def __setattr__(self, key, value): #設(shè)置一個(gè)屬性時(shí)，一定要執(zhí)行，至于是否生效，則另當(dāng)別論
        print ('__setattr__',key,value)
    def __delattr__(self, item): #此處在刪除一個(gè)實(shí)例的屬性進(jìn)行的操作，只要實(shí)例能找到，都能夠刪除
        print ('__delattr__',item)

    def __getattribute__(self, item):  #此處是在字典屬性之前進(jìn)行攔截執(zhí)行
        print ('__getattribute__',item)
a=A(20)

print (a.x)

結(jié)果如下

實(shí)例的所有屬性的訪問(wèn)，第一個(gè)都會(huì)調(diào)用__getattribute__方法，其阻止了屬性查找，該方法應(yīng)該返回(計(jì)算后)值或者拋出一個(gè)attributeError 異常
他的return 值將作為屬性查找的結(jié)果，如果拋出attributeError 異常，則會(huì)直接調(diào)用__getattr__方法，因?yàn)楸硎緦傩詻](méi)有找到

#!/usr/bin/poython3.6
#conding:utf-8

class  Base:
    a=5

class A(Base):
    m=6
    def __init__(self,x):
        print ('init')
        self.x=x  #此處定義了屬性，所以下面的__setattr__被執(zhí)行了一次，初始化先執(zhí)行，之后__setattr__這個(gè)屬性再執(zhí)行一次
    def __getattr__(self, item):#針對(duì)上述無(wú)法查找到的屬性，則執(zhí)行此屬性，可配置其值為None來(lái)彌補(bǔ)此屬性值
        print ('__getattr__',item)
        # self.__dict__[item]=None
    def __setattr__(self, key, value): #設(shè)置一個(gè)屬性時(shí)，一定要執(zhí)行，至于是否生效，則另當(dāng)別論
        print ('__setattr__',key,value)
    def __delattr__(self, item): #此處在刪除一個(gè)實(shí)例的屬性進(jìn)行的操作，只要實(shí)例能找到，都能夠刪除
        print ('__delattr__',item)

    def __getattribute__(self, item):  #此處是在字典屬性之前進(jìn)行攔截執(zhí)行
        print ('__getattribute__',item)
        raise  AttributeError(item)  # 此處若屬性不存在，拋出異常，則直接進(jìn)入getattr中機(jī)型處理
a=A(20)

print (a.x)

#!/usr/bin/poython3.6
#conding:utf-8

class  Base:
    a=5

class A(Base):
    m=6
    def __init__(self,x):
        print ('init')
        self.x=x  #此處定義了屬性，所以下面的__setattr__被執(zhí)行了一次，初始化先執(zhí)行，之后__setattr__這個(gè)屬性再執(zhí)行一次
    def __getattr__(self, item):#針對(duì)上述無(wú)法查找到的屬性，則執(zhí)行此屬性，可配置其值為None來(lái)彌補(bǔ)此屬性值
        print ('__getattr__',item)
        # self.__dict__[item]=None
    def __setattr__(self, key, value): #設(shè)置一個(gè)屬性時(shí)，一定要執(zhí)行，至于是否生效，則另當(dāng)別論
        print ('__setattr__',key,value)
    def __delattr__(self, item): #此處在刪除一個(gè)實(shí)例的屬性進(jìn)行的操作，只要實(shí)例能找到，都能夠刪除
        print ('__delattr__',item)

    def __getattribute__(self, item):  #此處是在字典屬性之前進(jìn)行攔截執(zhí)行
        print ('__getattribute__',item)
        # raise  AttributeError(item)  # 此處若屬性不存在，拋出異常，則直接進(jìn)入getattr中機(jī)型處理
        return object.__getattribute__(self,item)  #此處表示若不存在，則直接去object中進(jìn)行查找，并得到其訪問(wèn)的值
a=A(20)

print (a.b)

結(jié)果如下

注意：\getattribute\ 方法中為了避免在該方法中無(wú)限遞歸，實(shí)現(xiàn)了應(yīng)該永久調(diào)用基類的同名方法以訪問(wèn)需要的任何屬性，除非你明確知道\getattribute\方法用來(lái)做什么，否則不要使用它。

6 總結(jié)：

標(biāo)題名稱：python類之特殊屬性和魔術(shù)方法
網(wǎng)頁(yè)URL：http://weahome.cn/article/pojcih.html