這個週末斷斷續續的閱讀完了《Effective Python之編寫高質量Python程式碼的59個有效方法》，感覺還不錯，具有很大的指導價值。下面將以最簡單的方式記錄這59條建議，並在大部分建議後面加上了說明和示例，文章篇幅大，請您提前備好瓜子和啤酒！

1. 用Pythonic方式思考

第一條：確認自己使用的Python版本

（1）有兩個版本的python處於活躍狀態，python2和python3

（2）有很多流行的Python執行時環境，CPython、Jython、IronPython以及PyPy等

（3）在開發專案時，應該優先考慮Python3

第二條：遵循PEP風格指南

　　PEP8是針對Python程式碼格式而編訂的風格指南，參考：http://www.python.org/dev/peps/pep-0008

（1）當編寫Python程式碼時，總是應該遵循PEP8風格指南

（2）當廣大Python開發者採用同一套程式碼風格，可以使專案更利於多人協作

（3）採用一致的風格來編寫程式碼，可以令後續的修改工作變得更為容易

第三條：瞭解bytes、str、與unicode的區別

（1）python2提供str個unicode,python3中修改為bytes和str，bytes為原始的8位值，str包含unicode字元，在進行編碼轉換時使用decode和encode方法

（2）從檔案中讀取二進位制資料，或向其中寫入二進位制資料時，總應該以‘rb’或‘wb’等二進位制模式來開啟檔案

第四條：用輔助函式來取代複雜的表示式

（1）開發者很容易過度運用Python的語法特性，從而寫出那種特別複雜並且難以理解的單行表示式

（2）請把複雜的表示式移入輔助函式中，如果要反覆使用相同的邏輯，那更應該這麼做

第五條：瞭解切割序列的方法

（1）不要寫多餘的程式碼：當start索引為0，或end索引為序列長度時，應將其省略a[:]

（2）切片操作不會計較start與end索引是否越界，者使得我們很容易就能從序列的前端或後端開始，對其進行範圍固定的切片操作，a[:20]或a[-20:]

（3）對list賦值的時候，如果使用切片操作，就會把原列表中處在相關範圍內的值替換成新值，即便它們的長度不同也依然可以替換

第六條：在單詞切片操作內，不要同時指導start、end和step

（1）這條的目的主要是怕程式碼難以閱讀，作者建議將其拆解為兩條賦值語句，一條做範圍切割，另一條做步進切割

（2）注意：使用[::-1]時會出現不符合預期的錯誤，看下面的例子

msg = '謝謝'
print('msg:',msg)
x = msg.encode('utf-8')
y = x.decode('utf-8')
print('y:',y)
z=x[::-1].decode('utf-8')
print('z:', z)

　　輸出：

第七條：用列表推導式來取代map和filter

（1）列表推導要比內建的map和filter函式清晰，因為它無需額外編寫lambda表示式

（2）字典與集合也支援推導表示式

第八條：不要使用含有兩個以上表達式的列表推導式

第九條：用生成器表示式來改寫資料量較大的列表推導式

（1）列表推導式的缺點

　　在推導過程中，對於輸入序列中的每個值來說，可能都要建立僅含一項元素的全新列表，當輸入的資料比較少時，不會出現問題，但如果輸入資料非常多，那麼可能會消耗大量記憶體，並導致程式崩潰，面對這種情況，python提供了生成器表示式，它是列表推導和生成器的一種泛化，生成器表示式在執行的時候，並不會把整個輸出序列呈現出來，而是會估值為迭代器。

　　把實現列表推導式所用的那種寫法放在一對園括號中，就構成了生成器表示式

numbers = [1,2,3,4,5,6,7,8]
li = (i for i in numbers)
print(li)

>>>> <generator object <genexpr> at 0x0000022E7E372228>

（2）串在一起的生成器表示式執行速度很快

第十條：儘量用enumerate取代range

（1）儘量使用enumerate來改寫那種將range與下表訪問結合的序列遍歷程式碼

（2）可以給enumerate提供第二個引數，以指定開始計數器時所用的值，預設為0

color = ['red','black','write','green']
#range方法
for i in range(len(color)):
    print(i,color[i])

#enumrate方法
for i,value in enumerate(color):
    print(i,value)

第11條：用zip函式同時遍歷兩個迭代器

（1）內建的zip函式可以平行地遍歷多個迭代器

（2）Python3中的zip相當於生成器，會在遍歷過程中逐次產生元組，而python2中的zip則是直接把這些元組完全生成好，並一次性地返回整份列表、

（3）如果提供的迭代器長度不等，那麼zip就會自動提前終止

attr = ['name','age','sex']
values = ['zhangsan',18,'man']

people = zip(attr,values)
for p in people:
    print(p)

第12條：不要在for和while迴圈後面寫else塊

（1）python提供了一種很多程式語言都不支援的功能，那就是在迴圈內部的語句塊後面直接編寫else塊

for i in range(3):
    print('loop %d' %(i))
else:
    print('else block!')

　　上面的寫法很容易讓人產生誤解：如果迴圈沒有正常執行完，那就執行else,實際上剛好相反

（2）不要再迴圈後面使用else，因為這種寫法既不直觀，又容易讓人誤解

第13條：合理利用try/except/else/finally結構中的每個程式碼塊

try:
    #執行程式碼
except:
    #出現異常
else:
    #可以縮減try中程式碼，再沒有發生異常時執行
finally:
    #處理釋放操作

2. 函式

第14條：儘量用異常來表示特殊情況，而不要返回None

（1）用None這個返回值來表示特殊意義的函式，很容易使呼叫者犯錯，因為None和0及空字串之類的值，在表示式裡都會貝評估為False

（2）函式在遇到特殊情況時應該丟擲異常，而不是返回None，呼叫者看到該函式的文件中所描述的異常之後，應該會編寫相應的程式碼來處理它們

第15條：瞭解如何在閉包裡使用外圍作用域中的變數

（1）理解什麼是閉包

　　閉包是一種定義在某個作用域中的函式，這種函式引用了那個作用域中的變數

（2）表示式在引用變數時，python直譯器遍歷各作用域的順序：

　　a. 當前函式的作用域

　　b. 任何外圍作用域（例如：包含當前函式的其他函式）

　　c. 包含當前程式碼的那個模組的作用域（也叫全域性作用域）

　　d. 內建作用域（也即是包含len及str等函式的那個作用域）

　　e. 如果上賣弄這些地方都沒有定義過名稱相符的變數，那麼就丟擲NameError異常

（3）賦值操作時，python直譯器規則

　　給變數賦值時，如果當前作用域內已經定義了這個變數，那麼該變數就會具備新值，若當前作用域內沒有這個變數，python則會把這次賦值視為對該變數的定義

（4）nonlocal

　　nonlocal的意思：給相關變數賦值的時候，應該在上層作用域中查詢該變數，nomlocal的唯一限制在於，它不能延申到模組級別，這是為了防止它汙染全域性作用域

（5）global

　　global用來表示對該變數的賦值操作，將會直接修改模組作用域的那個變數

第16條：考慮用生成器來改寫直接返回列表的函式

　　參考第九條

第17條：在引數上面迭代時，要多加小心

（1）函式在輸入的引數上面多次迭代時要當心，如果引數是迭代物件，那麼可能會導致奇怪的行為並錯失某些值

　　看下面兩個例子：

　　例1：

def normalize(numbers):
    total = sum(numbers)
    print('total:',total)
    print('numbers:',numbers)
    result = []
    for value in numbers:
        percent = 100 * value / total
        result.append(percent)
    return result
    
numbers = [15,35,80]
print(normalize(numbers))

　　輸出：

　　例2：將numbers換成生成器

def fun():
    li = [15,35,80]
    for i in li:
        yield i
        
print(normalize(fun()))

　　輸出：

　　原因：迭代器只產生一輪結果，在丟擲過StopIteration異常的迭代器或生成器上面繼續迭代第二輪，是不會有結果的。

（2）python的迭代器協議，描述了容器和迭代器應該如何於iter和next內建函式、for迴圈及相關表示式互相配合

（3）想判斷某個值是迭代器還是容器，可以拿該值為引數，兩次呼叫iter函式，若結果相同，則是迭代器，呼叫內建的next函式，即可令該迭代器前進一步

if iter(numbers) is iter(numbers):
    raise TypeError('Must supply a container')

第18條：用數量可變的位置引數減少視覺雜訊

（1）在def語句中使用*args，即可令函式接收數量可變的位置引數

（2）呼叫函式時，可以採用*操作符，把序列中的元素當成位置引數，傳給該函式

（3）對生成器使用*操作符，可能導致程式耗盡記憶體並崩潰，所以只有當我們能夠確定輸入的引數個數比較少時，才應該令函式接受*arg式的變長引數

（4）在已經接收*args引數的函式上面繼續新增位置引數，可能會產生難以排查的錯誤

第19條：用關鍵字引數來表達可選的行為

（1）函式引數可以按位置或關鍵字來指定

（2）只使用位置引數來呼叫函式，可能會導致這些引數值的含義不夠明確，而關鍵字引數則能夠闡明每個引數的意圖

（3）該函式新增新的行為時，可以使用帶預設值的關鍵字引數，以便與原有的函式呼叫程式碼保持相容

（4）可選的關鍵字引數總是應該以關鍵字形式來指定，而不應該以位置引數來指定

第20條：用None和文件字串來描述具有動態預設值的引數

import datetime
import time
def log(msg,when=datetime.datetime.now()):
    print('%s:%s' %(when,msg))
    
log('hi,first')
time.sleep(1)
log('hi,second')

輸出：

　　兩次顯示的時間一樣，這是因為datetime.now()只執行了一次，也就是它只在函式定義的時候執行了一次，引數的預設值，會在每個模組載入進來的時候求出，而很多模組都在程式啟動時載入。我們可以將上面的函式改成：

import datetime
import time
def log(msg,when=None):
    """
    arg when:datetime of when the message occurred
    """
    
    if when is None:
        when=datetime.datetime.now()
    print('%s:%s' %(when,msg))
    
log('hi,first')
time.sleep(1)
log('hi,second')

輸出：

（1）引數的預設值，只會在程式載入模組並讀到本函式定義時評估一次，對於{}或[]等動態的值，這可能導致奇怪的行為

（2）對於以動態值作為實際預設值的關鍵字引數來說，應該把形式上的預設值寫為None，並在函式的文件字串裡面描述該預設值所對應的實際行為

第21條：用只能以關鍵字形式指定的引數來確保程式碼明確

（1）關鍵字引數能夠使函式呼叫的意圖更加明確

（2）對於各引數之間很容易混淆的函式，可以宣告只能以關鍵字形式指定的引數，以確保呼叫者必須通過關鍵字來指定它們。對於接收多個Boolean標誌的函式更應該這樣做

3. 類與繼承

第22條：儘量用輔助類來維護程式的狀態，而不要用字典或元組

　　作者的意思是：如果我們使用字典或元組儲存程式的某部分資訊，但隨著需求的不斷變化，需要逐漸的修改之前定義好的字典或元組結構，會出現多次的巢狀，過分膨脹會導致程式碼出現問題，而且難以理解。遇到這樣的情況，我們可以把巢狀結構重構為類。

（1）不要使用包含其他字典的字典，也不要使用過長的元組

（2）如果容器中包含簡單而又不可變的資料，那麼可以先使用namedtupe來表述，待稍後有需要時，再修改為完整的類

　　注意：namedtuple類無法指定各引數的預設值，對於可選屬性比較多的資料來說，namedtuple用起來不方便

（3）儲存內部狀態的字典如果變得比較複雜，那就應該把這些程式碼拆分為多個輔組類

第23條：簡單的介面應該接收函式，而不是類的例項

（1）對於連線各種python元件的簡單介面來說，通常應該給其直接傳入函式，而不是先定義某個類，然後再傳入該類的例項

（2）Python種的函式和方法可以像類那麼引用，因此，它們與其他型別的物件一樣，也能夠放在表示式裡面

（3）通過名為__call__的特殊方法，可以使類的例項能夠像普通的Python函式那樣得到呼叫

第24條：以@classmethod形式的多型去通用的構建物件

　　在python種，不僅物件支援多型，類也支援多型

（1）在Python程式種，每個類只能有一個構造器，也就是__init__方法

（2）通過@classmethod機制，可以用一種與構造器相仿的方式來構造類的物件

（3）通過類方法機制，我們能夠以更加通用的方式來構建並拼接具體的子類

　　下面以實現一套MapReduce流程計算檔案行數為例來說明：

（1）思路

　　

（2）上程式碼

import threading
import os

class InputData:
    def read(self):
        raise NotImplementedError

class PathInputData(InputData):
    def __init__(self,path):
        super().__init__()
        self.path = path
    
    def read(self):
        return open(self.path).read()  
        
class worker:
    def __init__(self,input_data):
        self.input_data = input_data
        self.result = None
        
    def map(self):
        raise NotImplementedError
        
    def reduce(self):
        raise NotImplementedError
        
class LineCountWorker(worker):
    def map(self):
        data = self.input_data.read()
        self.result = data.count('\n')
        
    def reduce(self,other):
        self.result += other.result
        
def generate_inputs(data_dir):
    for name in os.listdir(data_dir):
        yield PathInputData(os.path.join(data_dir,name))
        
def create_workers(input_list):
    workers = []
    for input_data in input_list:
        workers.append(LineCountWorker(input_data))
    return workers
    
def execute(workers):
    threads = [threading.Thread(target=w.map) for w in workers]
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join()
        
    first,rest = workers[0],workers[1:]
    for worker in rest:
        first.reduce(worker)
    return first.result
    
def mapreduce(data_dir):
    inputs = generate_inputs(data_dir)
    workers = create_workers(inputs)
    return execute(workers)
    
if __name__ == "__main__":
    print(mapreduce('D:\mapreduce_test'))

MapReduce

　　上面的程式碼在拼接各種元件時顯得非常費力，下面重新使用@classmethod來改進下

import threading
import os

class InputData:
    def read(self):
        raise NotImplementedError
    
    @classmethod
    def generate_inputs(cls,data_dir):
        raise NotImplementedError

class PathInputData(InputData):
    def __init__(self,path):
        super().__init__()
        self.path = path
    
    def read(self):
        return open(self.path).read()  
        
    @classmethod
    def generate_inputs(cls,data_dir):
        for name in os.listdir(data_dir):
            yield cls(os.path.join(data_dir,name))
        
class worker:
    def __init__(self,input_data):
        self.input_data = input_data
        self.result = None
        
    def map(self):
        raise NotImplementedError
        
    def reduce(self):
        raise NotImplementedError
        
    @classmethod
    def create_workers(cls,input_list):
        workers = []
        for input_data in input_list:
            workers.append(cls(input_data))
        return workers
        
class LineCountWorker(worker):
    def map(self):
        data = self.input_data.read()
        self.result = data.count('\n')
        
    def reduce(self,other):
        self.result += other.result
        
def execute(workers):
    threads = [threading.Thread(target=w.map) for w in workers]
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join()
        
    first,rest = workers[0],workers[1:]
    for worker in rest:
        first.reduce(worker)
    return first.result
    
def mapreduce(data_dir):
    inputs = PathInputData.generate_inputs(data_dir)
    workers = LineCountWorker.create_workers(inputs)
    return execute(workers)
    
if __name__ == "__main__":
    print(mapreduce('D:\mapreduce_test'))

修改後的MapReduce

　　通過類方法實現多型機制，我們可以用更加通用的方式來構建並拼接具體的類

第25條：用super初始化父類

　　如果從python2開始詳細的介紹super使用方法需要很大的篇幅，這裡只介紹python3中的使用方法和MRO

（1）MRO即為方法解析順序，以標準的流程來安排超類之間的初始化順序，深度優先，從左至右，它也保證鑽石頂部那個公共基類的__init__方法只會執行一次

（2）python3中super的使用方法

　　python3提供了一種不帶引數的super呼叫方法，該方式的效果與用__class__和self來呼叫super相同

class A(Base):
    def __init__(self,value):
        super(__class__,self).__init__(value)
        
class A(Base):
    def __init__(self,value):
        super().__init__(value)

　　推薦使用上面兩種方法，python3可以在方法中通過__class__變數精確的引用當前類，而Python2中則沒有定義__class__方法

（3）總是應該使用內建的super函式來初始化父類

第26條：只在使用Mix-in元件製作工具類時進行多重繼承

　　python是面向物件的程式語言，它提供了一些內建的程式設計機制，使得開發者可以適當地實現多重繼承，但是，我們應該儘量避免多重繼承，若一定要使用，那就考慮編寫mix-in類，mix-in是一種小型的類，它只定義了其他類可能需要提供的一套附加方法，而不定義自己的 例項屬性，此外，它也不要求使用者呼叫自己的__init__函式

（1）能用mix-in元件實現的效果，就不要使用多重繼承來做

（2）將各功能實現為可插拔的mix-in元件，然後令相關的類繼承自己需要的那些元件，即可定製該類例項所具備的行為

（3）把簡單的行為封裝到mix-in元件裡，然後就可以用多個mix-in組合出複雜的行為了

第27條：多用public屬性，少用private屬性

　　python沒有從語法上嚴格保證private欄位的私密性，用簡單的話來說，我們都是成年人。

　　個人習慣：_XXX 單下劃代表protected；__XXX 雙下劃線開始的且不以_結尾表示private；__XXX__系統定義的屬性和方法

class People:
    __name="zhanglin"
    
    def __init__(self):
        self.__age = 16
    
print(People.__dict__)
p = People()
print(p.__dict__)

　　會發現__name和__age屬性名都發生了變化，都變成了（_類名+屬性名），只有在__XXX這種命名方式下才會發生變化，所以以這種方式作為偽私有說明

（1）python編譯器無法嚴格保證private欄位的私密性

（2）不要盲目地將屬性設為private，而是應該從一開始就做好規劃，並允許子類更多地訪問超類內部的api

（3）應該更多的使用protected屬性，並在文件中把這些欄位的合理用法告訴子類的開發者，而不是試圖用private屬性來限制子類訪問這些欄位

（4）只有當子類不受自己控制時，才可以考慮用private屬性來避免名稱衝突

第28條：繼承collections.abc以實現自定義的容器型別

　　collections.abc模組定義了一系列抽象基類，它們提供了每一種容器型別所應具備的常用方法，大家可以自己參考原始碼

__all__ = ["Awaitable", "Coroutine",
           "AsyncIterable", "AsyncIterator", "AsyncGenerator",
           "Hashable", "Iterable", "Iterator", "Generator", "Reversible",
           "Sized", "Container", "Callable", "Collection",
           "Set", "MutableSet",
           "Mapping", "MutableMapping",
           "MappingView", "KeysView", "ItemsView", "ValuesView",
           "Sequence", "MutableSequence",
           "ByteString",
           ]

（1）如果定製的子類比較簡單，那就可以直接從Python的容器型別（如list、dict）中繼承

（2）想正確實現自定義的容器型別，可能需要編寫大量的特殊方法

（3）編寫自制的容器型別時，可以從collections.abc模組的抽象基類中繼承，那些基類能夠確保我們的子類具備適當的介面及行為

4. 元類及屬性

第29條：用純屬性取代get和set方法

（1）編寫新類時，應該用簡單的public屬性來定義其介面，而不要手工實現set和get方法

（2）如果訪問物件的某個屬性，需要表現出特殊的行為，那就用@property來定義這種行為

　　比如下面的示例：成績必須在0-100範圍內

class Homework:
    def __init__(self):
        self.__grade = 0
        
    @property
    def grade(self):
        return self.__grade
        
    @grade.setter
    def grade(self,value):
        if not (0<=value<=100):
            raise ValueError('Grade must be between 0 and 100')
        self.__grade = value

（3）@property方法應該遵循最小驚訝原則，而不應該產生奇怪的副作用

（4）@property方法需要執行得迅速一些，緩慢或複雜的工作，應該放在普通的方法裡面

（5）@property的最大缺點在於和屬性相關的方法，只能在子類裡面共享，而與之無關的其他類都無法複用同一份實現程式碼

第30條：考慮用@property來代替屬性重構

　　作者的意思是：當我們需要遷移屬性時（也就是對屬性的需求發生變化的時候），我們只需要給本類新增新的功能，原來的那些呼叫程式碼都不需要改變，它在持續完善介面的過程中是一種重要的緩衝方案

（1）@property可以為現有的例項屬性新增新的功能

（2）可以用@properpy來逐步完善資料模型

（3）如果@property用的太過頻繁，那就應該考慮徹底重構該類並修改相關的呼叫程式碼

第31條：用描述符來改寫需要複用的@property方法

　　首先對描述符進行說明，先看下面的例子：

class Grade:
    def __init(self):
        self.__value = 0
        
    def __get__(self, instance, instance_type):
        return self.__value
    
    def __set__(self, instance, value):
        if not (0 <= value <= 100):
            raise ValueError('Grade must be between 0 and 100')
        self.__value = value
        
class Exam:
    math_grade = Grade()
    chinese_grade = Grade()
    science_grade = Grade()

if __name__ == "__main__":
    exam = Exam()
    exam.math_grade = 99
    
    exam1 = Exam()
    exam1.math_grade = 75
    print('exam.math_grade:',exam.math_grade, 'is wrong')
    print('exam1.math_grade:',exam1.math_grade, 'is right')

　　輸出：

　　會發現在兩個Exam例項上面分別操作math_grade時，導致了錯誤的結果，出現這種情況的原因是因為該math_grade屬性為Exam類的例項，為了解決這個問題，看下面的程式碼

class Grade:
    def __init__(self):
        self.__value = {}
        
    def __get__(self, instance, instance_type):
        if instance is None:
            return self
        return self.__value.get(instance,0)
    
    def __set__(self, instance, value):
        if not (0 <= value <= 100):
            raise ValueError('Grade must be between 0 and 100')
        self.__value[instance] = value
        
class Exam:
    math_grade = Grade()
    chinese_grade = Grade()
    science_grade = Grade()

if __name__ == "__main__":
    exam = Exam()
    exam.math_grade = 99
    exam1 = Exam()
    exam1.math_grade = 75
    print('exam.math_grade:',exam.math_grade, 'is wrong')
    print('exam1.math_grade:',exam1.math_grade, 'is right')

輸出：

　　上面這種實現方式很簡單，而且能夠正常運作，但它仍然有個問題，那就是會洩露記憶體，在程式的生命期內，對於傳給__set__方法的每個Exam例項來說，__values字典都會儲存指向該例項的一份引用，者就導致例項的引用計數無法降為0，從而使垃圾收集器無法將其收回。使用python的內建weakref模組，可解決上述問題。

class Grade:
    def __init(self):
        self.__value = weakref.WeakKeyDictionary()
        

（1）如果想複用@property方法及其驗證機制，那麼可以自己定義描述符

（2）WeakKeyDictionary可以保證描述符類不會洩露記憶體

（3）通過描述符協議來實現屬性的獲取和設定操作時，不要糾結於__getattribute__的方法具體運作細節

第32條：用__getattr__、__getattribute__和__setattr__實現按需生成的屬性

　　如果某個類定義了__getattr__，同時系統在該類物件的例項字典中又找不到待查詢的屬性，那麼就會呼叫這個方法

　　惰性訪問的概念：初次執行__getattr__的時候進行一些操作，把相關的屬性載入進來，以後再訪問該屬性時，只需從現有的結果中獲取即可　　

　　程式每次訪問物件的屬性時，Python系統都會呼叫__getattribute__，即使屬性字典裡面已經有了該屬性，也以讓會觸發__getattribute__方法

（1）通過__getattr__和__setattr__，我們可以用惰性的方式來載入並儲存物件的屬性

（2）要理解__getattr__和__getattribute__的區別：前者只會在待訪問的屬性缺失時觸發，，而後者則會在每次訪問屬性時觸發

（3）如果要在__getattribute__和__setattr__方法中訪問例項屬性，那麼應該直接通過super()來做，以避免無限遞迴

第33條：用元類來驗證子類

　　元類最簡單的一種用途，就是驗證某個類定義的是否正確，構建複雜的類體系時，我們可能需要確保類的風格協調一致，確保某些方法得到了覆寫，或是確保類屬性之間具備某些嚴格的關係。

　　下例判斷類屬性中是否含有name屬性：

#驗證某個類的定義是否正確
class Meta(type):
    def __new__(meta,name,bases,class_dict):
        print('class_dict:',class_dict)
        if not class_dict.get('name',None):   #判斷類屬性中是否含有name屬性
            raise AttributeError('must has name attribute')
        return type.__new__(meta,name,bases,class_dict)
            
class A(metaclass=Meta):
    def __init__(self):
        self.chinese_grade = 90
        self.math_grade = 99
        
if __name__ == '__main__':
    a = A()

　　輸出：

（1）通過元類，我們可以在生成子類物件之前，先驗證子類的定義是否合乎規範

（2）python系統把子類的整個class語句體處理完畢之後，就會呼叫其元類的__new__方法

第34條：用元類來註冊子類

　　元類還有一個用途就是在程式中自動註冊型別，對於需要反向查詢（reverse lookup）的場合，這種註冊操作很有用

　　看下面的例子:對物件進行序列化和反序列化

import json

register = {}
class Meta(type):
    def __new__(meta,name,bases,attr_dic):
        cls = type.__new__(meta,name,bases,attr_dic)
        print('create class in Meta:', cls)
        register[cls.__name__] = cls
        return cls
        
class Serializable(metaclass=Meta):
    def __init__(self,*args):
        self.args = args
        
    def serialize(self):
        return json.dumps({'class':self.__class__.__name__, 'args':self.args})
        
    def deserilize(self,json_data):
        json_dict = json.loads(json_data)
        classname = json_dict['class']
        args = json_dict['args']
        return register[classname](*args)
        
class Point2D(Serializable):
    def __init__(self,x,y):
        super().__init__(x,y)
        self.x = x
        self.y = y
        
    def add(self):
        return self.x + self.y
        
if __name__ == "__main__":
    p = Point2D(2,5)
    data = p.serialize()
    print('serialize_data:',data)
    new_point2d = p.deserilize(data)
    print('new_point2d:',new_point2d)
    print(new_point2d.add())

　　輸出：

（1）通過元類來實現類的註冊，可以確保所有子類就都不會洩露，從而避免後續的錯誤

第35條：用元類來註解類的屬性

（1）藉助元類，我們可以在某個類完全定義好之前，率先修改該類的屬性

（2）描述符與元類能夠有效的組合起來，以便對某種行為做出修飾，或在程式執行時探查相關資訊

（3）如果把元類與描述符相結合，那就可以在不使用weakref模組的前提下避免記憶體洩漏

5. 併發與並行

　　併發和並行的關鍵區別在於能不能提速，若是並行，則總任務的執行時間會減半，若是併發，那麼即使可以看似平行的方式分別執行多條路徑，依然不會使總任務的執行速度得到提升，用Python語言編寫併發程式，是比較容易的，通過系統呼叫、子程序和C語言擴充套件等機制，也可以用Python平行地處理一些事務，但是，要想使併發式的python程式碼以真正平行的方式來執行，卻相當困難。

　　可以先閱讀我之前的部落格，相信會有幫組：python究竟要不要使用多執行緒

第36條：用subprocess模組來管理子程序

　　在多年的發展過程中，Python演化出了多種執行子程序的方式，其中包括popen、popen2和os.exec*等，然而，對於至今的Python來說，最好且最簡單的子程序管理模組，應該是內建的subprocess模組

第37條：可以用執行緒來執行阻塞式I/O，但不要用它做平行計算

（1）因為受全域性解釋鎖（GIL）的限制，所以多條Python執行緒不能在多個CPU核心上面平行地執行位元組碼

（2）儘管受制於GIL，但是python的多執行緒功能依然很有用，它可以輕鬆地模擬出同一時刻執行多項任務的效果

（3）通過python執行緒，我們可以平行地執行多個系統呼叫，這使得程式能夠在執行阻塞式I/O操作的同時，執行一些運算操作

第38條：線上程中使用Lock來防止資料競爭

class LockingCounter:
    def __init__(self):
        self.lock = threading.Lock()
        self.count = 0
        
    def increment(self, offset):
        with self.lock:
            self.count += offset

第39條：用Queue來協調各執行緒之間的工作

　　作者舉了一個照片處理系統的例子：

　　需求：該系統從數碼相機裡面持續獲取照片、調整其尺寸，並將其新增到網路相簿中。

　　實現：使用三階段的管線實現，需要4個自定義的deque訊息佇列，第一階段獲取新照片，第二階段把下載好的照片傳給縮放函式，第三階段把縮放後的照片交給上傳函式

　　問題：該程式雖然可以正常執行，但是每個階段的工作函式都會有差別，這使得前一階段可能會拖慢後一階段的進度，從而令整條管線遲滯，後一階段會在其迴圈語句中，反覆查詢輸入佇列，以求獲取新的任務，而任務卻遲遲未到達，這將令後一階段陷入飢餓，會白白浪費CPU時間，效率特低

　　內建的queue模組的Queue類可以解決上述問題，因為其get方法會持續阻塞，直到有新的資料加入

import threading
from queue import Queue

class ClosableQueue(Queue):
    SENTINEL = object()
    
    def close(self):
        self.put(SENTINEL)
        
    def __iter__(self):
        while True:
            item = self.get()
            try:
                if item is self.SENTINEL:
                    return 
                yield item
            finally:
                self.task_done()
                
class StoppabelWoker(threading.Thread):
    def __init__(self,func,in_queue,out_queue):
        self.func = func
        self.in_queue = in_queue
        self.out_queue = out_queue
    
    def run(self):
        for item in self.in_queue:
            result = self.func(item)
            self.out_queue.put(result)

（1）管線是一種優秀的任務處理方式，它可以把處理流程劃分未若干個階段，並使用多條python執行緒來同時執行這些任務

（2）構建併發式的管線時，要注意許多問題，其中包括：如何防止某個階段陷入持續等待的狀態之中，如何停止工作執行緒，以及如何防止記憶體膨脹等

（3）Queue類所提供的機制，可以cedilla解決上述問題，它具備阻塞式的佇列操作，能夠指定緩衝區的尺寸，而且還支援join方法，這使得開發者可以構建出健壯的管線

第40條：考慮用協程來併發地執行多個函式

（1）協程提供了一種有效的方式，令程式看上去好像能夠同時執行大量函式

（2）對於生成器內的yield表示式來說，外部程式碼通過send方法傳給生成器的那個值就是該表示式所要具備的值

（3）協程是一種強大的工具，它可以把程式的核心邏輯，與程式同外部環境互動時所使用的程式碼相隔離

第41條：考慮用concurrent.futures來實現真正的平行計算

　　參考之前的部落格：網路爬蟲必備知識之concurrent.futures庫

6. 內建模組

第42條：用functools.wrap定義函式修飾器

　　為了維護函式的介面，修飾之後的函式，必須保留原函式的某些標準Python屬性，例如__name__和__module__，這個時候我們需要使用functools.wraps來確保修飾後函式具備正確的行為

第43條：考慮以contextlib和with語句來改寫可複用的try/finally程式碼

（1）可以用with語句來改寫try/finally塊中的邏輯，以提升複用程度，並使程式碼更加整潔

import threading

lock = threading.Lock()
lock.acquier()
try:
    print("lock is held")
finally:
    lock.release()

　　可以直接使用下面的語法：

import threading

lock = threading.Lock()
with lock:
    print("lock is held")

（2）內建的contextlib模組提供了名叫為contextmanager的修飾器，開發者只需要用它來修飾自己的函式，即可令該函式支援with語句

from contextlib import contextmanager

@contextmanager
def file_open(path):
    ''' file open test'''
    try:
        fp = open(path,"wb")
        yield fp
    except OSError:
        print("We had an error!")
    finally:
        print("Closing file")
        fp.close()

if __name__ == "__main__": 
    with file_open("contextlibtest.txt") as fp:
        fp.write("Testing context managers".encode("utf-8"))

（3）情景管理器可以通過yield語句向with語句返回一個值，此值會賦給由as關鍵字所指定的變數

第44條：用copyreg實現可靠pickle操作

（1）內建的pickle模組，只適合用來彼此信任的程式之間，對相關物件執行序列化和反序列化操作

（2）如果用法比較複雜，那麼pickle模組的功能可能就會出現問題，我們可以用內建的copyreg模組和pickle結合起來使用，以便為舊資料新增缺失的屬性值、進行類的版本管理、並給序列化之後的資料提供固定的引入路徑

第45條：應該用datetime模組來處理本地時間，而不是time模組

（1）不要用time模組在不同時區之間進行轉換

（2）如果要在不同時區之間，可靠地執行轉換操作，那就應該把內建的datetime模組與開發者社群提供的pytz模組打起來使用

（3）開發者總是應該先把時間表示為UTC格式，然後對其執行各種轉換操作，最後再把它轉回本地時間

第46條：使用內建演算法和資料結構

（1）雙向佇列 collections.deque

（2）有序字典 dollections.OrderDict

（3）帶有預設值的有序字典 collections.defaultdict

（4）堆佇列（優先順序佇列）heapq.heap

（5）二分查詢 bisect模組中的bisect_left函式等提供了高效的二分折半搜尋演算法

（6）與迭代器有關的工具 itertools模組

第47條：在重視精度的場合，應該使用decimal

（1）decimal模組中的Decimal類預設提供28個小數位，以進行定點數字運算，還可以按照開發射所要求的精度及四捨五入

第48條：學會安裝由Python開發者社群所構建的模組

7. 協作開發

第49條：為每個函式、類和模組編寫文件字串

第50條：用包來安排模組，並提供穩固的API

（1）只要把__init__.py檔案放入含有其他原始檔的目錄裡，就可以將該目錄定義為包，目錄中的檔案，都將成為包的子模組，該包的目錄下面，也可以含有其他的包

（2）把外界可見的名稱，列在名為__all__的特殊屬性裡，即可為包提供一套明確的API

第51條：為自編的模組定義根異常，以便呼叫者與API相隔離

　　意思就是單獨用個模組提供各種異常API

第52條：用適當的方式打破迴圈依賴關係

（1）調整引入順序

（2）先引入、再配置、最後執行

　　只在模組中給出函式、類和常量的定義，而不要在引入的時候真正去執行那些函式

（3）動態引入：在函式或方法內部使用import語句

第53條：用虛擬環境隔離專案，並重建其依賴關係

　　參考之前的部落格：Python之用虛擬環境隔離專案，並重建依賴關係

8. 部署

第54條：考慮用模組級別的程式碼來配置不同的部署環境

（1）可以根據外部條件來決定模組的內容，例如，通過sys和os模組來查詢宿主作業系統的特性，並以此來定義本模組中的相關結構

第55條：通過repr字串來輸出除錯資訊

第56條：通過unittest來測試全部程式碼

　　這個在後面會單獨寫篇部落格對unittest單元測試模組進行詳細說明

第57條：考慮用pdb實現互動除錯

第58條：先分析效能，然後再優化

（1）優化python程式之前，一定要先分析其效能，因為python程式的效能瓶頸通常很難直接觀察出來

（2）做效能分析時，應該使用cProfile模組，而不要使用profile模組，因為前者能夠給出更為精確的效能分析資料

第59條：用tracemalloc來掌握記憶體的使用及洩露情況

　　在Python的預設實現中，也就是Cpython中，記憶體管理是通過引用計數來處理的，另外，Cpython還內建了迴圈檢測器，使得垃圾回收機制能夠把那些自我引用的物件清除掉

（1）使用內建的gc模組進行查詢，列出垃圾收集器當前所知道的每個物件，該方法相當笨拙

（2）python3.4提供了內建模組tracemalloc可以打印出Python系統在執行每一個分配記憶體操作時所具備的完整堆疊資訊

文章到這裡就全部結束了，感謝您這麼有耐心的閱讀！