coroutines

Fluent Python 讀書筆記（六）

2022 年 5 月 10 日
Python

註

此筆記適用 Python 3.4，部份已不相容後續版本的套件與 API

以 futures 撰寫並行

futures —— 非同步執行某項操作的物件
網路 I/O 涉及高度延遲，須要用到並行來有效處理
在公用 Web 測試並行 HTTP 用戶端，你可能會無意中啟動一個阻斷服務攻擊（DOS），或被懷疑在做這件事…要測試複雜的用戶端，你應該設定自己的測試伺服器（作法說明）
requests 已經被視為 Python 式 API 的典範，它比標準函式庫 urllib.request 還要強大
concurrent.futures 主要功能是能讓你分別提交（submit）在不同執行緒/程序執行的可呼叫物（callables），實作於 ThreadPoolExecutor、ProcessPoolExecutor 的介面（分別在內部管理一個 worker thread pool 及 process pool）

多執行緒並行起手勢

# 以 worker 數量來初始化

with futures.ThreadPoolExecuter(MAX_WORKERS) as executor:

# func 函式同時被多個執行緒呼叫，回傳一個產生器

res = executor.map(func, tasks)

# executor.__exit__ 方法呼叫 executor.shutdown(wait=True)

# 這個動作會被**阻塞**直到所有執行緒都完成

# 迭代取出每一個呼叫的回傳值

# 隱式的 next() 會呼叫每一個 future.result()

# 如果有任何執行緒在呼叫時出錯，會在這邊發出例外

result = list(res)

使用單純迴圈來取代 ThreadPoolExecuter.map：

with futures.ThreadPoolExecuter(MAX_WORKERS) as a executor:

future_stack = []

for task in tasks:

future_stack.append(executor.submit(func, task))

使用手動呼叫 result 取代隱式的 next 呼叫（阻塞式）：

result = []

for future in future_stack:

result.append(future.result())

使用 as_completed 取代阻塞式的結果查詢（完成後才產出），必須放在 Context Manager 區塊內，因為預設的 __exit__ 會阻塞：

with futures.ThreadPoolExecuter(MAX_WORKERS) as a executor:

...

result = []

for future in futures.as_completed(future_stack):

result.append(future.result())

Read More »Fluent Python 讀書筆記（六）

Fluent Python 讀書筆記（五）

2022 年 5 月 1 日2022 年 5 月 12 日
Python

控制流程

在大部分情況下，Python 社群將 Iterator 與 Generator 視為同義詞
Python 所有集合都是可迭代的
內部的 for 迴圈、集合生成式、變數和引數的 Unpacking 都會用到 Iterator
iter() 會先參考 __iter__，其次才參考 __getitem__，都沒有的話，發出 TypeError 代表「該物件不可迭代」（此處 __getitem__ 的參考在以後可能被棄用）
承上，可迭代物件不一定滿足 isinstance(C, abc.Iterable)（在未實作 __iter__ 的情況下），為了避免這個誤區，要判斷物件是否可迭代，最準確的方式是呼叫 iter() 看看
如果 iter() 會過，那物件是「Iterable」；實作 __iter__ ，須回傳一個「Iterator 實體」—— Python 會跟 Iterable 索取 Iterator
Iterator 類別的標準介面：__iter__ 跟 __next__，__next__ 負責回傳下一個項目或發起 StopIteration，__iter__ 則單純回傳 self
不要把 Iterable 跟 Iterator 混為一談，「Iterable 有一個 __iter__ 方法，這個方法每次都會實例化一個新的 Iterator」
Iterator 也是 Iterable，但 Iterable 不是 Iterator。Iterable 永遠不該扮演自己的 Iterator
Iterator 獨立出來的用意是「每一個迭代器都能保存它自己的內部狀態」
除了回傳獨立的 Iterator 實體，也可以將 __iter__ 變成一個「Generator 函式」，藉由回傳一個「Generator 實體」，以介面而言，Generator 是 Iterator，它會在內文結束時發出 StopIteration
用一個「 lazy 的產生器」取代一個「儲存所有資料的迭代器實體」是更好的，因為只要在必要時（最後一刻）才產生值，可以節省大量記憶體
Iterator 的另一個功能是「延緩工作」、「一次只產生一個項目」
「當你在用 Python3 想著『有更 lazy 的作法嗎？』的時候，答案通常都是『有』」
yield from 不只是一個糖衣語法，除了取代迴圈之外，它也是一個管道，連接外部產生器，接收外部產生器的值
all、any 有一種重要的優化是 reduce 無法作到的，那就是 short-circuit，確定結果後就停止
sorted 可以接收任意的 Iterable
iter() 的另一個功能：傳入一個 Callable 及一個標記值（sentinel），當回傳值等同此標記時，停止迭代
無論資料大小為何，Generator 提供一種有彈性的解決方案，把大型資料集當做資料流來處理
.send() 同樣會讓產生器進入下一個 yield，但是它也可以用來傳入資料，相較於 next() 單純接收資料，.send() 可讓使用者與產生器雙向交換資料——變成協同程序 (coroutines)
「在內文埋入一個 yield，不足以提醒那一個語意有如此不同」（但 Guido 討厭使用新的關鍵字）
以實作而言，Generator 是一種語言結構，以函式或表達式編寫，呼叫時回傳 GeneratorType
以概念而言，不管 Iterator 內部有多複雜（例如是一個樹狀資料結構），它的資料永遠只有一個來源（自己本身）；至於產生器，則不一定只產生集合裡面的項目
「Iterator 最簡單的介面是由 First、Next、IsDone、CurrentItem 的操作組成」，在 Python 它的介面更精簡：next() 跟 StopIteration

Read More »Fluent Python 讀書筆記（五）

Generator as Coroutines

2019 年 8 月 23 日2019 年 8 月 27 日
Python

Generator as Coroutines

cooperative multitasking (cooperative routines)
concurrent not parallel (python program execute on a single thread)

The way to create coroutines:

generators (asyncio)
native coroutines (using async /await)

Concepts

concurrency: tasks start, run and complete in overlapping time periods
parallelism: tasks run simultaneousely

cooperative: control relinquished to other task voluntarily, control by application(developer)
preemptive: control relinquished to other task involuntarily, control by the OS.
some sort of scheduler involved

Global Interpreter Lock(GIL)
Only one native thread excutes at a time.

Use Process based parallelism to avoid GIL. Not Thread based.

The Python threading module uses threads instead of processes. Threads uniquely run in the same unique memory heap. Whereas Processes run in separate memory heaps. This makes sharing information harder with processes and object instances. One problem arises because threads use the same memory heap, multiple threads can write to the same location in the memory heap which is why the global interpreter lock(GIL) in CPython was created as a mutex to prevent it from happening.

Make the right choice

CPU Bound => Multi processing
I/O Bound, Fast I/O, Limit Connections => Muilti Threading
I/O Bound, Slow I/O, Many Connections => Concurrency

Use deque

Much more efficient way to implement the stack and queue.

Operate 10,000 items take 1,000 times average:

(times in seconds)	list	deque
append(right)	0.87	0.87
pop(right)	0.002	0.0005
insert(left)	20.8	0.84
pop(left)	0.012	0.0005

Use unlimited deque with deque() or deque(iterable)
Use limited deque with deque(maxlen=n). If full, a corresponding number of items are discarded from the opposite end.

Implement producer / consumer coroutine using deque

Implement simple event loop