Python 編程語言要掌握的技能之一：編寫條件分支代碼的技巧

時間 2019-11-20

標籤 python 編程語言掌握技能之一編寫條件分支代碼技巧欄目 Python 简体版

原文原文鏈接

Python 裏的分支代碼

Python 支持最爲常見的 if/else 條件分支語句，不過它缺乏在其餘編程語言中常見的 switch/case 語句。除此以外，Python 還爲 for/while 循環以及 try/except 語句提供了 else 分支，在一些特殊的場景下，它們能夠大顯身手。下面我會從最佳實踐、常見技巧、常見陷阱三個方面講一下若是編寫優秀的條件分支代碼。html

最佳實踐

1. 避免多層分支嵌套

若是這篇文章只能刪減成一句話就結束，那麼那句話必定是**「要竭盡所能的避免分支嵌套」**。過深的分支嵌套是不少編程新手最容易犯的錯誤之一。假若有一位新手 JavaScript 程序員寫了不少層分支嵌套，那麼你可能會看到一層又一層的大括號：if { if { if { ... }}}。俗稱「嵌套 if 地獄（Nested If Statement Hell）」。可是由於 Python 使用了縮進來代替 {}，因此過深的嵌套分支會產生比其餘語言下更爲嚴重的後果。好比過多的縮進層次很容易就會讓代碼超過 PEP8 中規定的每行字數限制。讓咱們看看這段代碼：python

def buy_fruit(nerd, store):

    """去水果店買蘋果

    - 先得看看店是否是在營業

    - 若是有蘋果的話，就買 1 個

    - 若是錢不夠，就回家取錢再來

    """

    **if** store.is_open():

        **if** store.has_stocks("apple"):

            **if** nerd.can_afford(store.price("apple", amount=1)):

                nerd.buy(store, "apple", amount=1)

                **return**

            **else**:

                nerd.go_home_and_get_money()

                **return** buy_fruit(nerd, store)

        **else**:

            raise MadAtNoFruit("no apple in store!")

    **else**:

        raise MadAtNoFruit("store is closed!")

上面這段代碼最大的問題，就是過於直接翻譯了原始的條件分支要求，致使短短十幾行代碼包含了有三層嵌套分支。這樣的代碼可讀性和維護性都不好。不過咱們能夠用一個很簡單的技巧：「提早結束」 來優化這段代碼：程序員

def buy_fruit(nerd, store):

    **if** **not** store.is_open():

        raise MadAtNoFruit("store is closed!")

    **if** **not** store.has_stocks("apple"):

        raise MadAtNoFruit("no apple in store!")

    **if** nerd.can_afford(store.price("apple", amount=1)):

        nerd.buy(store, "apple", amount=1)

        **return**

    **else**:

        nerd.go_home_and_get_money()

        **return** buy_fruit(nerd, store)

「提早結束」指：**在函數內使用 return 或 raise 等語句提早在分支內結束函數。**好比，在新的 buy_fruit 函數裏，當分支條件不知足時，咱們直接拋出異常，結束這段這代碼分支。這樣的代碼沒有嵌套分支，更直接也更易讀。golang

2. 封裝那些過於複雜的邏輯判斷

若是條件分支裏的表達式過於複雜，出現了太多的 not/and/or，那麼這段代碼的可讀性就會大打折扣，好比下面這段代碼：chrome

# 若是活動還在開放，而且活動剩餘名額大於 10，爲全部性別爲女性，或者級別大於 3

# 的活躍用戶發放 10000 個金幣

**if** activity.is_active **and** activity.remaining> 10 **and** \

        user.is_active **and** (user.sex== 'female' **or** user.level> 3):

    user.add_coins(10000)

    **return**

對於這樣的代碼，咱們能夠考慮將具體的分支邏輯封裝成函數或者方法，來達到簡化代碼的目的：編程

**if** activity.allow_new_user() **and** user.match_activity_condition():

    user.add_coins(10000)

    **return**

事實上，將代碼改寫後，以前的註釋文字其實也能夠去掉了。**由於後面這段代碼已經達到了自說明的目的。**至於具體的什麼樣的用戶知足活動條件？這種問題，就應由具體的 match_activity_condition() 方法來回答了。app

Hint: 恰當的封裝不光直接改善了代碼的可讀性，事實上，若是上面的活動判斷邏輯在代碼中出現了不止一次的話，封裝更是必須的。否則重複代碼會極大的破壞這段邏輯的可維護性。編程語言

3. 留意不一樣分支下的重複代碼

重複代碼是代碼質量的天敵，而條件分支語句又很是容易成爲重複代碼的重災區。因此，當咱們編寫條件分支語句時，須要特別留意，不要生產沒必要要的重複代碼。讓咱們看下這個例子：函數

# 對於新用戶，建立新的用戶資料，不然更新舊資料

**if** user.no_profile_exists:

    create_user_profile(

        username=user.username,

        email=user.email,

        age=user.age,

        address=user.address,

        # 對於新建用戶，將用戶的積分置爲 0

        points=0,

        created=now(),

    )

**else**:

    update_user_profile(

        username=user.username,

        email=user.email,

        age=user.age,

        address=user.address,

        updated=now(),

    )

在上面的代碼中，咱們能夠一眼看出，在不一樣的分支下，程序調用了不一樣的函數，作了不同的事情。可是，由於那些重複代碼的存在，咱們卻很難簡單的區分出，兩者的不一樣點到底在哪。 其實，得益於 Python 的動態特性，咱們能夠簡單的改寫一下上面的代碼，讓可讀性能夠獲得顯著的提高：優化

**if** user.no_profile_exists:

    profile_func= create_user_profile

    extra_args= {'points': 0, 'created': now()}

**else**:

    profile_func= update_user_profile

    extra_args= {'updated': now()}

profile_func(

    username=user.username,

    email=user.email,

    age=user.age,

    address=user.address,

    **extra_args

)

當你編寫分支代碼時，請額外關注由分支產生的重複代碼塊，若是能夠簡單的消滅它們，那就不要遲疑。

4. 謹慎使用三元表達式

三元表達式是 Python 2.5 版本後才支持的語法。在那以前，Python 社區一度認爲三元表達式沒有必要，咱們須要使用 x and a or b 的方式來模擬它。[注] 事實是，在不少狀況下，使用普通的 if/else 語句的代碼可讀性確實更好。盲目追求三元表達式很容易誘惑你寫出複雜、可讀性差的代碼。因此，請記得只用三元表達式處理簡單的邏輯分支。

language= "python" **if** you.favor("dynamic") **else** "golang"

對於絕大多數狀況，仍是使用普通的 if/else 語句吧。

常見技巧

1. 使用「德摩根定律」

在作分支判斷時，咱們有時候會寫成這樣的代碼：

# 若是用戶沒有登陸或者用戶沒有使用 chrome，拒絕提供服務

**if** **not** user.has_logged_in **or** **not** user.is_from_chrome:

    **return** "our service is only available for chrome logged in user"

第一眼看到代碼時，是否是須要思考一會才能理解它想幹嗎？這是由於上面的邏輯表達式裏面出現了 2 個 not和 1 個 or。而咱們人類剛好不擅長處理過多的「否認」以及「或」這種邏輯關係。這個時候，就該德摩根定律出場了。通俗的說，德摩根定律就是 not A or not B 等價於 not (A and B)。經過這樣的轉換，上面的代碼能夠改寫成這樣：

**if** **not** (user.has_logged_in **and** user.is_from_chrome):

    **return** "our service is only open for chrome logged in user"

怎麼樣，代碼是否是易讀了不少？記住德摩根定律，不少時候它對於簡化條件分支裏的代碼邏輯很是有用。

2. 自定義對象的「布爾真假」

咱們常說，在 Python 裏，「萬物皆對象」。其實，不光「萬物皆對象」，咱們還能夠利用不少魔法方法（文檔中稱爲：user-defined method），來自定義對象的各類行爲。咱們能夠用不少在別的語言裏面沒法作到、有些魔法的方式來影響代碼的執行。好比，Python 的全部對象都有本身的「布爾真假」：

· 布爾值爲假的對象：None, 0, False, [], (), {}, set(), frozenset(), … …

· 布爾值爲真的對象：非 0 的數值、True，非空的序列、元組，普通的用戶類實例，… …

經過內建函數 bool()，你能夠很方便的查看某個對象的布爾真假。而 Python 進行條件分支判斷時用到的也是這個值：

>>> **bool**(**object**())

**True**

重點來了，雖然全部用戶類實例的布爾值都是真。可是 Python 提供了改變這個行爲的辦法：自定義類的 bool 魔法方法 （在 Python 2.X 版本中爲 nonzero）。當類定義了 bool 方法後，它的返回值將會被看成類實例的布爾值。另外，bool 不是影響實例布爾真假的惟一方法。若是類沒有定義 bool 方法，Python 還會嘗試調用 len 方法（也就是對任何序列對象調用 len 函數），經過結果是否爲 0 判斷實例真假。那麼這個特性有什麼用呢？看看下面這段代碼：

**class** UserCollection(**object**):

    def __init__(**self**, users):

        **self**._users= users

users= UserCollection([piglei, raymond])

**if** len(users._users)> 0:

    print("There's some users in collection!")

上面的代碼裏，判斷 UserCollection 是否有內容時用到了 users._users 的長度。其實，經過爲 UserCollection 添加 len 魔法方法，上面的分支能夠變得更簡單：

**class** UserCollection:

    def __init__(**self**, users):

        **self**._users= users

    def __len__(**self**):

        **return** len(**self**._users)

users= UserCollection([piglei, raymond])

# 定義了 __len__ 方法後，UserCollection 對象自己就能夠被用於布爾判斷了

**if** users:

    print("There's some users in collection!")

經過定義魔法方法 len 和 bool ，咱們可讓類本身控制想要表現出的布爾真假值，讓代碼變得更 pythonic。

3. 在條件判斷中使用 all() / any()

all() 和 any() 兩個函數很是適合在條件判斷中使用。這兩個函數接受一個可迭代對象，返回一個布爾值，其中：

· all(seq)：僅當 seq 中全部對象都爲布爾真時返回 True，不然返回 False

· any(seq)：只要 seq 中任何一個對象爲布爾真就返回 True，不然返回 False

假如咱們有下面這段代碼：

def all_numbers_gt_10(numbers):

    """僅當序列中全部數字大於 10 時，返回 True

    """

    **if** **not** numbers:

        **return** **False**

    **for** n **in** numbers:

        **if** n<= 10:

            **return** **False**

    **return** **True**

若是使用 all() 內建函數，再配合一個簡單的生成器表達式，上面的代碼能夠寫成這樣：

def all_numbers_gt_10_2(numbers):

    **return** **bool**(numbers) **and** all(n> 10 **for** n **in** numbers)

簡單、高效，同時也沒有損失可用性。

4. 使用 try/while/for 中 else 分支

讓咱們看看這個函數：

def do_stuff():

    first_thing_successed= **False**

    **try**:

        do_the_first_thing()

        first_thing_successed= **True**

    except Exception **as** e:

        print("Error while calling do_some_thing")

        **return**

    # 僅當 first_thing 成功完成時，作第二件事

    **if** first_thing_successed:

        **return** do_the_second_thing()

在函數 do_stuff 中，咱們但願只有當 do_the_first_thing() 成功調用後（也就是不拋出任何異常），才繼續作第二個函數調用。爲了作到這一點，咱們須要定義一個額外的變量 first_thing_successed 來做爲標記。其實，咱們能夠用更簡單的方法達到一樣的效果：

def do_stuff():

    **try**:

        do_the_first_thing()

    except Exception **as** e:

        print("Error while calling do_some_thing")

        **return**

    **else**:

        **return** do_the_second_thing()

在 try 語句塊最後追加上 else 分支後，分支下的do_the_second_thing() 便只會在 try 下面的全部語句正常執行（也就是沒有異常，沒有 return、break 等）完成後執行。相似的，Python 裏的 for/while 循環也支持添加 else 分支，它們表示：當循環使用的迭代對象被正常耗盡、或 while 循環使用的條件變量變爲 False 後才執行 else 分支下的代碼。

常見陷阱

1. 與 None 值的比較

在 Python 中，有兩種比較變量的方法：== 和 is，兩者在含義上有着根本的區別：

· ==：表示兩者所指向的的值是否一致

· is：表示兩者是否指向內存中的同一分內容，也就是 id(x) 是否等於 id(y)

None 在 Python 語言中是一個單例對象，若是你要判斷某個變量是否爲 None 時，記得使用 is 而不是 ==，由於只有 is 才能在嚴格意義上表示某個變量是不是 None。不然，可能出現下面這樣的狀況：

>>> **class** Foo(**object**):

... def __eq__(**self**, other):

... **return** **True**

...

>>> foo= Foo()

>>> foo== None

**True**

在上面代碼中，Foo 這個類經過自定義 eq 魔法方法的方式，很容易就知足了 == None 這個條件。 因此，當你要判斷某個變量是否爲 None 時，請使用 is 而不是 ==。

2. 留意 and 和 or 的運算優先級

看看下面這兩個表達式，猜猜它們的值同樣嗎？

Python

>>> (**True** **or** **False**) **and** **False**

>>> **True** **or** **False** **and** **False**

答案是：不同，它們的值分別是 False 和 True，你猜對了嗎？問題的關鍵在於：and** 運算符的優先級大於 **or。所以上面的第二個表達式在 Python 看來其實是 True or (False and False)。因此結果是 True 而不是 False。在編寫包含多個 and 和 or 的表達式時，請額外注意 and 和 or 的運算優先級。即便執行優先級正好是你須要的那樣，你也能夠加上額外的括號來讓代碼更清晰。