淺談Python中的反射

反射

reflection，指運行時獲取類型定義的信息。

一個對象能夠在運行時，如同照鏡子一樣，反射出其類型信息。簡單而言，在Python中，能夠通過一個對象，找出其type、class、attribute或者method的能力，稱爲反射或者自省。

Python的反射能力，主要體現在對象的屬性上。

---

請看以下例子： 有一個Point類，並提供了一個方法去查看實例屬性。

class Point:
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def __str__(self):
        return "Point({},{})".format(self.x,self.y)

    def show(self):
        print(self.x,self.y)

p = Point(3,8)
p.show() # 3 8
print(p.__dict__) # {'x': 3, 'y': 8}

# 直接修改屬性,並添加屬性
p.__dict__['y'] = 10
p.z = 100
print(p.__dict__) # {'x': 3, 'y': 10, 'z': 100}

上述的例子，是對象在運行時獲取了它的屬性，並且修改屬性和添加了屬性。本質上，這利用了Python的反射的能力。

但是，上例的訪問方式並不優雅，Python提供了內置的函數。

反射相關的內建函數

內建函數	意義
getattr(object,name[,default])	通過name返回object的屬性值。當屬性不存在時，將使用default返回。如果沒有default，則拋出AttributeError。name必須爲字符串。
setattr(object,name,value)	object的屬性存在，則覆蓋。不存在，則新增。
hasattr(object,name)	判斷對象是否有此名字的屬性，name必須爲字符串。

於是，上例的訪問變成了這樣：

class Point:
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def __str__(self):
        return "Point({},{})".format(self.x,self.y)

    def show(self):
        print(self.x,self.y)

p1 = Point(3,8)
p2 = Point(4,9)

print(getattr(p1,'x')) # 3
print(getattr(p2,'y')) # 9
print(getattr(p1,'__dict__')) # {'x': 3, 'y': 8}

這裏，我們可以理解爲，通過訪問字符串的方式，訪問到了字符串的變量值(而一般情況下，訪問字符串，就返回字符串本身)。

這就是反射最明顯的特徵。

# 接上例
if hasattr(p1,'show'):
    getattr(p1,'show')() # 3 8

有時，我們並不清楚一個對象是否支持show方法，此時可以利用反射，在對象運行期間反射出其是否具有show方法，如果有則調用之。

有時，我們並非代碼的開發者，而是使用者。此時我們如果想了解某個對象的屬性，就需要用如鏡子一樣的能力把對象的能力反射出來。

這就是反射的含義。

當然，如果某個類的屬性不存在，我們能動態添加之。

# 接上例
if not hasattr(Point,'add'):
    setattr(Point,'add',lambda self,other:Point(self.x + other.x,self.y + other.y))

p3 = Point(1,2)
p4 = Point(3,4)
print(p3.add(p4)) # Point(4,6)

也就是說，反射時看到的屬性，你也能修改之或者添加之！

這種動態增刪屬性的方式是運行時改變類或者改變實例的方式。但是裝飾器或者Mixin都是定義時就決定了，因此反射能力具有更大的靈活性。

例子：利用反射，實現命令分發器

class Dispatcher():
    def __init__(self):
        self._run()

    def cmd1(self):
        print('I am cmd1')

    def cmd2(self):
        print('I am cmd2')

    def _run(self):
        while True:
            cmd = input('input CMD:')
            if cmd == 'quit':
                break
            ret = getattr(self,cmd,lambda :print('unknow command {}'.format(cmd)))
            ret()


Dispatcher()

反射相關的魔術方法

__getattr__

我們已經知道，可以通過getattr(object,name[,default]) 這種方式去獲取一個對象的屬性。如果該對象的屬性沒有定義，則會拋出異常。

是否有一種方法，當屬性不存在時，可以避免異常的發生？

先看一個例子：

class Base:
    n = 0

class Point(Base):
    z = 6

    def __init__(self,x,y):
        self.x = x
        self.y = y

    def show(self):
        print(self.x,self.y)

    def __getattr__(self,item):
        return 'missing {}'.format(item)

p1 = Point(4,5)
print(p1.x) # 4
print(p1.z) # 6
print(p1.n) # 0
print(p1.t) # missing t

一個對象屬性會按照繼承關係往上尋找，如果找不到，則執行__getattr__方法。如果此方法無定義，則拋出AttributeError異常表示找不到屬性。

總結：

instance.__dict__ --> 
instance.__class__.__dict__ --> 
繼承的祖先類(直到object).__dict__ --> 
找不到 --> 
調用__getattr__

__setattr__

先看一個例子：

class Base:
    n = 0


class Point(Base):
    z = 6

    def __init__(self,x,y):
        self.x = x
        self.y = y

    def show(self):
        print(self.x,self.y)

    def __getattr__(self,item):
        return 'missing {}'.format(item)

    def __setattr__(self,key,value):
        print("setattr {}={}".format(key,value))


p1 = Point(4,5)
print(p1.x)
# 輸出：
# setattr x=4
# setattr y=5
# missing x 

爲什麼輸出這樣的信息？

當實例通過.點號設置屬性時，比如self.x = 4，就會調用__setattr__函數。此時阻止了屬性x添加到實例字典的流程，相當於x並沒有添加到實例字典中。因此，當訪問x屬性時，就會提示missing x。

如果需要添加到實例字典中，則需要顯式完成：

def __setattr__(self,key,value):
	print("setattr {}={}".format(key,value))
	self.__dict__[key] = value

此方法，可以攔截對實例屬性的增加、修改操作。如果要設置屬性字典生效，則需要自己手動操作實例的屬性字典。

理解下面的訪問方式：

print(p1.z) # 6
print(p1.n) # 0
print(p1.t) # missing t
p1.x = 50 # setattr x=50，調用了__setattr__
print(p1.__dict__) # {}  因爲阻止了實例字典的添加
p1.__dict__['x'] = 60  # 顯式添加
print(p1.__dict__) # {'x': 60}
print(p1.x) # 60

__delattr__

上面講述了添加，修改對象屬性時，具體發生了什麼事情。那刪除屬性時，又會發生什麼事情呢？

class Point:
    Z = 5
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def __delattr__(self,item):
        print('Can not del {}'.format(item))


p = Point(14,5)
del p.x #  Can not del x 

p.z = 15
del p.z # Can not del z
print(p.__dict__) # {'x': 14, 'y': 5, 'z': 15}

del Point.Z # 無輸出，已經刪除了z屬性了嗎？
print(Point.__dict__) # 類屬性字典 已經刪除Point的z屬性
print(p.__dict__) # {'x': 14, 'y': 5, 'z': 15} 實例屬性字典依然保留z屬性

__delattr__魔術方法可以阻止通過實例刪除屬性的操作，但是依然可通過類刪除類屬性。

---

__getattribute__

class Base:
    n = 0


class Point(Base):
    z = 6

    def __init__(self,x,y):
        self.x = x
        self.y = y

    def show(self):
        print(self.x,self.y)

    def __getattr__(self,item):
        return 'missing {}'.format(item)

    def __getattribute__(self, item):
        return item

p1 = Point(4,5)
print(p1.__dict__)  # 竟然輸出了__dict__？實例的屬性字典哪兒去了？
print(p1.x) # x  訪問x屬性，竟然返回了x字符串?
print(p1.z) # z
print(p1.n) # n
print(p1.t) # t
print(Point.z) # 6，能輸出類的屬性字典的值

對實例的所有屬性訪問，第一個都會調用此方法。

它阻止了屬性的查找，該方法應該返回(計算後的)值或者拋出一個AttributeError異常。

它的return值可作爲屬性查找的結果，如果拋出AttributeError異常，則會直接調用__getattr__方法，因爲屬性沒有找到。

class Base:
    n = 0


class Point(Base):
    z = 6

    def __init__(self,x,y):
        self.x = x
        self.y = y

    def show(self):
        print(self.x,self.y)

    def __getattr__(self,item):
        return 'missing {}'.format(item)

    def __getattribute__(self, item):
        return object.__getattribute__(self,item) ## object爲基類


p1 = Point(4,5)
print(p1.__dict__) # {'x': 4, 'y': 5} 此時終於表現得符合預期了
print(p1.x) # 4
print(p1.z) # 6
print(p1.n) # 0
print(p1.t) # missing t
print(Point.z) # 6

__getattribute__方法中爲了避免在該方法中無限遞歸，它的實現應該永遠調用基類的同名方法以訪問需要的任何屬性。

注意：除非你明確知道此方法的後果，否則不要使用它。

此時，可以總結訪問一個對象的屬性時，其查找順序：

實例調用__getattribute__ --> 
instance.__dict__ --> 
instance.__class__.__dict__ --> 
繼承的祖先類(直到object).__dict__ --> 
找不到 --> 
調用__getattr__