學習筆記三：改善Python程序的91個建議

01-28

許久沒更新，四月份學校又加了幾門課程，我自己又去報名了駕校，時間沒有安排過來。不知不覺已經五月了，希望一切能夠回歸正軌。同時又給自己加了兩項任務：夜跑和寫日記，望能夠堅持下去。有始有終，今天更新完這個學習筆記系列，主要的原因是知乎不支持 markdown，再次吐槽！

第 4 章庫

建議 41：使用 argparse 處理命令行參數

Python 標準庫中有幾種關於處理命令行的方案：getopt、optparse、argparse。

現階段最好用的參數處理是argparse：

import argparsenparse = argparse.ArgumentParser()nparse.add_argument(-o, --output)nparse.add_argument(-v, dest=verbose, action=store_true)nargs = parser.parse_args()n

關於命令行參數，我記得有個第三方庫超好用，好久貼個教程出來。

建議 42：使用 pandas 處理大型 CSV 文件

CSV 作為一種逗號分隔型值的純文本格式文件，常用於資料庫數據的導入導出，數據分析中記錄的存儲。Python 中的 csv 模塊提供了對 CSV 的支持。

列出一些常用的 API：

reader(csvfile[, dialect=excel][, fmtparam]) # 讀取一個 csv 文件，返回一個 reader 對象ncsv.writer(csvfile, dialect=excel, **fmtparams) # 寫入 csv 文件ncsv.DictWriter(csvfile, fieldnames, restval=, extrasaction=raise, dialect=excel)n

當然，處理 CSV 還有更好的選擇，那就是大名鼎鼎的 Pandas，它提供兩種基本的數據結構：Series 和 DataFrame。這裡有個 Pandas 的教程，值得一看。

建議 43：一般情況下使用 ElementTree 解析 XML

給一個較好的學習教程，下面直接看例子吧：

count = 0nfor event, elem in ET.iterparse(test.xml):n if event == end:n if elem.tag == userid:n count += 1n elem.clear()nprint(count)n

建議 44：理解模塊 pickle 優劣

pickle 是較為通用的序列化模塊，其中兩個主要的函數dump()和load()分別用來進行對象的序列化和反序列化：

pickle.dump(obj, file[, protocol])
load(file)

In [1]: import picklenIn [2]: data = {name: Python, type: Language, version: 3.5.2}nIn [3]: with open(pickle.dat, wb) as fp:n ...: pickle.dump(data, fp)n ...: nIn [4]: with open(pickle.dat, rb) as fp:n ...: out = pickle.load(fp)n ...: print(out)n ...: n{version: 3.5.2, name: Python, type: Language}n

它還有個C語言的實現 cPickle，性能較好。但 pickle 限制較多：比如不能保證原子性操作，存在安全問題，跨語言兼容性不好等。

建議 45：序列化的另一個不錯的選擇 JSON

這個應該不用多做介紹了吧，書中講得比較淺，又來放鏈接（逃...

建議 46：使用 traceback 獲取棧信息

當發生異常，開發人員往往需要看到現場信息，trackback 模塊可以滿足這個需求，先列幾個常用的：

traceback.print_exc() # 列印錯誤類型、值和具體的trace信息ntraceback.print_exception(type, value, traceback[, limit[, file]]) # 前三個參數的值可以從sys.exc_info()nraceback.print_exc([limit[, file]]) # 同上，不需要傳入那麼多參數ntraceback.format_exc([limit]) # 同 print_exc()，返回的是字元串ntraceback.extract_stack([file, [, limit]]) # 從當前棧中提取 trace 信息n

traceback 模塊獲取異常相關的數據是通過sys.exc_info()得到的，該函數返回異常類型type、異常value、調用和堆棧信息traceback組成的元組。

同時 inspect 模塊也提供了獲取 traceback 對象的介面。

建議 47：使用 logging 記錄日誌信息

僅僅將信息輸出到控制台是遠遠不夠的，更為常見的是使用日誌保存程序運行過程中的相關信息，如運行時間、描述信息以及錯誤或者異常發生時候的特定上下文信息。Python 提供 logging 模塊提供了日誌功能，將日誌分為 5 個級別：

Level使用情形DEBUG詳細的信息，在追蹤問題的時候使用INFO正常的信息WARNING一些不可預見的問題發生，或者將要發生，如磁碟空間低等，但不影響程序的運行ERROR由於某些嚴重的問題，程序中的一些功能受到影響CRITICAL嚴重的錯誤，或者程序本身不能夠繼續運行

之前完成過一個個人博客，總算對日誌消息有了一定的了解。總的來說，日誌消息是給程序員看的，在開發中，我們需要看到程序運行時的方方面面的情況，這時候給日誌分級就派上用場，其實日誌消息是由我們來決定它屬於哪一種類型。

logging.basicConfig([**kwargs]) 提供對日誌系統的基本配置：

格式描述filename指定 FileHandler 的文件名，而不是默認的 StreamHandlerfilemode打開文件的模式，同 open 函數中的同名參數，默認為 aformat輸出格式字元串datefmt日期格式level設置根 logger 的日誌級別stream指定 StreamHandler。這個參數若與 filename 衝突，忽略 stream

下面結合 traceback 和 logging 來記錄程序運行過程中的異常：

import tracebacknimport sysnimport loggingngList = ["a", "b", "c", "d", "e", "f", "g"]nlogging.basicConfig( # 配置日誌的輸出方式及格式n level = logging.DEBUG,n filename = "log.txt",n filemode = "w",n format = "%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s % (message)s",n)nndef f():n gList[5]n logging.info("[INFO]:calling method g() in f()") # 記錄正常的信息n return g()nndef g():n logging.info("[INFO]:calling method h() in g()")n return h()nndef h():n logging.info("[INFO]:Delete element in gList in h()")n del gList[2]n logging.info("[INFO]:calling method i() in h()")n return i()nndef i():n logging.info("[INFO]:Append element i to gList in i()")n gList.append("i")n print(gList[7])nnif __name__ == "__main__":n logging.debug("Information during calling f():")n try:n f()n except IndexError as ex:n print("Sorry, Exception occured, you accessed an element out of range")n # traceback.print_exc()n ty, tv, tb = sys.exc_info()n logging.error("[ERROR]: Sorry, Exception occured, you accessed an element out of range") # 記錄異常錯誤消息n logging.critical("object info:%s" % ex)n logging.critical("Error Type:{0}, Error Information:{1}".format(ty, tv)) # 記錄異常的類型和對應的值n logging.critical("".join(traceback.format_tb(tb))) # 記錄具體的 trace 信息n sys.exit(1)n

logging 模塊讓我們可以很方便地控制日誌信息，如loggging.disable()傳入一個日誌級別會禁用該級別或比級別更低的日誌消息，默認是全部禁用。大致我們常用的日誌記錄就這些了。

建議 48：使用 threading 模塊編寫多線程程序

之前學習廖老師的 Python3 教程的時候，關於線程有句話記得特別清楚：

多線程的並發在Python中就是一個美麗的夢。

由於 GIL 的存在，讓 Python 多線程編程在多核處理器中無法發揮優勢，但在一些使用場景下使用多線程仍然比較好，如等待外部資源返回，或建立反應靈活的用戶界面，或多用戶程序等。

Python3 提供了兩個模塊：_thread和threading。_thread提供了底層的多線程支持，使用比較複雜，下面我們重點說說threading。

Python 多線程支持用兩種方式來創建線程：一種通過繼承 Thread 類，重寫它的run()方法；另一種是創建一個 threading.Thread 對象，在它的初始化函數__init__()中將可調用對象作為參數傳入。

threading模塊中不僅有 Lock 指令鎖，RLock 可重入指令鎖，還支持條件變數 Condition、信號量 Semaphore、BoundedSemaphore 以及 Event 事件等。

下面有一個比較經典的例子來理解多線程：

import threadingnfrom time import ctime,sleepnndef music(func):n for i in range(2):n print("I was listening to %s. %s" % (func,ctime()))n sleep(1) # 程序休眠 1 秒nndef move(func):n for i in range(2):n print("I was at the %s! %s" % (func,ctime()))n sleep(5)nnthreads = []nt1 = threading.Thread(target=music,args=(愛情買賣,))nthreads.append(t1)nt2 = threading.Thread(target=move,args=(阿凡達,))nthreads.append(t2)nnif __name__ == __main__:n for t in threads:n t.setDaemon(True) # 聲明線程為守護線程n t.start()n #3n print("all over %s" % ctime())n

以下是運行結果：

I was listening to 愛情買賣. Tue Apr 4 17:57:02 2017nI was at the 阿凡達! Tue Apr 4 17:57:02 2017nall over Tue Apr 4 17:57:02 2017n

分析：threading 模塊支持線程守護，我們可以通過setDaemon()來設置線程的daemon屬性，當其屬性為True時，表明主線程的退出可以不用等待子線程完成，反之，daemon屬性為False時所有的非守護線程結束後主線程才會結束，那運行結果為：

I was listening to 愛情買賣. Tue Apr 4 18:05:26 2017nI was at the 阿凡達! Tue Apr 4 18:05:26 2017nall over Tue Apr 4 18:05:26 2017nI was listening to 愛情買賣. Tue Apr 4 18:05:27 2017nI was at the 阿凡達! Tue Apr 4 18:05:31 2017n

繼續修改代碼，當我們在#3處加入t.join()，此方法能夠阻塞當前上下文環境，直到調用該方法的線程終止或到達指定的 timeout，此時在運行程序：

I was listening to 愛情買賣. Tue Apr 4 18:08:15 2017nI was at the 阿凡達! Tue Apr 4 18:08:15 2017nI was listening to 愛情買賣. Tue Apr 4 18:08:16 2017nI was at the 阿凡達! Tue Apr 4 18:08:20 2017nall over Tue Apr 4 18:08:25 2017n

當我們把music函數的休眠時間改為 4 秒，再次運行程序：

I was listening to 愛情買賣. Tue Apr 4 18:11:16 2017nI was at the 阿凡達! Tue Apr 4 18:11:16 2017nI was listening to 愛情買賣. Tue Apr 4 18:11:20 2017nI was at the 阿凡達! Tue Apr 4 18:11:21 2017nall over Tue Apr 4 18:11:26 2017n

此時我們就可以發現多線程的威力了，music雖然增加了 3 秒，然而總的運行時間仍然為 10 秒。

建議 49：使用 Queue 使多線程編程更加安全

線程間的同步和互斥，線程間數據的共享等這些都是涉及線程安全要考慮的問題。縱然 Python 中提供了眾多的同步和互斥機制，如 mutex、condition、event 等，但同步和互斥本身就不是一個容易的話題，稍有不慎就會陷入死鎖狀態或者威脅線程安全。

如何保證線程安全呢？我們先來看看 Python 中的 Queue 模塊：

Queue.Queue(maxsize)：先進先出，maxsize 為隊列大小，其值為非正數的時候為無限循環隊列
Queue.LifoQueue(maxsize)：後進先出，相當於棧
Queue.PriorityQueue(maxsize)：優先順序隊列

以上隊列所支持的方法：

Queue.qsize()：返回近似的隊列大小。當該值 > 0 的時候並不保證並發執行的時候 get() 方法不被阻塞，同樣，對於 put() 方法有效。
Queue.empty()：隊列為空的時候返回 True，否則返回 False
Queue.full()：當設定了隊列大小的情況下，如果隊列滿則返回 True，否則返回 False
Queue.put(item[, block[, timeout]])：往隊列中添加元素 item，block 設置為 False 的時候，如果隊列滿則拋出 Full 異常。如果 block 設置為 True，timeout 為 None 的時候則會一直等待直到有空位置，否則會根據 timeout 的設定超時後拋出 Full 異常
Queue.put_nowait(item)：等於 put(item, False).block 設置為 False 的時候，如果隊列空則拋出 Empty 異常。如果 block 設置為 True、timeout 為 None 的時候則會一直等到有元素可用，否則會根據 timeout 的設定超時後拋出 Empty 異常
Queue.get([block[, timeout]])：從隊列中刪除元素並返回該元素的值
Queue.get_nowait()：等價於 get(False)
Queue.task_done()：發送信號表明入列任務已經完成，經常在消費者線程中用到
Queue.join()：阻塞直至隊列中所有的元素處理完畢

首先 Queue 中的隊列和 collections.deque 所表示的隊列並不一樣，前者用於不同線程之間的通信，內部實現了線程的鎖機制，後者是數據結構上的概念，支持 in 方法。

Queue 模塊實現了多個生產者多個消費者的隊列，當多線程之間需要信息安全的交換的時候特別有用，因此這個模塊實現了所需要的鎖原語，為 Python 多線程編程提供了有力的支持，它是線程安全的。

先來看一個簡單的例子：

import osnimport Queuenimport threadingnimport urllib2nnclass DownloadThread(threading.Thead):nn def __init__(self, queue):n threading.Thread.__init__(self)n self.queue = queuenn def run(self):n while True:n url = self.queue.get()n print({0} begin download {1}....format(self.name, url))n self.download_file(url)n self.queque.task_done()n print({0} download completed!!!.format(self.name))nn def download_file(self, url):n urlhandler = urllib2.urlopen(url)n fname = os.path.basename(url) + .htmln with open(fname, wb) as f:n while True:n chunk = urlhandler.read(1024)n if not chunk: breakn f.write(chunk)nnif __name__ == __main__:n urls = [http://wiki.python.org/moin/WebProgramming,n https://www.createspace.com/3611970,n http://wiki.python.org/moin/Documentationn ]n queue = Queue.Queue()n for i range(5):n t = DownloadThread(queue)n t.setDaemon(True)n t.start()n for url in urls:n queue.put(url)n queue.join()n

第 5 章設計模式

建議 50：利用模塊實現單例模式

滿足單例模式的 3 個需求：

只能有一個實例
必須自行創建這個實例
必須自行向整個系統提供這個實例

下面我們使用 Python 實現一個帶鎖的單例：

class Singleton(object):nn objs = {}n objs_locker = threading.Lock()nn def __new__(cls, *args, **kw):n if cls in cls.objs:n return cls.objs(cls)n cls.objs_locker.acquire()n try:n if cls in cls.objs:n return cls.objs(cls)n cls.objs[cls] = object.__new__(cls)n finally:n cls.objs_locker.release()n

當然這種方案也存在問題：

如果 Singleton 的子類重載了__new__()，會覆蓋或干擾 Singleton 類中__new__()的執行
如果子類有__init__()，那麼每次實例化該 Singleton 的時候，__init__()都會被調用，這顯然是不應該的

雖然以上問題都有解決方案，但讓單例的實現不夠 Pythonic。我們可以重新審視 Python 的語法元素，發現模塊採用的其實是天然的單例的實現方式：

所有的變數都會綁定到模塊
模塊只初始化一次
import 機制是線程安全的，保證了在並髮狀態下模塊也只是一個實例

# World.pynimport Sunnndef run():n while True:n Sun.rise()n Sun.set()nn# main.pynimport WorldnWorld.run()n

感覺這是最炫酷的單例模式。

建議 51：用 mixin 模式讓程序更加靈活

模板方法模式就是在一個方法中定義一個演算法的骨架，並將一些實現步驟延遲到子類中。模板方法可以使子類在不改變演算法結構的情況下，重新定義演算法中的某些步驟。

來看一個例子：

class People(object):n def make_tea(self):n teapot = self.get_teapot()n teapot.put_in_tea()n teapot.put_in_water()n return teapotn

顯然get_teapot()方法並不需要預先定義，也就是說我們的基類不需要預先申明抽象方法，子類只需要繼承 People 類並實現get_teapot()，這給調試代碼帶來了便利。但我們又想到如果一個子類 StreetPeople 描述的是正走在街上的人，那這個類將不會實現get_teapot()，一調用make_tea()就會產生找不到get_teapot()的 AttributeError，所以此時程序員應該立馬想到，隨著需求的增多，越來越多的 People 子類會選擇不喝茶而喝咖啡，或者是抽雪茄之類的，按照以上的思路，我們的代碼只會變得越發難以維護。

所以我們希望能夠動態生成不同的實例：

class UseSimpleTeapot(object):n def get_teapot(self):n return SimpleTeapot()nnclass UseKungfuTeapot(object):n def get_teapot(self):n return KungfuTeapot()nnclass OfficePeople(People, UseSimpleTeapot): passnnclass HomePeople(People, UseSimpleTeapot): passnnclass Boss(People, UseKungfuTeapot): passnndef simple_tea_people():n people = People()n people.__base__ += (UseSimpleTeapot,)n return peoplenndef coffee_people():n people = People()n people.__base__ += (UseCoffeepot,)nndef tea_and_coffee_people():n people = People()n people.__base__ += (UseSimpleTeapot, UserCoffeepot,)n return peoplenndef boss():n people = People()n people.__base__ += (KungfuTeapot, UseCoffeepot, )n return peoplen

以上代碼的原理在於每個類都有一個__bases__屬性，它是一個元組，用來存放所有的基類，作為動態語言，Python 中的基類可以在運行中可以動態改變。所以當我們向其中增加新的基類時，這個類就擁有了新的方法，這就是混入mixin。

利用這個技術我們可以在不修改代碼的情況下就可以完成需求：

import mixins # 把員工需求定義在 Mixin 中放在 mixins 模塊nndef staff():n people = People()n bases = []n for i in config.checked():n bases.append(getattr(maxins, i))n people.__base__ += tuple(bases)n return peoplen

建議 52：用發布訂閱模式實現松耦合

發布訂閱模式是一種編程模式，消息的發送者不會發送其消息給特定的接收者，而是將發布的消息分為不同的類別直接發布，並不關注訂閱者是誰。而訂閱者可以對一個或多個類別感興趣，且只接收感興趣的消息，並且不關注是哪個發布者發布的消息。要實現這個模式，就需要一個中間代理人 Broker，它維護著發布者和訂閱者的關係，訂閱者把感興趣的主題告訴它，而發布者的信息也通過它路由到各個訂閱者處。

from collections import defaultdictnroute_table = defaultdict(list)ndef sub(topic, callback):n if callback in route_table[topic]:n returnn route_table[topic].append(callback)nndef pub(topic, *args, **kw):n for func in route_table[topic]:n func(*args, **kw)n

將以上代碼放在 Broker.py 的模塊，省去了各種參數檢測、優先處理、取消訂閱的需求，只向我們展示發布訂閱模式的基礎實現：

import Brokerndef greeting(name):n print(Hello, {}.format(name))nBroker.sub(greet, greeting)nBroker.pub(greet, LaiYonghao)n

注意學習 blinker 和 python-message 兩個模塊

建議 53：用狀態模式美化代碼

所謂狀態模式，就是當一個對象的內在狀態改變時允許改變其行為，但這個對象看起來像是改變了其類。

def workday():n print(work hard)nndef weekend():n print(play harder)nnclass People(object): passnpeople = People()nwhile True:n for i in range(1, 8):n if i == 6:n people.day = weekendn if i == 1:n people.day = workdayn people.day()n

但上述例子還有缺陷：

查詢對象的當前狀態很麻煩
狀態切換時需要對原狀態做一些清掃工作，而對新狀態做初始化工作，因每個狀態需要做的事情不同，全部寫在切換狀態的代碼中必然重複

這時候我們可以使用 Python-state 來解決。

改寫之前的例子：

from state import curr, switch, stateful, State, behaviorn@statefulnclass People(object):n class Workday(State):n default = Truen @behavior # 相當於staticmethodn def day(self): # 這裡的self並不是Python的關鍵字，而是有助於我們理解狀態類的宿主是People的實例n print(work hard)n class Weekend(State):n @behaviorn def day(self):n print(play harder)npeople = People()nwhile True:n for i in range(1, 8):n if i == 6:n switch(people, People.Weekend)n if i == 1:n switch(people, People.Workday)n people.day()n

@statefule裝飾器重載了被修飾的類的__getattr__()從而使得 People 的實例能夠調用當前狀態類的方法，同時被修飾的類的實例是帶有狀態的，能夠使用curr()查詢當前狀態，也可以使用switch()進行狀態切換，默認的狀態是通過類定義的 default 屬性標識，default = True的類成為默認狀態。

狀態類 Workday 和 Weekend 繼承自 State 類，從其派生的子類可以使用__begin__和__end___狀態轉換協議，自定義進入和離開當前狀態時對宿主的初始化和清理工作。

下面是一個真實業務的例子：

@statefulnclass User(object):n class NeedSignin(State):n default = Truen @behaviorn def signin(self, user, pwd):n ...n switch(self, Player.Signin)n class Signin(State):n @behaviorn def move(self, dst): ...n @behaviorn def atk(self, other): ...n

第 6 章內部機制

建議 54：理解 built-in objects

Python 中一切皆對象，在新式類中，object 是所有內建類型的基類，用戶自定義的類可以繼承自 object 也可繼承自內建類型。

In [1]: class TestNewClass:n ...: __metaclass__ = typen ...: nnIn [2]: type(TestNewClass)nOut[2]: typennIn [3]: TestNewClass.__bases__nOut[3]: (object,)nnIn [4]: a = TestNewClass()nnIn [5]: type(a)nOut[5]: __main__.TestNewClassnnIn [6]: a.__class__nOut[6]: __main__.TestNewClassn

新式類支持 property 和描述符特性，作為新式類的祖先，Object 類還定義了一些特殊方法：__new__()、__init__()、__delattr__()、__getattribute__()、__setattr__()、__hash__()、__repr__()、__str__()等。

建議 55：init()不是構造方法

class A(object):n def __new__(cls, *args, **kw):n print(cls)n print(args)n print(kw)n print(----------)n instance = object.__new__(cls, *args, **kw)n print(instance)n def __init__(self, a, b):n print(init gets called)n print(self is {}.format(self))n self.a, self.b = a, bna1 = A(1, 2)nprint(a1.a)nprint(a1.b)n

運行結果：

<class __main__.A>n(1, 2)n{}n----------nTraceback (most recent call last):n File "test.py", line 19, in <module>n a1 = A(1, 2)n File "test.py", line 13, in __new__n instance = object.__new__(cls, *args, **kw)nTypeError: object() takes no parametersn

從結果中我們可以看出，程序輸出了__new__()調用所產生的輸出，並拋出了異常。於是我們知道，原來__new__()才是真正創建實例，是類的構造方法，而__init__()是在類的對象創建好之後進行變數的初始化。上面程序拋出異常是因為在__new__()中沒有顯式返回對象，a1此時為None，當去訪問實例屬性時就拋出了異常。

根據官方文檔，我們可以總結以下幾點：

object.__new__(cls[, args...])：其中 cls 代表類，args 為參數列表，為靜態方法
object.__init__(self[, args...])：其中 self 代表實例對象，args 為參數列表，為實例方法
控制實例創建的時候可使用 __new__() ，而控制實例初始化的時候使用 __init__()
__new__()需要返回類的對象，當返回類的對象時將會自動調用__init__()進行初始化，沒有對象返回，則__init__()不會被調用。__init__() 方法不需要顯示返回，默認為 None，否則會在運行時拋出 TypeError
但當子類繼承自不可變類型，如 str、int、unicode 或者 tuple 的時候，往往需要覆蓋__new__()
覆蓋 __new__() 和 __init__() 的時候這兩個方法的參數必須保持一致，如果不一致將導致異常

下面我們來總結需要覆蓋__new__()的幾種特殊情況：

當類繼承不可變類型且默認的 __new__() 方法不能滿足需求的時候
用來實現工廠模式或者單例模式或者進行元類編程，使用__new__()來控制對象創建
作為用來初始化的 __init__() 方法在多繼承的情況下，子類的 __init__()方法如果不顯式調用父類的 __init__() 方法，則父類的 __init__() 方法不會被調用；通過super(子類， self).__init__()顯式調用父類的初始化方法；對於多繼承的情況，我們可以通過迭代子類的 __bases__ 屬性中的內容來逐一調用父類的初始化方法

分別來看例子加深理解：

# 創建一個集合能夠將任何以空格隔開的字元串變為集合中的元素nclass UserSet(frozenset):n def __new__(cls, *args):n if args and isinstance(args[0], str):n args = (args[0].split(), ) + args[1:]n return super(UserSet, cls).__new__(cls, *args)nn# 一個工廠類根據傳入的參量決定創建出哪一種產品類的實例nclass Shape(object):n def __init__(object):n passn def draw(self):n passnnclass Triangle(Shape):n def __init__(self):n print("I am a triangle")n def draw(self):n print("I am drawing triangle")nnclass Rectangle(Shape):n def __init__(self):n print("I am a rectangle")n def draw(self):n print("I am drawing triangle")nnclass Trapezoid(Shape):n def __init__(self):n print("I am a trapezoid")n def draw(self):n print("I am drawing triangle")nnclass Diamond(Shape):n def __init__(self):n print("I am a diamond")n def draw(self):n print("I am drawing triangle")nnclass ShapeFactory(object):n shapes = {triangle: Triangle, rectangle: Rectangle, trapzoid: Trapezoid, diamond: Diamond}n def __new__(cls, name):n if name in ShapeFactory.shapes.keys():n print(creating a new shape {}.format(name))n return ShapeFactory.shapes[name]()n else:n print(creating a new shape {}.format(name))n return Shape()n

建議 56：理解名字查找機制

在 Python 中所謂的變數其實都是名字，這些名字指向一個或多個 Python 對象。這些名字都存在於一個表中（命名空間），我們稱之為局部變數，調用locals()可以查看：

>>> locals()n{__package__: None, __spec__: None, __loader__: <class _frozen_importlib.BuiltinImporter>, __doc__: None, __name__: __main__, __builtins__: <module builtins (built-in)>}n>>> globals()n{__loader__: <class _frozen_importlib.BuiltinImporter>, __builtins__: <module builtins (built-in)>, __package__: None, __doc__: None, __spec__: None, __name__: __main__}n

Python 中的作用域分為：

局部作用域: 一般來說函數的每次調用都會創建一個新的本地作用域, 擁有新的命名空間
全局作用域: 定義在 Python 模塊文件中的變數名擁有全局作用域, 即在一個文件的頂層的變數名僅在這個文件內可見
嵌套作用域: 多重函數嵌套時才會考慮, 即使使用 global 進行申明也不能達到目的, 其結果最終是在嵌套的函數所在的命名空間中創建了一個新的變數
內置作用域: 通過標準庫中的__builtin__實現的

當訪問一個變數的時候，其查找順序遵循變數解析機制 LEGB 法則，即依次搜索 4 個作用域：局部作用域、嵌套作用域、全局作用域以及內置作用域，並在第一個找到的地方停止搜尋，如果沒有搜到，則會拋出異常。

Python 3 中引入了 nonlocal 關鍵字:

def foo(x):n a = xn def bar():n nonlocal an b = a * 2n a = b + 1n print(a)n return barn

建議 57: 為什麼需要 self 參數

在類中當定義實例方法的時候需要將第一個參數顯式聲明為self, 而調用時不需要傳入該參數, 我們通過self.x訪問實例變數, self.m()訪問實例方法:

class SelfTest(object):n def __init__(self.name):n self.name = namen def showself(self):n print(self here is {}.format(self))n def display(self):n self.showself()n print(The name is: {}.format(self.name))nst = SelfTest(instance self)nst.display()nprint({}.format(st))n

運行結果:

self here is <__main__.SelfTest object at 0x7f440c53ba58>nThe name is: instance selfn<__main__.SelfTest object at 0x7f440c53ba58>n

從中可以發現, self 表示實例對象本身, 即 SelfTest 類的對象在內存中的地址. self 是對對象 st 本身的引用, 我們在調用實例方法時也可以直接傳入實例對象: SelfTest.display(st). 同時 self 或 cls 並不是 Python 的關鍵字, 可以替換成其它的名稱.

Python 中為什麼需要 self 呢:

借鑒了其他語言的特徵
Python 語言本身的動態性決定了使用 self 能夠帶來一定便利
在存在同名的局部變數以及實例變數的情況下使用 self 使得實例變數更容易被區分

Python 屬於一級對象語言, 我們有好幾種方法可以引用類方法:

A.__dict__["m"]nA.m.__func__n

Python 的哲學是：顯示優於隱式（Explicit is better than implicit）.

建議 58: 理解 MRO 與多繼承

古典類與新式類所採取的 MRO (Method Resolution Order, 方法解析順序) 的實現方式存在差異.

古典類是按照多繼承申明的順序形成繼承樹結構, 自頂向下採用深度優先的搜索順序. 而新式類採用的是 C3 MRO 搜索方法, 在新式類通過__mro__得到 MRO 的搜索順序, C3 MRO 的演算法描述如下:

假定，C1C2...CN 表示類 C1 到 CN 的序列，其中序列頭部元素（head）=C1，序列尾部（tail）定義 = C2...CN；
C 繼承的基類自左向右分別表示為 B1，B2...BN
L[C] 表示 C 的線性繼承關係，其中 L[object] = object。
演算法具體過程如下：
L[C(B1...BN)] = C + merge(L[B1] ... L[BN], B1 ... BN)
其中 merge 方法的計算規則如下：在 L[B1]...L[BN]，B1...BN 中，取 L[B1] 的 head，如果該元素不在 L[B2]...L[BN]，B1...BN 的尾部序列中，則添加該元素到 C 的線性繼承序列中，同時將該元素從所有列表中刪除（該頭元素也叫 good head），否則取 L[B2] 的 head。繼續相同的判斷，直到整個列表為空或者沒有辦法找到任何符合要求的頭元素（此時，將引發一個異常）。

菱形繼承是我們在多繼承設計的時候需要盡量避免的一個問題.

建議 59: 理解描述符機制

In [1]: class MyClass(object):n ...: class_attr = 1n ...: n# 每一個類都有一個__dict__屬性, 包含它的所有屬性nIn [2]: MyClass.__dict__nOut[2]:nmappingproxy({__dict__: <attribute __dict__ of MyClass objects>,n __doc__: None,n __module__: __main__,n __weakref__: <attribute __weakref__ of MyClass objects>,n class_attr: 1})nnIn [3]: my_instance = MyClass()n# 每一個實例也相應有一個實例屬性, 我們通過實例訪問一個屬性時,n# 它首先會嘗試在實例屬性中查找, 找不到會到類屬性中查找nIn [4]: my_instance.__dict__nOut[4]: {}n# 實例訪問類屬性nIn [5]: my_instance.class_attrnOut[5]: 1n# 如果通過實例增加一個屬性,只能改變此實例的屬性nIn [6]: my_instance.inst_attr = chinannIn [7]: my_instance.__dict__nOut[7]: {inst_attr: china}n# 對於類屬性而言並沒有絲毫變化nIn [8]: MyClass.__dict__nOut[8]:nmappingproxy({__dict__: <attribute __dict__ of MyClass objects>,n __doc__: None,n __module__: __main__,n __weakref__: <attribute __weakref__ of MyClass objects>,n class_attr: 1})n# 我們可以動態地給類增加一個屬性nIn [9]: MyClass.class_attr2 = 100nnIn [10]: my_instance.class_attr2nOut[10]: 100n# 但Python的內置類型並不能隨意地為它增加屬性或方法n

.操作符封裝了對實例屬性和類屬性兩種不同屬性進行查找的細節。

但是如果是訪問方法呢:

In [1]: class MyClass(object):n ...: def my_method(self):n ...: print(my_method)n ...: nnIn [2]: MyClass.__dict__[my_method]nOut[2]: <function __main__.MyClass.my_method>nnIn [3]: MyClass.my_methodnOut[3]: <function __main__.MyClass.my_method>nnIn [4]: type(MyClass.my_method)nOut[4]: functionnnIn [5]: type(MyClass.__dict__[my_method])nOut[5]: functionn

根據通過實例訪問屬性和根據類訪問屬性的不同，有以下兩種情況：

一種是通過實例訪問，比如代碼 obj.x，如果 x 是一個描述符，那麼 __getattribute__() 會返回 type(obj).__dict__[x].__get__(obj, type(obj)) 結果，即：type(obj) 獲取 obj 的類型；type(obj).__dict__[x] 返回的是一個描述符，這裡有一個試探和判斷的過程；最後調用這個描述符的 __get__() 方法。
另一個是通過類訪問的情況，比如代碼 cls.x，則會被 __getattribute__()轉換為 cls.__dict__[x].__get__(None, cls)。
描述符協議是一個 Duck Typing 的協議，而每一個函數都有 __get__ 方法，也就是說其他每一個函數都是描述符。所有對屬性, 方法進行修飾的方案往往都用到了描述符, 如classmethod, staticmethod, property等, 以下是property的參考實現:
class Property(object):n "Emulate PyProperty_Type() in Objects/descrobject.c"n def __init__(self, fget=None, fset=None, fdel=None, doc=None):n self.fget = fgetn self.fset = fsetn self.fdel = fdeln self.__doc__ = docn def __get__(self, obj, objtype=None):n if obj is None:n return selfn if self.fget is None:n raise AttributeError, "unreadable attribute"n return self.fget(obj)n def __set__(self, obj, value):n if self.fset is None:n raise AttributeError, "cant set attribute"n self.fset(obj, value)n def __delete__(self, obj):n if self.fdel is None:n raise AttributeError, "cant delete attribute"n self.fdel(obj)n

建議 60：區別getattr()和getattribute()方法

以上兩種方法可以對實例屬性進行獲取和攔截：

__getattr__(self, name)：適用於屬性在實例中以及對應的類的基類以及祖先類中都不存在；
__getattribute__(self, name)：對於所有屬性的訪問都會調用該方法

但訪問不存在的實例屬性時，會由內部方法__getattribute__()拋出一個 AttributeError 異常，也就是說只要涉及實例屬性的訪問就會調用該方法，它要麼返回實際的值，要麼拋出異常。詳情請參考。

那麼__getattr__()在什麼時候調用呢：

屬性不在實例的__dict__中；
屬性不在其基類以及祖先類的__dict__中；
觸發AttributeError異常時（注意，不僅僅是__getattribute__()方法的AttributeError異常，property 中定義的get()方法拋出異常的時候也會調用該方法）。

當這兩個方法同時被定義的時候，要麼在__getattribute__()中顯式調用，要麼觸發AttributeError異常，否則__getattr__()永遠不會被調用。

我們知道 property 也能控制屬性的訪問，如果一個類中如果定義了 property、__getattribute__()以及__getattr__()來對屬性進行訪問控制，會最先搜索__getattribute__()方法，由於 property 對象並不存在於 dict 中，因此並不能返回該方法，此時會搜索 property 中的get()方法；當 property 中的set()方法對屬性進行修改並再次訪問 property 的get()方法會拋出異常，這時會觸發__getattr__()的調用。

__getattribute__()總會被調用，而__getattr__()只有在__getattribute__()中引發異常的情況下調用。