初識 return
相信每一個用過Python函式的童鞋, 肯定會用過return語句, return顧名思義, 就是用來返回值給呼叫者, 例如:
|
1 2 3 4 5 6 7 8 9 |
def test(): a = 2 return a s = test() print s # 輸出結果 2 |
對於上面的結果, 相信大家都不會感到意外, 那麼加大點難度, 如果在return語句還有程式碼呢? 那句程式碼會怎樣呢?
|
1 2 3 4 5 6 7 8 9 10 |
def test(): a = 2 return a s = 3 print s s = test() print s # 結果是什麼? |
老司機肯定一眼就能看出結果, 但是對於尚在入門或者對return不很瞭解的童鞋, 可能就會懵逼了~ 後面的兩句程式碼是否會被執行?
答案是: 不會執行
return正如它的名字那樣, 當執行這句程式碼, 整個函式都會返回, 整個呼叫就算結束了~ 所以在return後面的程式碼, 都是不會被執行的!
也正因為這個特性, 所以有種編碼規範叫early return的編碼規範就被倡導。
它的意思大概就是: 當條件已經滿足返回時, 就馬上返回
舉個例子來說明:
|
1 2 3 4 5 6 7 8 9 10 |
def test(): a = 2 if a > 2: result = 'more than' else: result = 'less than' return result s = test() print s |
上面的程式碼應該比較容易理解, 就是根據a的值, 來決定返回的result是什麼. 這樣的編碼相信也是大部分童鞋喜歡用的, 因為這樣比較符合我們直覺, 然而, 這樣寫似乎有點浪費, 因為當第一個判斷結束了, 如果結果為真, 就應該返回more than, 然後結束函式, 否則肯定就是返回less than, 所以我們可以把程式碼調整成這樣:
|
1 2 3 4 5 6 7 8 9 |
def test(): a = 2 if a > 2: return 'more than' else: return 'less than' s = test() print s |
甚至是:
|
1 2 3 4 5 6 7 8 |
def test(): a = 2 if a > 2: return 'more than' return 'less than' s = test() print s |
結果都是和第一個寫法是一樣的! 第一次看到這樣寫法的童鞋, 可能會覺得比較難以接受, 甚至覺得可讀性很差, 但是其實這樣的寫法, 我覺得反而會稍微好點. 因為:
- 執行的程式碼數少了, 呼叫方能更快得到結果
- 有利於減少巢狀的層數, 便於理解.
對於第2點在這需要解釋下, 很多時候我們寫得程式碼, 巢狀很深, 都是因為if/else的鍋, 因為巢狀的if/else 比較多, 所以導致一堆程式碼都巢狀得比較深, 這樣對於其他小夥伴, 簡直就是災難, 因為他們很可能在閱讀這部分程式碼時, 就忘了前面的邏輯….
為了更加容易理解, 舉個程式碼例子:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
def test(): a = 2 if a > 2: result = 'not 2' else: a += 2 if a < 2: result = 'not 2' else: for i in range(2): print 'test ~' result = 'Target !' return result s = test() print s # 輸出結果 test ~ test ~ Target ! |
程式碼簡化優化版:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
def test(): a = 2 if a > 2: return 'not 2' a += 2 if a < 2: return 'not 2' for i in range(2): print 'test ~' return 'Target !' s = test() print s # 輸出結果 test ~ test ~ Target ! |
這樣對比這來看, 應該能更好地理解為什麼說early return能夠減少巢狀的層數吧~ 有疑問歡迎留言討論~
談談深坑
剛才花了比較長的篇幅去介紹return, 相信看到這裡, 對於return應該有比較基本的理解了! 所以來聊聊更加迷惑的話題:
|
1 |
當 return 遇上 try..finally, 會怎樣呢? |
如果剛才有認真看的話, 會注意到一句話, 就是:
|
1 |
return 代表整個函式返回, 函式呼叫算結束 |
但事實真的這樣嗎? 通常這樣問, 答案一般都不是 ~~
先來看看例子:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
def test(): try: a = 2 return a except: pass finally: print 'finally' s = test() print s |
可以猜猜這句print a會不會列印? 相信很多童鞋都想了一會, 然後說不會~ 然而這個答案是錯的, 真正的輸出是:
|
1 2 |
finally 2 |
有木有覺得彷彿看見了新大陸, 在一開始的例子中, return後面的語句沒有被執行, 但是在這裡, 相隔那麼遠, 卻依舊沒有忘記, 這或許就是”真愛”吧!
然而就是因為這種”真愛”, 總是會讓一堆新老司機掉坑裡..然後還不知道為毛..
為了避免它們再繼續借用打著”真愛”的幌子, 欺負我們, 讓我們一起來揭開這”真愛”的真面目!
於是, 我們得藉助偷窺神器: dis, 想想都有點小興奮!
|
1 2 3 4 5 6 7 8 9 10 11 12 |
import dis def test(): try: a = 2 return a except: pass finally: print 'finally' print dis.dis(test) |
輸出比較長, 單獨寫:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
# 輸出結果 6 0 SETUP_FINALLY 28 (to 31) 3 SETUP_EXCEPT 14 (to 20) 7 6 LOAD_CONST 1 (2) 9 STORE_FAST 0 (a) 8 12 LOAD_FAST 0 (a) 15 RETURN_VALUE 16 POP_BLOCK 17 JUMP_FORWARD 7 (to 27) 9 >> 20 POP_TOP 21 POP_TOP 22 POP_TOP 10 23 JUMP_FORWARD 1 (to 27) 26 END_FINALLY >> 27 POP_BLOCK 28 LOAD_CONST 0 (None) 13 >> 31 LOAD_CONST 2 ('finally') 34 PRINT_ITEM 35 PRINT_NEWLINE 36 END_FINALLY 37 LOAD_CONST 0 (None) 40 RETURN_VALUE |
這邊簡單說著這些列所代表的意思:
|
1 2 3 4 5 |
第一列是程式碼在檔案的行號 第二列位元組碼的偏移量 位元組碼的名字 引數 位元組碼處理引數最終的結果 |
在位元組碼中可以看到, 依次是SETUP_FINALLY 和 SETUP_EXCEPT, 這個對應的就是finally和try,雖然finally在try後面, 雖然我們通常幫他們看成一個整體, 但是他們在實際上卻是分開的… 因為我們重點是finally, 所以就單單看SETUP_FINALLY
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
// ceval.c TARGET(SETUP_FINALLY) _setup_finally: { /* NOTE: If you add any new block-setup opcodes that are not try/except/finally handlers, you may need to update the PyGen_NeedsFinalizing() function. */ PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg, STACK_LEVEL()); DISPATCH(); } // fameobject.c void PyFrame_BlockSetup(PyFrameObject *f, int type, int handler, int level) { PyTryBlock *b; if (f->f_iblock >= CO_MAXBLOCKS) Py_FatalError("XXX block stack overflow"); b = &f->f_blockstack[f->f_iblock++]; b->b_type = type; b->b_level = level; b->b_handler = handler; } |
從上面的程式碼, 很明顯就能看出來, SETUP_FINALLY 就是呼叫下PyFrame_BlockSetup去建立一個Block, 然後為這個Block設定:
- b_type (opcode 也就是SETUP_FINALLY)
- b_level
- b_handler (INSTR_OFFSET() + oparg)
handler 可能比較難理解, 其實看剛才的 dis 輸出就能看到是哪個, 就是 13 >> 31 LOAD_CONST 2 (‘finally’), 這個箭頭就是告訴我們跳轉的位置的, 為什麼會跳轉到這句呢? 因為6 0 SETUP_FINALLY 28 (to 31)已經告訴我們將要跳轉到31這個位置~~~
如果這個搞清楚了, 那就再來繼續看 return, return對應的位元組碼是: RETURN_VALUE, 所以它對應的原始碼是:
|
1 2 3 4 5 6 7 |
// ceval.c TARGET_NOARG(RETURN_VALUE) { retval = POP(); why = WHY_RETURN; goto fast_block_end; } |
原來我們以前理解的return是假return! 這個return並沒有直接返回嘛, 而是將堆疊的值彈出來, 賦值個retval, 然後將why設定成WHY_RETURN, 接著就跑路了! 跑到一個叫fast_block_end;的地方~, 沒辦法, 為了揭穿真面目, 只好掘地三尺了:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 |
while (why != WHY_NOT && f->f_iblock > 0) { fast_block_end: while (why != WHY_NOT && f->f_iblock > 0) { /* Peek at the current block. */ PyTryBlock *b = &f->f_blockstack[f->f_iblock - 1]; assert(why != WHY_YIELD); if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) { why = WHY_NOT; JUMPTO(PyInt_AS_LONG(retval)); Py_DECREF(retval); break; } /* Now we have to pop the block. */ f->f_iblock--; while (STACK_LEVEL() > b->b_level) { v = POP(); Py_XDECREF(v); } if (b->b_type == SETUP_LOOP && why == WHY_BREAK) { why = WHY_NOT; JUMPTO(b->b_handler); break; } if (b->b_type == SETUP_FINALLY || (b->b_type == SETUP_EXCEPT && why == WHY_EXCEPTION) || b->b_type == SETUP_WITH) { if (why == WHY_EXCEPTION) { PyObject *exc, *val, *tb; PyErr_Fetch(&exc, &val, &tb); if (val == NULL) { val = Py_None; Py_INCREF(val); } /* Make the raw exception data available to the handler, so a program can emulate the Python main loop. Don't do this for 'finally'. */ if (b->b_type == SETUP_EXCEPT || b->b_type == SETUP_WITH) { PyErr_NormalizeException( &exc, &val, &tb); set_exc_info(tstate, exc, val, tb); } if (tb == NULL) { Py_INCREF(Py_None); PUSH(Py_None); } else PUSH(tb); PUSH(val); PUSH(exc); } else { if (why & (WHY_RETURN | WHY_CONTINUE)) PUSH(retval); v = PyInt_FromLong((long)why); PUSH(v); } why = WHY_NOT; JUMPTO(b->b_handler); break; } } /* unwind stack */ |
在這需要回顧下剛才的一些知識, 剛才我們看了return的程式碼, 看到它將why設定成了 WHY_RETURN, 所以在這麼一大串判斷中, 它只是走了最後面的else, 動作也很簡單, 就是將剛才return儲存的值retval再push壓回棧, 同時將why轉換成long再壓回棧, 然後有設定了下why,接著就是屁顛屁顛去執行剛才SETUP_FINALLY設定的b_handler程式碼了~ 當這這段bhandler程式碼執行完, 就再通過END_FINALLY去做回該做的事, 而這裡就是, return retval
結論
所以, 我們應該能知道為什麼當我們執行了return程式碼, 為什麼finally的程式碼還會先執行了吧, 因為return的本質, 就是設定why和retval, 然後goto到一個大判斷, 最後根據why的值去執行對應的操作! 所以可以說並不是真的實質性的返回. 希望我們往後再用到它們的時候, 別再掉坑裡!