#coding:utf-8
import sys

def foo():pass

class Cat(object):
    def __init__(self, name='Kitty'):
        self.name = name

    def sayHi(self):
        print self.name, 'says Hi!'

cat = Cat()

print Cat.sayHi
print cat.sayHi

有時候我們會碰到這樣的需求，需要執行物件的某個方法，或是需要對物件的某個欄位賦值，而方法名或是欄位名在編碼程式碼時並不能確定，需要通過引數傳遞字串的形式輸入。舉個具體的例子：當我們需要實現一個通用的DBM框架時，可能需要對資料物件的欄位賦值，但我們無法預知用到這個框架的資料物件都有些什麼欄位，換言之，我們在寫框架的時候需要通過某種機制訪問未知的屬性。

這個機制被稱為反射（反過來讓物件告訴我們他是什麼），或是自省（讓物件自己告訴我們他是什麼，好吧我承認括號裡是我瞎掰的- -#），用於實現在執行時獲取未知物件的資訊。反射是個很嚇唬人的名詞，聽起來高深莫測，在一般的程式語言裡反射相對其他概念來說稍顯複雜，一般來說都是作為高階主題來講；但在Python中反射非常簡單，用起來幾乎感覺不到與其他的程式碼有區別，使用反射獲取到的函式和方法可以像平常一樣加上括號直接呼叫，獲取到類後可以直接構造例項；不過獲取到的欄位不能直接賦值，因為拿到的其實是另一個指向同一個地方的引用，賦值只能改變當前的這個引用而已。

1. 訪問物件的屬性

以下列出了幾個內建方法，可以用來檢查或是訪問物件的屬性。這些方法可以用於任意物件而不僅僅是例子中的Cat例項物件；Python中一切都是物件。

#coding:utf-8
from a import *

cat = Cat('kitty')

print cat.name
cat.sayHi()    #呼叫例項方法

print dir(cat)

if hasattr(cat, 'name'): #檢查例項是否有這個屬性
    setattr(cat, 'name', 'tiger') #same as: a.name = 'tiger'
    print getattr(cat, '
 
name') #same as: print a.name

    
getattr(cat, 'sayHi')()

    dir([obj]):
    呼叫這個方法將返回包含obj大多數屬性名的列表（會有一些特殊的屬性不包含在內）。obj的預設值是當前的模組物件。
    hasattr(obj, attr): 
    這個方法用於檢查obj是否有一個名為attr的值的屬性，返回一個布林值。
    getattr(obj, attr): 
    呼叫這個方法將返回obj中名為attr值的屬性的值，例如如果attr為’bar’，則返回obj.bar。
    setattr(obj, attr, val):

2. 訪問物件的元資料

當你對一個你構造的物件使用dir()時，可能會發現列表中的很多屬性並不是你定義的。這些屬性一般儲存了物件的元資料，比如類的__name__屬性儲存了類名。大部分這些屬性都可以修改，不過改動它們意義並不是很大；修改其中某些屬性如function.func_code還可能導致很難發現的問題，所以改改name什麼的就好了，其他的屬性不要在不瞭解後果的情況下修改。

接下來列出特定物件的一些特殊屬性。另外，Python的文件中有提到部分屬性不一定會一直提供，下文中將以紅色的星號*標記，使用前你可以先開啟直譯器確認一下。

2.0. 準備工作：確定物件的型別

在types模組中定義了全部的Python內建型別，結合內建方法isinstance()就可以確定物件的具體型別了。

• isinstance(object, classinfo): 
  檢查object是不是classinfo中列舉出的型別，返回布林值。classinfo可以是一個具體的型別，也可以是多個型別的元組或列表。

types模組中僅僅定義了型別，而inspect模組中封裝了很多檢查型別的方法，比直接使用types模組更為輕鬆，所以這裡不給出關於types的更多介紹，如有需要可以直接檢視types模組的文件說明。本文第3節中介紹了inspect模組。

2.1. 模組(module)

• __doc__: 文件字串。如果模組沒有文件，這個值是None。
• *__name__: 始終是定義時的模組名；即使你使用import .. as 為它取了別名，或是賦值給了另一個變數名。
• *__dict__: 包含了模組裡可用的屬性名-屬性的字典；也就是可以使用模組名.屬性名訪問的物件。
• __file__: 包含了該模組的檔案路徑。需要注意的是內建的模組沒有這個屬性，訪問它會丟擲異常！

#coding:utf-8
import fnmatch as m

print m.__doc__.splitlines()[0]
print m.__name__
print m.__file__
print m.__dict__.items()[0]

__dict__ 返回屬性、方法物件名值的字典，而dir僅僅是個屬性、方法名的列表。

2.2. 類(class)

• __doc__: 文件字串。如果類沒有文件，這個值是None。
• *__name__: 始終是定義時的類名。
• *__dict__: 包含了類裡可用的屬性名-屬性的字典；也就是可以使用類名.屬性名訪問的物件。
• __module__: 包含該類的定義的模組名；需要注意，是字串形式的模組名而不是模組物件。
• *__bases__: 直接父類物件的元組；但不包含繼承樹更上層的其他類，比如父類的父類

#coding:utf-8
from a import *

print Cat.__doc__ #None Cat類沒有doc
print Cat.__name__ #Cat
print Cat.__module__ # a 如果在自身的module中執行時__main__
print Cat.__bases__ #(<type 'object'>,)
print Cat.__dict__ # 一個屬性、方法物件名值的字典

2.3. 例項(instance)

例項是指類例項化以後的物件。

• *__dict__: 包含了可用的屬性名-屬性物件字典。
• *__class__: 該例項的類物件。對於類Cat，cat.__class__ == Cat 為 True。

#coding:utf-8
from a import *

print cat.__dict__ #{'name': 'Kitty'} 僅僅有屬性，沒有方法
print cat.__class__ #<class 'a.Cat'>
print cat.__class__ == Cat #True

2.4. 內建函式和方法(built-in functions and methods)

根據定義，內建的(built-in)模組是指使用C寫的模組，可以通過sys模組的builtin_module_names欄位檢視都有哪些模組是內建的。這些模組中的函式和方法可以使用的屬性比較少，不過一般也不需要在程式碼中檢視它們的資訊。

• __doc__: 函式或方法的文件。
• __name__: 函式或方法定義時的名字。
• __self__: 僅方法可用，如果是繫結的(bound)，則指向呼叫該方法的類（如果是類方法）或例項（如果是例項方法），否則為None。
• *__module__: 函式或方法所在的模組名。

2.5. 函式(function)

這裡特指非內建的函式。注意，在類中使用def定義的是方法，方法與函式雖然有相似的行為，但它們是不同的概念。

• __doc__: 函式的文件；另外也可以用屬性名func_doc。
• __name__: 函式定義時的函式名；另外也可以用屬性名func_name。
• *__module__: 包含該函式定義的模組名；同樣注意，是模組名而不是模組物件。
• *__dict__: 函式的可用屬性；另外也可以用屬性名func_dict。  不要忘了函式也是物件，可以使用函式.屬性名訪問屬性（賦值時如果屬性不存在將新增一個），或使用內建函式has/get/setattr()訪問。不過，在函式中儲存屬性的意義並不大。

• func_defaults: 這個屬性儲存了函式的引數預設值元組；因為預設值總是靠後的引數才有，所以不使用字典的形式也是可以與引數對應上的。
• func_code: 這個屬性指向一個該函式對應的code物件，code物件中定義了其他的一些特殊屬性，將在下文中另外介紹。
• func_globals: 這個屬性指向當前的全域性名稱空間而不是定義函式時的全域性名稱空間，用處不大，並且是隻讀的。
• *func_closure: 這個屬性僅當函式是一個閉包時有效，指向一個儲存了所引用到的外部函式的變數cell的元組，這個屬性也是隻讀的。（通過func_closure可以檢視必報）

#coding:utf-8
def foo():
    name = 'zhangsan'
    age = 11

    def bar():
        print name, age

    return bar

closure = foo()

print closure.func_closure 
# (<cell at 0x7f2fa7d36558: int object at 0x19f7b78>, <cell at 0x7f2fa7d36590: str object at 0x7f2fa7d37450>)

for cell in closure.func_closure:
    print cell.cell_contents
    # zhangsan
    # 11

2.6. 方法(method)

方法雖然不是函式，但可以理解為在函式外面加了一層外殼；拿到方法裡實際的函式以後，就可以使用2.5節的屬性了。

• __doc__: 與函式相同。
• __name__: 與函式相同。
• *__module__: 與函式相同。
• im_func: 使用這個屬性可以拿到方法裡實際的函式物件的引用。另外如果是2.6以上的版本，還可以使用屬性名__func__。
• im_self: 如果是繫結的(bound)，則指向呼叫該方法的類（如果是類方法）或例項（如果是例項方法），否則為None。如果是2.6以上的版本，還可以使用屬性名__self__。
• im_class: 實際呼叫該方法的類，或實際呼叫該方法的例項的類。注意不是方法的定義所在的類，如果有繼承關係的話。

 這裡討論的是一般的例項方法，另外還有兩種特殊的方法分別是類方法(classmethod)和靜態方法(staticmethod)。類方法還是方法，不過因為需要使用類名呼叫，所以他始終是繫結的；而靜態方法可以看成是在類的名稱空間裡的函式（需要使用類名呼叫的函式），它只能使用函式的屬性，不能使用方法的屬性。

#coding:utf-8

class Dog(object):
    def imeth(self):
        print 'instance method ', self

    @classmethod
    def cmeth(cls):
        print 'class method ', cls

    @staticmethod
    def smeth():
        print 'static method '

dog = Dog()
dog.imeth() #例項呼叫 繫結方法
Dog.imeth(dog) #類呼叫 未繫結方法

Dog.cmeth() # 類呼叫類方法
Dog.smeth() # 類呼叫靜態方法

# 例項雖然也可以呼叫 類方法和靜態方法，但是沒有多大意義，類方法依舊繫結類本身
dog.cmeth()
dog.smeth()

print '============================'


print dog.imeth.__self__ #<__main__.Dog object at 0x7f9a69d04e10>
print Dog.imeth.__self__ #None 未繫結
print Dog.cmeth.__self__ #<class '__main__.Dog'>
print dog.cmeth.__self__ #<class '__main__.Dog'> 使用例項呼叫類方法沒有多大意義，依舊繫結類本身
#print Dog.smeth.__self__ # 靜態方法可以理解為類中的函式（function），所以沒有__self__

2.7. 生成器(generator)

生成器是呼叫一個生成器函式(generator function)返回的物件，多用於集合物件的迭代。

• __iter__: 僅僅是一個可迭代的標記。
• gi_code: 生成器對應的code物件。
• gi_frame: 生成器對應的frame物件。
• gi_running: 生成器函式是否在執行。生成器函式在yield以後、執行yield的下一行程式碼前處於frozen狀態，此時這個屬性的值為0。
• next|close|send|throw: 這是幾個可呼叫的方法，並不包含元資料資訊，如何使用可以檢視生成器的相關文件。

#coding:utf-8

def gen():
    for n in xrange(5):
        yield n

g = gen()

print g
print g.gi_code
print g.gi_frame
print g.gi_running

接下來討論的是幾個不常用到的內建物件型別。這些型別在正常的編碼過程中應該很少接觸，除非你正在自己實現一個直譯器或開發環境之類。所以這裡只列出一部分屬性，如果需要一份完整的屬性表或想進一步瞭解，可以檢視文末列出的參考文件。

2.8. 程式碼塊(code)

程式碼塊可以由類原始碼、函式原始碼或是一個簡單的語句程式碼編譯得到。這裡我們只考慮它指代一個函式時的情況；2.5節中我們曾提到可以使用函式的func_code屬性獲取到它。code的屬性全部是隻讀的。

• co_argcount: 普通引數的總數，不包括*引數和**引數。
• co_varnames: 所有的引數名（包括*引數和**引數）和區域性變數名的元組。
• co_filename: 原始碼所在的檔名。
• co_flags:  這是一個數值，每一個二進位制位都包含了特定資訊。較關注的是0b100(0×4)和0b1000(0×8)，如果co_flags & 0b100 != 0，說明使用了*args引數；如果co_flags & 0b1000 != 0，說明使用了**kwargs引數。另外，如果co_flags & 0b100000(0×20) != 0，則說明這是一個生成器函式(generator function)

（我的理解是code代表了類、函式程式碼本身的一些特徵）

#coding:utf-8

def foo(name, age=11, home='CHN', *args, **kwargs):
    inner = 'inner'
    
co = foo.func_code
print co.co_argcount #3 普通引數 name age home
print co.co_varnames 
# ('name', 'age', 'home', 'args', 'kwargs', 'inner')
print co.co_flags & 0b100 #4 表明使用了*args

2.9. 棧幀(frame)

棧幀表示程式執行時函式呼叫棧中的某一幀。函式沒有屬性可以獲取它，因為它在函式呼叫時才會產生，而生成器則是由函式呼叫返回的，所以有屬性指向棧幀（我的理解就是生成器是動態的）。想要獲得某個函式相關的棧幀，則必須在呼叫這個函式且這個函式尚未返回時獲取。你可以使用sys模組的_getframe()函式、或inspect模組的currentframe()函式獲取當前棧幀。這裡列出來的屬性全部是隻讀的。

• f_back: 呼叫棧的前一幀。
• f_code: 棧幀對應的code物件。
• f_locals: 用在當前棧幀時與內建函式locals()相同，但你可以先獲取其他幀然後使用這個屬性獲取那個幀的locals()。
• f_globals: 用在當前棧幀時與內建函式globals()相同，但你可以先獲取其他幀……。

2.10. 追蹤(traceback)

追蹤是在出現異常時用於回溯的物件，與棧幀相反。由於異常時才會構建，而異常未捕獲時會一直向外層棧幀丟擲，所以需要使用try才能見到這個物件。你可以使用sys模組的exc_info()函式獲得它，這個函式返回一個元組，元素分別是異常型別、異常物件、追蹤。traceback的屬性全部是隻讀的。

• tb_next: 追蹤的下一個追蹤物件。
• tb_frame: 當前追蹤對應的棧幀。
• tb_lineno: 當前追蹤的行號。

3. 使用inspect模組

inspect模組提供了一系列函式用於幫助使用自省。下面僅列出較常用的一些函式，想獲得全部的函式資料可以檢視inspect模組的文件。

3.1. 檢查物件型別

• is{module|class|function|method|builtin}(obj): 檢查物件是否為模組、類、函式、方法、內建函式或方法。

• isroutine(obj):  用於檢查物件是否為函式、方法、內建函式或方法等等可呼叫型別。用這個方法會比多個is*()更方便，不過它的實現仍然是用了多個is*()。

#coding:utf-8
import inspect

print inspect.ismodule(inspect) #True
print inspect.isfunction(inspect.isfunction) #True
print inspect.isbuiltin(sorted) #True
print inspect.isroutine(sorted) #True

對於實現了__call__的類例項，這個方法會返回False。如果目的是隻要可以直接呼叫就需要是True的話，不妨使用isinstance(obj, collections.Callable)這種形式。我也不知道為什麼Callable會在collections模組中，抱歉！我猜大概是因為collections模組中包含了很多其他的ABC(Abstract Base Class)的緣故吧：）

#coding:utf-8
import collections

class Dog(object):
    def __call__(self, name):#實現__call__方法就可以直接呼叫物件了
        print 'i am a dog named ' , name

dog = Dog()
dog('DaHuang')

print isinstance(dog, collections.Callable) #True

print dog.__class__.__bases__

3.2. 獲取物件資訊

• getmembers(object[, predicate]): 這個方法是dir()的擴充套件版，它會將dir()找到的名字對應的屬性一併返回，形如[(name, value), ...]。另外，predicate是一個方法的引用，如果指定，則應當接受value作為引數並返回一個布林值，如果為False，相應的屬性將不會返回。使用is*作為第二個引數可以過濾出指定型別的屬性。
• getmodule(object):還在為第2節中的__module__屬性只返回字串而遺憾嗎？這個方法一定可以滿足你，它返回object的定義所在的模組物件。
• get{file|sourcefile}(object):獲取object的定義所在的模組的檔名|原始碼檔名（如果沒有則返回None）。用於內建的物件（內建模組、類、函式、方法）上時會丟擲TypeError異常。
• get{source|sourcelines}(object):獲取object的定義的原始碼，以字串|字串列表返回。程式碼無法訪問時會丟擲IOError異常。只能用於module/class/function/method/code/frame/traceack物件。

• getargspec(func): 僅用於方法，獲取方法宣告的引數，返回元組，分別是(普通引數名的列表, *引數名, **引數名, 預設值元組)。如果沒有值，將是空列表和3個None。如果是2.6以上版本，將返回一個命名元組(Named Tuple)，即除了索引外還可以使用屬性名訪問元組中的元素。

#coding:utf-8
import inspect
from a import *

print inspect.getmembers(Cat, inspect.ismethod)
#[('__init__', <unbound method Cat.__init__>), ('sayHi', <unbound method Cat.sayHi>)]

print cat.__module__ #str
print inspect.getmodule(cat) #<module 'a' from '/tmp/zc/a.pyc'> module 物件

print inspect.getfile(Cat) #/tmp/zc/a.pyc

print inspect.getsource(Cat) # 返回原始碼（覺得這個挺酷的！！！）
"""
class Cat(object):
    def __init__(self, name='Kitty'):
        self.name = name

    def sayHi(self):
        print self.name, 'says Hi!'
"""
class Dog(object):
    def foo(self, name, age=11, home='CHN', *args, **kwargs):
        pass


print inspect.getargspec(Dog.foo)
#ArgSpec(args=['self', 'name', 'age', 'home'], varargs='args', keywords='kwargs', defaults=(11, 'CHN'))

getmro(cls): 
返回一個型別元組，查詢類屬性時按照這個元組中的順序。如果是新式類，與cls.__mro__結果一樣。但舊式類沒有__mro__這個屬性，直接使用這個屬性會報異常，所以這個方法還是有它的價值的。

#coding:utf-8
import inspect

class A(object):
    pass

class B(object):
    pass

class C(A, B):
    pass

print inspect.getmro(C) 
print C.__mro__
print C.mro()
"""
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>)
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>)
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>]
"""