撰寫高質量Python程式（三）基礎語法

本系列文章為《撰寫高質量代碼——改善Python程式的91個建議》的精華匯總，

關于匯入模塊

Python的3種引入外部模塊的方式：import陳述句、from ... import ... 和 __import__函式，其中前兩種比較常見，

在使用 import 時，應注意：

• 優先使用 import A 或 import A as a
• 有節制的使用 from A import B
• 盡量避免使用 from A import *

對于 from a import ...，如果無節制的使用，會帶來的問題：

• 命名空間的沖突
• 回圈嵌套匯入的問題（兩個檔案相互匯入對方的變數或函式或類）

i += 1 不等于 ++i

Python 解釋器會將 ++i 解釋為 +(+i)，其中 + 表示正數符號，對于 --i 也是類似，

因此，要明白 ++i 在 Python 的語法層面上是合法的，但并不是通常意義上的自增操作，

使用 with 自動關閉資源

對檔案操作完成后，應該立即關閉它們，因為打開的檔案不僅會占用系統資源，而且可能影響其他程式或者行程的操作，甚至會導致用戶期望與實際操作結果不一致，

Python 提供了 with 陳述句，語法為：

with 運算式 [as 目標]:
    代碼塊

with 陳述句支持嵌套，支持多個 with 子句，它們兩者可以相互轉換，with expr1 as e1, expr2 as e2 與下面的嵌套形式等價：

with expr1 as e1:
    with expr2 as e2:

使用 else 子句簡化回圈（例外處理）

在回圈中， else 子句提供了隱含的對回圈是否由 break 陳述句引發回圈結束的判斷，例子：

# 以下兩段代碼等價
# 借助了一個標志量 found 來判斷回圈結束是不是由 break 陳述句引起的，
def print_prime(n):
    for i in range(2, n):
        found = True
        for j in range(2, i):
            if i % j == 0:
                found = False
                break
        if found:
            print("{} is a prime number".format(i))

def print_prime2(n):
    for i in range(2, n):
        for j in range(2, i):
            if i % j == 0:
                break
        else:
            print("{} is a prime number".format(i))

當回圈“自然”終結（回圈條件為假）時 else 從句會被執行一次，而當回圈是由 break 陳述句中斷時，else 子句就不被執行，

與 for 陳述句相似，while 陳述句中的 else 子句的語意是一樣的： else 塊在回圈正常結束和回圈條件不成立時被執行，

遵循例外處理的幾點基本原則

Python中常用的例外處理語法是try、except、else、finally，它們可以有多種組合，語法形式如下：

# Run this main action first
try:
    <statements>

# 當 try 中發生 name1 的例外時，進行處理
except <name1>:
    <statements>

# 當 try 中發生 name2 或 name3 中的某一個例外時
except (name2, name3):
    <statements>

# 當 try 中發生 name4 的例外時處理，并獲取對應實體
except <name4> as <data>:
    <statements>

# 其他例外時，進行處理
except:
    <statements>

# 沒有例外時，執行
else:
    <statements>

# 無論有沒有例外，都執行
finally:
    <statements>

例外處理，通常需要遵循以下幾點基本原則：

• 不推薦在 try 中放入過多的代碼，在 try 中放入過多的代碼帶來的問題是如果程式中拋出例外，將會較難定位，給 debug 和修復帶來不便，因此應盡量只在可能拋出例外的陳述句塊前面放入 try 陳述句，
• 謹慎使用單獨的 except 陳述句處理所有例外，最好能定位具體的例外，同樣也不推薦使用 except Exception 或者 except StandardError 來捕獲例外，如果必須使用，最好能夠使用 raise 陳述句將例外拋出向上層傳遞，
• 注意例外捕獲的順序，在合適的層次處理例外，
  • 用戶也可以繼承自內建例外構建自己的例外類，從而在內建類的繼承結構上進一步延伸，在這種情況下捕獲例外的順序顯得非常重要，為了更精確地定位錯誤發生的原因，推薦的方法是將繼承結構中子類例外在前面的 except 陳述句中拋出，而父類例外在后面的 except 陳述句拋出，這樣做的原因是當 try 塊中有例外發生的時候，解釋器根據 except 宣告的順序進行匹配，在第一個匹配的地方便立即處理該例外，
  • 例外捕獲的順序非常重要，同時例外應該在適當的位置被處理，一個原則就是如果例外能夠在被捕獲的位置被處理，那么應該及時處理，不能處理也應該以合適的方式向上層拋出，向上層傳遞的時候需要警惕例外被丟失的情況，可以使用不帶引數的 raise 來傳遞，
• 使用更為友好的例外資訊，遵守例外引數的規范，通常來說有兩類例外閱讀者：使用軟體的人和開發軟體的人，

避免 finally 中可能發生的陷阱

無論 try 陳述句中是否有例外拋出，finally 陳述句總會被執行，由于這個特性，finally 陳述句經常被用來做一些清理作業，
但使用 finally 時，也要特別小心一些陷阱，

• 當 try 塊中發生例外的時候，如果在 except 陳述句中找不到對應的例外處理，例外將會被臨時保存起來，當 finally 執行完畢的時候，臨時保存的例外將會再次被拋出，但如果 finally 陳述句中產生了新的例外或者執行了 return 或者 break 陳述句，那么臨時保存的例外將會被丟失，從而導致例外屏蔽，
• 在實際應用程式開發程序中，并不推薦在 finally 中使用 return 陳述句進行回傳，這種處理方式不僅會帶來誤解而且可能會引起非常嚴重的錯誤，

深入理解 None，正確判斷物件是否為空

Python 中以下資料會當作空來處理：

• 常量 None
• 常量 False
• 任何形式的數值型別零，如 0、0L、0.0、0j
• 空的序列，如 ''、()、[]
• 空的字典，如 {}
• 當用戶定義的類中定義了 __nonzero__() 和 __len__() 方法，并且該方法回傳整數 0 或 False 的時候，

if list1 # value is not empty
    Do something
else: # value is empty
    Do some other thing

• 執行程序中會呼叫內部方法 __nonzero__() 來判斷變數 list1 是否為空并回傳其結果，

注： __nonzero__() 方法 —— 該內部方法用于對自身物件進行空值測驗，回傳 0/1 或 True/False，

• 如果一個物件沒有定義該方法，Python 將獲取 __len__() 方法呼叫的結果來進行判斷，__len__() 回傳值為 0 則表示為空，如果一個類中既沒有定義 __len__() 方法也沒有定義 __nonzero__() 方法，該類的實體用 if 判斷的結果都為 True，

格式化字串時盡量使用 .format 方式而不是 %

推薦盡量使用 format 方式而不是 % 運算子來格式化字串，理由：

• format 方式在使用上較 % 運算子更為靈活，使用 format 方式時，引數的順序與格式化的順序不必完全相同

• format 方式可以方便的作為引數傳遞

  weather = [("Monday", "rain"), ("Tuesday", "sunny"), ("Wednesday", "sunny"), ("Thursday", "rain"), ("Friday", "cloudy")]
  formatter = "Weather of '{0[0]}' is '{0[1]}'".format
  for item in map(formatter, weather):
      print(item)
  

• % 最侄訓被 .format 方式所代替，根據 Python 的官方檔案，之所以仍然保留 % 運算子是為了保持向后兼容

• % 方法在某些特殊情況下使用時需要特別小心，對于 % 直接格式化字符的這種形式，如果字符本身為元組，則需要使用在 % 使用 (itemname,) 這種形式才能避免錯誤，注意逗號，

區別對待可變物件和不可變物件

Python 中一切皆物件，物件根據其值能否修改分為可變物件和不可變物件，

• 不可變物件

  • 數字
  • 字串
  • 元組

• 可變物件

  • 字典
  • 串列
  • 位元組陣列

在將可變物件作為函式默認引數的時候要特別緊惕，對可變物件的更改會直接影響原物件，

最好的方法是傳入 None 作為默認引數，在創建物件的時候動態生成可變物件，

• 對于一個可變物件，切片操作相當于淺拷貝，

• 對于不可變物件，當我們對其進行相關操作的時候，Python 實際上仍然保持原來的值而且重新創建一個新的物件，所以字串物件不允許以索引的方式進行賦值，當有兩個物件同時指向一個字串物件的時候，對其中一個物件的操作并不會影響另一個物件，

函式傳參既不是傳值也不是傳參考

對于Python中函式的傳參方法，既不是傳值，也不是傳參考，

正確的叫法應該是傳物件（call by object）或者說傳物件的參考（call-by-object-reference），

函式引數在傳遞的程序中將整個物件傳入，

• 對于可變物件：它的修改在函式外部以及內部都可見，呼叫者和被呼叫者之間共享這個物件
• 對于不可變物件：由于并不能真正被修改，因此，修改往往是通過生成一個新物件然后賦值來實作的

慎用變長引數

慎用可變長度引數*args, **kwargs，原因如下：

• 使用過于靈活，變長引數意味著這個函式的簽名不夠清晰，存在多種呼叫方式，另外變長引數可能會破壞程式的健壯性，
• 如果一個函式的引數串列很長，雖然可以通過使用 *args 和 **kwargs 來簡化函式的定義，但通常這個函式可以有更好的實作方式，應該被重構，例如可以直接傳入元組和字典，

可變長引數適合在下列情況下使用：

• 為函式添加一個裝飾器
• 如果引數的數目不確定，可以考慮使用變長引數
• 用來實作函式的多型，或者在繼承情況下子類需要呼叫父類的某些方法的時候

深入理解 str() 和 repr() 的區別

函式 str() 和 repr() 都可以將 Python 中的物件轉換為字串，兩者的使用以及輸出都非常相似，有以下幾點區別：

• 兩者的目標不同：

  • str() 主要面向用戶，其目的是可讀性，回傳形式為用戶友好性和可讀性都較強的字串型別
  • 而 repr() 面向開發人員，其目的是準確性，其回傳值表示 Python 解釋器內部的含義，常用作 debug

• 在解釋器中直接輸入時默認呼叫 repr() 函式，而 print 則呼叫 str() 函式

• repr() 的回傳值一般可以用 eval() 函式來還原物件，通常有如下等式：obj == eval(repr(obj))

• 一般，類中都應該定義 __repr__() 方法，而 __str__() 方法則為可選，當可讀性比準確性更為重要的時候應該考慮定義 __str__() 方法，如果類中沒有定義 __str__() 方法，則默認會使用 __repr__() 方法的結果來回傳物件的字串表示形式，用戶實作 __repr__() 方法的時，最好保證其回傳值可以用 eval() 方法使物件重新還原，

分清靜態方法和類方法的適用場景

靜態方法：

class C(object):
    @staticmethod
    def f(arg1, arg2, ...):

類方法：

class C(object):
    @classmethod
    def f(cls, arg1, arg2, ...):

都可以通過類名.方法名或者實體.方法名的形式來訪問，

其中，靜態方法沒有常規方法的特殊行為，如系結、非系結、隱式引數等規則，而類方法的呼叫使用類本身作為其隱含引數，但呼叫本身并不需要顯示提供該引數，

類方法

• 在呼叫的時候沒有顯式宣告 cls，但實際上類本身是作為隱藏引數傳入的
• 類方法可以判斷出自己是通過基類被呼叫，還是通過某個子類被呼叫
• 類方法通過子類呼叫時，可以回傳子類的屬性而非基類的屬性
• 類方法通過子類呼叫時，可以呼叫子類的其他類方法

靜態方法

• 既不跟特定的實體相關也不跟特定的類相關
• 靜態方法定義在類中的原因是，能夠更加有效地將代碼組織起來，從而使相關代碼的垂直距離更近，提高代碼的可維護性

文章首發于公眾號【Python與演算法之路】

標籤：Python

上一篇：撰寫高質量Python程式（二）編程慣用法

下一篇：qt建的QMainwindow為什么關閉，放大，縮小按鈕沒有呢？