Python: 淺析 return 和 finally 共同挖的坑

wangzy2019 發布于2019-07-30 14:29 / 3454人閱讀

摘要：初識相信每一個用過函數的童鞋肯定會用過語句顧名思義就是用來返回值給調用者例如輸出結果對于上面的結果相信大家都不會感到意外那么加大點難度如果在語句還有代碼呢那句代碼會怎樣呢結果是什么老司機肯定一眼就能看出結果但是對于尚在入門或者對不很了解的童

初識 return

??相信每一個用過Python函數的童鞋, 肯定會用過return語句, return顧名思義, 就是用來返回值給調用者, 例如:

def test():
    a = 2
    return a

s = test()
print s

# 輸出結果
2

對于上面的結果, 相信大家都不會感到意外, 那么加大點難度, 如果在return語句還有代碼呢? 那句代碼會怎樣呢?

def test():
    a = 2
    return a
    s = 3
    print s

s = test()
print s

# 結果是什么?

老司機肯定一眼就能看出結果, 但是對于尚在入門或者對return不很了解的童鞋, 可能就會懵逼了~ 后面的兩句代碼是否會被執行?
答案是: 不會執行

return正如它的名字那樣, 當執行這句代碼, 整個函數都會返回, 整個調用就算結束了~ 所以在return后面的代碼, 都是不會被執行的!
??也正因為這個特性, 所以有種編碼規范叫early return的編碼規范就被倡導

它的意思大概就是: 當條件已經滿足返回時, 就馬上返回
舉個例子來說明:

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, 所以我們可以把代碼調整成這樣:

def test():
    a = 2
    if a > 2:
        return "more than"
    else:
        return "less than"

s = test()
print s

甚至是:

def test():
    a = 2
    if a > 2:
        return "more than"
    return "less than"

s = test()
print s

結果都是和第一個寫法是一樣的! 第一次看到這樣寫法的童鞋, 可能會覺得比較難以接受, 甚至覺得可讀性很差, 但是其實這樣的寫法, 我覺得反而會稍微好點. 因為:

運行的代碼數少了, 調用方能更快得到結果

有利于減少嵌套的層數, 便于理解.

對于第2點在這需要解釋下, 很多時候我們寫得代碼, 嵌套很深, 都是因為if/else的鍋, 因為嵌套的if/else 比較多, 所以導致一堆代碼都嵌套得比較深, 這樣對于其他小伙伴, 簡直就是災難, 因為他們很可能在閱讀這部分代碼時, 就忘了前面的邏輯....
為了更加容易理解, 舉個代碼例子:

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 !

代碼簡化優化版:

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應該有比較基本的理解了! 所以來聊聊更加迷惑的話題:

當 return 遇上 try..finally, 會怎樣呢?

如果剛才有認真看的話, 會注意到一句話, 就是:

return 代表整個函數返回, 函數調用算結束

但事實真的這樣嗎? 通常這樣問, 答案一般都不是 ~~
先來看看例子:

def test():
    try:
        a = 2
        return a
    except:
        pass

    finally:
        print "finally"

s = test()
print s

可以猜猜這句print a會不會打印? 相信很多童鞋都想了一會, 然后說不會~ 然而這個答案是錯的, 真正的輸出是:

finally
2

有木有覺得仿佛看見了新大陸, 在一開始的例子中, return后面的語句沒有被執行, 但是在這里, 相隔那么遠, 卻依舊沒有忘記, 這或許就是"真愛"吧!

然而就是因為這種"真愛", 總是會讓一堆新老司機掉坑里..然后還不知道為毛..

為了避免它們再繼續借用打著"真愛"的幌子, 欺負我們, 讓我們一起來揭開這"真愛"的真面目!

于是, 我們得借助偷窺神器: dis, 想想都有點小興奮!

import dis
def test():
    try:
        a = 2
        return a
    except:
        pass

    finally:
        print "finally"

print dis.dis(test)

輸出比較長, 多帶帶寫:

# 輸出結果
  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

// 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, 所以它對應的源碼是:

// 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;的地方~, 沒辦法, 為了揭穿真面目, 只好掘地三尺了:

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的值去執行對應的操作! 所以可以說并不是真的實質性的返回. 希望我們往后再用到它們的時候, 別再掉坑里!

歡迎各位大神指點交流, QQ討論群: 258498217
轉載請注明來源: https://segmentfault.com/a/11...

云服務器 GPU云服務器共同開發源碼淺析 cdn淺析語言的坑爹設計

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/40740.html

【Flutter組件】仿微信左滑刪除組件與透明背景時的處理

摘要：本文用到的組件這是一個簡單版仿微信的左滑刪除的組件左滑刪除組件地址倉庫地址問題在上，使用仿微信樣式的左滑刪除組件時如果這一行的背景色是透明的，就會出現如下問題透明的下可以看到刪除和編輯按鈕，我們就需要處理一下。本文用到的組件：這是一個簡單版仿微信的左滑刪除的組件： # 左滑刪除組件 left_scroll_actions: any pub地址：https://pub.dartlan...

mingzhong 2019-08-26 10:19 評論0 收藏0
淺析Otto框架，并與EventBus對比

摘要：它有發布者，訂閱者這兩個主要對象。的最佳實踐就是通過反射犧牲了微小的性能，同時極大的降低了程序的耦合度。官網和應用場景框架的主要功能是幫助我們來降低多個組件通信之間的耦合度的解耦。前兩天在公眾號里發了一篇有關EventBus的文章《玩轉EventBus,詳解其使用》，有讀者和開發者反饋說沒有OTTO好用。確實是，各有優缺點吧，那今天就有必要再講一下Otto事件框架。 OTTO是Squ...

EsgynChina 2019-08-14 15:32 評論0 收藏0
JAVA HashMap源碼淺析

摘要：類的屬性和構造函數二的初始化構造方法這是的構造函數之一，其他構造函數都引用這個構造函數進行初始化。在構造函數中不會對數組進行初始化，只有在等操作方法內會進行判斷是否要初始化或擴容。其作用是保證的效率。引言 HashMap在鍵值對存儲中被經常使用，那么它到底是如何實現鍵值存儲的呢？一 Entry Entry是Map接口中的一個內部接口，它是實現鍵值對存儲關鍵。在HashMap中，有E...

xuxueli 2019-08-14 12:20 評論0 收藏0
一起學設計模式 - 單例模式

摘要：懶漢非線程安全，需要用一定的風騷操作控制，裝逼失敗有可能導致看一周的海綿寶寶餓漢天生線程安全，的時候就已經實例化好，該操作過于風騷會造成資源浪費單例注冊表初始化的時候，默認單例用的就是該方式特點私有構造方法，只能有一個實例。單例設計模式（Singleton Pattern）是最簡單且常見的設計模式之一，主要作用是提供一個全局訪問且只實例化一次的對象，避免多實例對象的情況下引起邏輯性錯...

Keven 2019-08-15 12:20 評論0 收藏0