Python學習教程_Python學習路線：python反射機制

Python學習教程（Python學習路線）：python反射機制

反射

反射機制就是在運行時，動態的肯定對象的類型，並能夠經過字符串調用對象屬性、方法、導入模塊，是一種基於字符串的事件驅動。

解釋型語言：程序不須要編譯，程序在運行時才翻譯成機器語言，每執行一次都要翻譯一次。所以效率比較低。相對於編譯型語言存在的，源代碼不是直接翻譯成機器語言，而是先翻譯成中間代碼，再由解釋器對中間代碼進行解釋運行。好比Python/JavaScript / Perl /Shell等都是解釋型語言。

python是一門解釋型語言，所以對於反射機制支持很好。在python中支持反射機制的函數有getattr()、setattr()、delattr()、exec()、eval()、__import__，這些函數均可以執行字符串。

eval

計算指定表達式的值。它只能執行單個表達式，而不能是複雜的代碼邏輯。並且不能是賦值表達式。

單個表達式：

a = "12 + 43"
b = eval(a)
print(b)
複製代碼

複雜表達式：

a = "print(12 + 43); print(1111)"
b = eval(a)
print(b)
# 輸出：
Traceback (most recent call last):
 File "xxxx.py", line 10, in <module>
 b = eval(a)
 File "<string>", line 1
 print(12 + 43); print(1111)
 ^
SyntaxError: invalid syntax
複製代碼

賦值：

a = 1
b = eval("a = 21")
print(b)
複製代碼

一般咱們使用eval的時候，主要是使用它的返回值，獲取表達式計算出的值

exec

執行復雜表達式，返回值永遠都是None

b = exec("aa = 21")
print(b) # None，exec返回值爲None
print(aa) # 21，exec執行了賦值語句，並定義了aa變量
複製代碼

執行復雜語句：

a = '''ret = [] for i in range(10): ret.append(i)'''
exec(a)
print(ret) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
複製代碼

導入模塊：

# 導入模塊
exec("import config")
print(config.KEYWORD)
# 動態建立類
class Base:
 def __init__(self):
 print("Base")
a = "Base"
exec(a+"()")
複製代碼

導入模塊這個功能就很是厲害了，這樣咱們就能夠動態的建立各類模塊類。

eval()函數和exec()函數的區別：

eval()函數只能計算單個表達式的值，而exec()函數能夠動態運行代碼段。

eval()函數能夠有返回值，而exec()函數返回值永遠爲None。

再看一下下面的例子：

class Base:
 def __init__(self):
 print("Base")
 def test(self):
 print("test")
 return "Base::test"
複製代碼

若是咱們想經過字符串來調用a對象的test方法，應該怎麼作呢，若是要獲取返回值，那麼可使用

b = eval("a.test()")
print(b)
複製代碼

輸出：

test

Base::test

若是不須要獲取返回值，那麼可使用exec，exec("a.test()")，輸出：test

雖然咱們可使用eval和exec來執行以上代碼，可是這種方式有一個缺陷，假如這個屬性是不存在的，那麼這種調用就會報錯。那麼作好的方式是什麼呢？先判斷屬性是否存在，若是存在就調用，不存在就不調用，python爲咱們提供了一套方法：hasattr、getattr、setattr、delattr

hasattr

def hasattr(*args, **kwargs): # real signature unknown
 """ Return whether the object has an attribute with the given name. This is done by calling getattr(obj, name) and catching AttributeError. """
 pass
複製代碼

經過源碼註釋咱們知道，它返回對象是否具備指定名稱的屬性。並且它是經過調用getattr並捕獲AttributeError異常來判斷的。就像上面的屬性調用，咱們就可使用hasattr(a, "test")來判斷，經過源碼註釋咱們也能夠思考一下，eval這種是否是也能夠實現這種方法呢？

def has_attr(obj, name):
 try:
 eval("obj.%s()" % name)
 return True
 except AttributeError as e:
 return False
a = Base()
if has_attr(a, "test"):
 eval("a.test()")
# 輸出：
Base
test
test
複製代碼

可是這種方式是有缺陷的，由於test輸出了兩次，由於咱們調用了兩次test()，這跟咱們想要的效果不同。若是用hasattr呢，這個函數就不會在判斷的時候調用一次了。

getattr()

有了判斷屬性是否存在的函數，那麼就得有獲取屬性的函數了

def getattr(object, name, default=None): # known special case of getattr
 """ getattr(object, name[, default]) -> value Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y. When a default argument is given, it is returned when the attribute doesn't exist; without it, an exception is raised in that case. """
 pass
複製代碼

從源碼註釋咱們就能知道獲取object對象的名爲name的屬性，想到與object.name，若是提供了default參數，那麼當屬性不存在的時候，就會返回默認值。一樣是上面的例子：

a = Base()
if hasattr(a, "test"):
 func = getattr(a, "test")
 func()
# 輸出：
Base
test
複製代碼

從例子中咱們能夠看出，hasattr並無調用test函數，並且getattr獲取到的是函數對象，也沒有調用它，經過咱們主動執行func()才執行了a.test()函數，這樣相比於exec和eval就靈活了許多。

setattr

判斷和獲取屬性有了，那麼設置屬性也是須要的

def setattr(x, y, v): # real signature unknown; restored from __doc__
 """ Sets the named attribute on the given object to the specified value. setattr(x, 'y', v) is equivalent to ``x.y = v'' """
 pass
複製代碼

將一個特殊值設置給object對象的name屬性，至關於x.y = v

class Base:
 def __init__(self):
 self.name = "name"
a = Base()
setattr(a, "name", "zhangsan")
print(a.name) # 改變原有屬性的值
setattr(a, "age", 32)
print(getattr(a, "age")) # 新增不存在的屬性，並設置值
複製代碼

雖然setattr(a, "age", 32)等於a.age=32，可是咱們不要忘了，這是經過一個字符串來增長的屬性。

判斷、獲取、增長都有了，固然還有刪除delattr，這個咱們就不詳述了，接下來咱們要看一個比較重要的方法。

import

在學習exec的時候，咱們有一個例子，導入配置文件exec("import config")，針對這種方式python也爲咱們提供了更好的方法。

def __import__(name, globals=None, locals=None, fromlist=(), level=0): # real signature unknown; restored from __doc__
 """ __import__(name, globals=None, locals=None, fromlist=(), level=0) -> module Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module. The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate ``from name import ...'', or an empty list to emulate ``import name''. When importing a module from a package, note that __import__('A.B', ...) returns package A when fromlist is empty, but its submodule B when fromlist is not empty. The level argument is used to determine whether to perform absolute or relative imports: 0 is absolute, while a positive number is the number of parent directories to search relative to the current module. """
 pass
複製代碼

在這裏咱們最須要關注的是formlist參數，先看一個簡單的例子：

a = __import__("config")
print(a.KEYWORD)
複製代碼

config是一個py腳本-config.py，內部有一個變量KEYWORD，咱們要經過其餘py模塊來導入這個文件，使用__import__咱們就能夠把它導入爲一個對象，而後使用對象的方式去調用，而不是一直用exec字符串的形式去調用。上面咱們說了formlist這個參數須要關注，爲何呢？咱們新增了一個模塊：comm。模塊內有一個腳本function.py

# function.py
def comm_function():
 print("test_module")
複製代碼

咱們如今想經過動態引入的方式調用comm_function函數，那麼按照上面的方式來

a = __import__("comm.function")
a.comm_function()
複製代碼

結果輸出：

Traceback (most recent call last):
 File "xxx.py", line 10, in <module>
 print(a.comm_function())
AttributeError: module 'comm' has no attribute 'comm_function'
複製代碼

意思是comm模塊沒有comm_function這個屬性，爲何是comm模塊而不是function呢？咱們能夠打印一下模塊的引入名稱print(a.__name__)，打印的結果是comm，就是說咱們經過上面的方式只是引入comm，而不是function。其實經過源碼註釋咱們就知道了，__import__(A.B)，若是fromlist爲空，返回的是A包，若是不爲空，則返回其子包B。修改一下咱們的代碼：

a = __import__("comm.function", fromlist=True)
print(a.__name__)
a.comm_function()
# 輸出：
comm.function
test_module
複製代碼

引入的模塊和執行函數都正確了，符合了咱們的預期要求。

總結

經過以上的函數學習，其中有經常使用的，也有不經常使用的，可是這些函數在咱們進行框架設計時是必不可少的，尤爲是__import__，接下來咱們還會繼續看框架設計中最重要的一個概念--元編程。學完了這些概念就能夠設計框架了。開玩笑的，哪有那麼簡單。閱讀源碼是一種增加知識的最快捷方式，可是前提是基礎必定要打好。不然看源碼是一頭霧水。咱們整理完這些概念後，在找幾個源碼庫看看，學習一下里面的設計理念。

更多的Python學習教程會繼續爲你們更新哦！或者說你們有想學的Python學習教程，也能夠留言哇！