本系列文章為《編寫高質量代碼——改善Python程式的91個建議》的精煉彙總。 利用assert語句發現問題 assert語句的基本語法如下： 其中， 是判斷語句，會返回True或False，當返回False時會引發AssertionError。 中的內容表示是可選的，用來傳遞具體的異常信息。 利用 ...
本系列文章為《編寫高質量代碼——改善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 可以有效地避免名稱衝突。在嵌套的包結構中，每一個模塊都以其所在的完整路徑作為其首碼，因此，即使名稱一樣，但由於模塊所對應的其首碼不同，就不會產生衝突。
文章首發於公眾號【Python與演算法之路】
