編寫高質量Python程序（二）編程慣用法

本系列文章爲《編寫高質量代碼——改善Python程序的91個建議》的精煉彙總。

利用assert語句發現問題

assert語句的基本語法以下：

assert expression1 ["," expression2]

其中，expression1是判斷語句，會返回True或False，當返回False時會引起AssertionError。[]中的內容表示是可選的，用來傳遞具體的異常信息。

>>> a = 1
>>> b = 2
>>> assert a == b, "a equals b"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: a equals b

利用assert語句來發現程序中的問題。斷言（assert）在不少語言中都存在，主要爲調試程序服務，可以快速方便檢查程序的異常或不恰當的輸入。

要注意的是使用assert是有代價的，它會對性能產生必定的影響，能夠不用盡可能不用。

兩個變量進行數據交換

變量進行數據交換值時，不推薦使用中間變量。

# 交換x,y
# 使用中間變量
temp = x
x = y
y = temp
# 不使用中間變量
x, y = y, x

第二種方法在內存中執行的順序以下：

• 先計算右邊的表達式 y, x，在內存中建立元組（y, x），其標示符合值分別爲 y、x 及其對應的值，其中 y 和 x 是在初始化時已經存在於內存中的對象。
• 經過解包操做（unpacking），元組第一標識符（爲 y）分配給左邊第一個元素（此時爲 x），元組第二個標識符（爲 x）分配給左邊第二個元素（爲 y），從而達到實現 x、y 值交換的目的。

充分利用Lazy evaluation的特性

Lazy evaluation 常被譯爲「延遲計算」或「惰性計算」，指的是僅僅在真正須要執行的時候才計算表達式的值。

• 避免沒必要要的計算，帶來性能上的提高。對於 Python 中的條件表達式 if x and y，在 x 爲 false 的狀況下 y 表達式的值將再也不計算。而對於 if x or y，當 x 的值爲 true 的時候將直接返回，再也不計算 y 的值。
• 節省空間，使得無限循環的數據結構成爲可能。Python 中最典型的使用延遲計算的例子就是生成器表達式了。好比斐波那契：

def fib():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b
from itertools import islice
print(list(islice(fib(), 5)))

不推薦使用type來進行類型檢查

內建函數 type(object) 用於返回當前對象的類型。能夠經過與 Python 自帶模塊 types 中所定義的名稱進行比較，根據其返回值肯定變量類型是否符合要求。

全部基本類型對應的名稱均可以在 types 模塊中找到，然而使用 type() 函數並不適合用來進行變量類型檢查。這是由於：

• 基於內建類型擴展的用戶自定義類型，type 函數並不能準確返回結果
• 在古典類中，全部類的實例的 type 值都相等

解決方法是，若是類型有對應的工廠函數，可使用工廠函數對類型作相應轉換，不然可使用 isinstance() 函數來檢測。

isinstance(object, classinfo)

其中，classinfo 能夠爲直接或間接類名、基本類型名稱或者由它們組成的元組，該函數在 classinfo 參數錯誤的狀況下會拋出 TypeError 異常。

# isinstance 基本用法舉例以下：
>>> isinstance(2, float)
False
>>> isinstance("a", (str, unicode))
True
>>> isinstance((2, 3), (str, list, tuple)) # 支持多種類型列表
True

警戒eval()的安全漏洞

Python中eval()函數將字符串當成有效的表達式來求值並返回計算結果。其函數聲明以下：

eval(expression[, globals[, locals]])

其中，參數 globals 爲字典形式，locals 爲任何映射對象，它們分別表示全局和局部命名空間。若是傳入 globals 參數的字典中缺乏 builtins 的時候，當前的全局命名空間將做爲 globals 參數輸入而且在表達式計算以前被解析。locals 參數默認與 globals 相同，若是二者都省略的話，表達式將在 eval() 調用的環境中執行。

eval 存在安全漏洞，一個簡單的例子：

import sys
from math import *
def ExpCalcBot(string):
    try:
        print "Your answer is", eval(user_func) # 計算輸入的值
    except NameError:
        print "The expression you enter is not valid"
print 'Hi, I am ExpCalcBot. please input your expression or enter e to end'
inputstr = ''
while True:
    print 'Please enter a number or operation. Enter c to complete. :'
    inputstr = raw_input()
    if inputstr == str('e'): # 遇到輸入爲 e 的時候退出
        sys.exit()
    elif repr(inputstr) != repr(''):
        ExpCalcBot(inputstr)
        inputstr = ''

因爲網絡環境下運行它的用戶並不是都是可信任的，好比輸入 __import__("os").system("dir") ，會顯示當前目錄下的全部文件列表；若是惡意輸入__import__("os").system("del * /Q")，會致使當前目錄下的全部文件都被刪除了，而這一切沒有任何提示。

在 globals 參數中禁止全局命名空間的訪問：

def ExpCalcBot(string):
    try:
        math_fun_list = ["acos", "asin", "atan", "cos", "e", "log", "log10", "pi", "pow", "sin", "sqrt", "tan"]
        math_fun_dict = dict([(k, globals().get(k)) for k in math_fun_list]) # 造成能夠訪問的函數的字典
        print "Your name is", eval(string, {"__builtins__": None}, math_fun_dict)
    except NameError:
        print "The expression you enter is not valid"

再次進行惡意輸入：[c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == "Quitter"][0](0)()，

# ().__class__.__bases__[0].__subclasses__() 用來顯示 object 類的全部子類。類 Quitter 與 "quit" 功能綁定，所以上面的輸入會致使程序退出。

對於有經驗的侵入者來講，他可能會有一系列強大的手段，使得 eval 能夠解釋和調用這些方法，帶來更大的破壞。此外，eval() 函數也給程序的調試帶來必定困難，要查看 eval() 裏面表達式具體的執行過程很難。所以在實際應用過程當中若是使用對象不是信任源，應該避免使用 eval，在須要使用 eval 的地方可用安全性更好的ast.literal_eval替代。

使用enumerate()獲取序列迭代的索引和值

使用函數 enumerate()，主要是爲了解決在循環中獲取索引以及對應值的問題。它具備必定的惰性（lazy），每次只在須要的時候纔會產生一個（index, item）對。函數簽名以下：

enumerate(sequence, start=0)

例子：

# 使用 enumerate() 獲取序列迭代的索引和值
li = ['a', 'b', 'c', 'd', 'e']
for i, e in enumerate(li):
    print("index:", i, "element:", e)

區分==與is的適用場景

• ==：用來檢驗兩個對象的值是否相等的。它實際調用內部 __eq__() 方法，所以 a == b 至關於 a.__eq__(b)。
• is：用來比較兩個對象在內存中是否擁有同一塊內存空間。僅當 x 和 y 是同一個對象的時候才返回 True，x is b 基本至關於 id(x) == id(y)。

== 操做符也是能夠被重載的，而 is 不能被重載。通常狀況下，若是 x is y 爲 True ， x == y 的值通常也爲 True（特殊狀況除外，如 NaN，a = float('NaN')，a is a 爲 True，a == a 爲 false）。

構建合理的包層次來管理模塊

每個 Python 文件均可以當作一個模塊（module），使用模塊能夠加強代碼的可維護性和可重用性。

包便是目錄，但與普通目錄不一樣，它除了包含常規的 Python 文件（也就是模塊）之外，還包含一個 __init__.py 文件，同時它容許嵌套。

Package/__init__.py
    Module1.py
    Module2.py
    Subpackage/__init__.py
        Module1.py
        Module2.py

包中的模塊能夠經過"."訪問符進行訪問，即"包名.模塊名"。有如下幾種導入方法：

• 直接導入一個包：

  import Package

• 導入子模塊或子包，包嵌套的狀況下能夠進行嵌套導入：

  from Package import Module1
  import Package.Module1
  from Package import Subpackage
  import Package.Subpackage
  from Package.Subpackage import Module1
  import Package.Subpackage.Module1

__init__.py 的做用：

• 使包和普通目錄區分
• 能夠在該文件中申明模塊級別的 import 語句，從而使其變成包級別可見

若是 __init__.py 文件爲空，當意圖使用 from Package import * 將包 Package 中全部的模塊導入當前名字空間時，並不能使得導入的模塊生效，這是由於不一樣平臺間的文件的命名規則不一樣，Python 解釋器並不能正確斷定模塊在對應的平臺該如何導入，所以僅僅執行 __init__.py 文件，若是要控制模塊的導入，則須要對 __init__.py 文件作修改。

__init__.py 文件還有一個做用就是經過在該文件中定義 __all__ 變量，控制須要導入的子包或者模塊。以後再運行 from ... import *，能夠看到 __all__ 變量中定義的模塊和包被導入當前名字空間。

包的使用可以帶來如下便利：

• 合理組織代碼，便於維護和使用
• 可以有效地避免名稱空間衝突

若是模塊包含的屬性和方法存在同名衝突，使用 import module 能夠有效地避免名稱衝突。在嵌套的包結構中，每個模塊都以其所在的完整路徑做爲其前綴，所以，即便名稱同樣，但因爲模塊所對應的其前綴不一樣，就不會產生衝突。

本篇文章由一文多發平臺ArtiPub自動發佈