pythonuntil
A. python日期加減比較問題請教
#time模塊實現,也是自帶的
#字元串不好計算~但是時間戳是固定的呀...
#計算結果中,假定今天24日,輸入24,輸出0天,輸入25,輸出-1天
importtime
deff(tm):
stamp=time.mktime(time.strptime(tm,"%Y%m%d"))
diff=int((time.time()-stamp)//86400)
ifdiff<=180:
return{tm:str(diff)}
else:
d={}
whilediff>180:
d[tm]=180
stamp+=180*86400
diff=int((time.time()-stamp)//86400)
#注意這里time.gmtime()返回的是0時區日期,需要處理時區問題
tm=time.strftime("%Y%m%d",time.gmtime(stamp-time.timezone))
else:
d[tm]=str(diff)
returnd
if__name__=='__main__':
tm='20160325'
print(f(tm))
tm='20171015'
print(f(tm))
#結果輸出,注意:字典是沒有固定順序的
'''
{'20160921':180,'20170320':180,'20170916':'38','20160325':180}
{'20171015':'9'}
'''
B. 詳解Python中的協程，為什麼說它的底層是生成器
協程又稱為是微線程，英文名是Coroutine。它和線程一樣可以調度，但是不同的是線程的啟動和調度需要通過操作系統來處理。並且線程的啟動和銷毀需要涉及一些操作系統的變數申請和銷毀處理，需要的時間比較長。而協程呢，它的調度和銷毀都是程序自己來控制的，因此它更加輕量級也更加靈活。
協程有這么多優點，自然也會有一些缺點，其中最大的缺點就是需要編程語言自己支持，否則的話需要開發者自己通過一些方法來實現協程。對於大部分語言來說，都不支持這一機制。go語言由於天然支持協程，並且支持得非常好，使得它廣受好評，短短幾年時間就迅速流行起來。
對於Python來說，本身就有著一個GIL這個巨大的先天問題。GIL是Python的全局鎖，在它的限制下一個Python進程同一時間只能同時執行一個線程，即使是在多核心的機器當中。這就大大影響了Python的性能，尤其是在CPU密集型的工作上。所以為了提升Python的性能，很多開發者想出了使用多進程+協程的方式。一開始是開發者自行實現的，後來在Python3.4的版本當中，官方也收入了這個功能，因此目前可以光明正大地說，Python是支持協程的語言了。
生成器（generator)
生成器我們也在之前的文章當中介紹過，為什麼我們介紹協程需要用到生成器呢，是因為Python的協程底層就是通過生成器來實現的。
通過生成器來實現協程的原因也很簡單，我們都知道協程需要切換掛起，而生成器當中有一個yield關鍵字，剛好可以實現這個功能。所以當初那些自己在Python當中開發協程功能的程序員都是通過生成器來實現的，我們想要理解Python當中協程的運用，就必須從最原始的生成器開始。
生成器我們很熟悉了，本質上就是帶有yield這個關鍵詞的函數。
async，await和future
從Python3.5版本開始，引入了async，await和future。我們來簡單說說它們各自的用途，其中async其實就是@asyncio.coroutine，用途是完全一樣的。同樣await代替的是yield from，意為等待另外一個協程結束。
我們用這兩個一改，上面的代碼就成了：
async def test(k):
n = 0
while n < k:
await asyncio.sleep(0.5)
print('n = {}'.format(n))
n += 1
由於我們加上了await，所以每次在列印之前都會等待0.5秒。我們把await換成yield from也是一樣的，只不過用await更加直觀也更加貼合協程的含義。
Future其實可以看成是一個信號量，我們創建一個全局的future，當一個協程執行完成之後，將結果存入這個future當中。其他的協程可以await future來實現阻塞。我們來看一個例子就明白了：
future = asyncio.Future()
async def test(k):
n = 0
while n < k:
await asyncio.sleep(0.5)
print('n = {}'.format(n))
n += 1
future.set_result('success')
async def log():
result = await future
print(result)
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait([
log(),
test(5)
]))
loop.close()
在這個例子當中我們創建了兩個協程，第一個協程是每隔0.5秒print一個數字，在print完成之後把success寫入到future當中。第二個協程就是等待future當中的數據，之後print出來。
在loop當中我們要調度執行的不再是一個協程對象了而是兩個，所以我們用asyncio當中的wait將這兩個對象包起來。只有當wait當中的兩個對象執行結束，wait才會結束。loop等待的是wait的結束，而wait等待的是傳入其中的協程的結束，這就形成了一個依賴循環，等價於這兩個協程對象結束，loop才會結束。
總結
async並不只是可以用在函數上，事實上還有很多其他的用法，比如用在with語句上，用在for循環上等等。這些用法比較小眾，細節也很多，就不一一展開了，大家感興趣的可以自行去了解一下。
不知道大家在讀這篇文章的過程當中有沒有覺得有些費勁，如果有的話，其實是很正常的。原因也很簡單，因為Python原生是不支持協程這個概念的，所以在一開始設計的時候也沒有做這方面的准備，是後來覺得有必要才加入的。那麼作為後面加入的內容，必然會對原先的很多內容產生影響，尤其是協程藉助了之前生成器的概念來實現的，那麼必然會有很多耦合不清楚的情況。這也是這一塊的語法很亂，對初學者不友好的原因。
C. python非同步有哪些方式
yield相當於return，他將相應的值返回給調用next()或者send()的調用者，從而交出了CPU使用權，而當調用者再次調用next()或者send()的時候，又會返回到yield中斷的地方，如果send有參數，還會將參數返回給yield賦值的變數,如果沒有就和next（）一樣賦值為None。但是這里會遇到一個問題，就是嵌套使用generator時外層的generator需要寫大量代碼，看如下示例：
注意以下代碼均在Python3.6上運行調試
#!/usr/bin/env python# encoding:utf-8def inner_generator():
i = 0
while True:
i = yield i if i > 10: raise StopIterationdef outer_generator():
print("do something before yield")
from_inner = 0
from_outer = 1
g = inner_generator()
g.send(None) while 1: try:
from_inner = g.send(from_outer)
from_outer = yield from_inner except StopIteration: breakdef main():
g = outer_generator()
g.send(None)
i = 0
while 1: try:
i = g.send(i + 1)
print(i) except StopIteration: breakif __name__ == '__main__':
main()041
為了簡化，在Python3.3中引入了yield from
yield from
使用yield from有兩個好處，
1、可以將main中send的參數一直返回給最里層的generator，
2、同時我們也不需要再使用while循環和send (), next()來進行迭代。
我們可以將上邊的代碼修改如下：
def inner_generator():
i = 0
while True:
i = yield i if i > 10: raise StopIterationdef outer_generator():
print("do something before coroutine start") yield from inner_generator()def main():
g = outer_generator()
g.send(None)
i = 0
while 1: try:
i = g.send(i + 1)
print(i) except StopIteration: breakif __name__ == '__main__':
main()
執行結果如下：
do something before coroutine start123456789101234567891011
這里inner_generator()中執行的代碼片段我們實際就可以認為是協程，所以總的來說邏輯圖如下：
我們都知道Python由於GIL(Global Interpreter Lock)原因，其線程效率並不高，並且在*nix系統中，創建線程的開銷並不比進程小，因此在並發操作時，多線程的效率還是受到了很大制約的。所以後來人們發現通過yield來中斷代碼片段的執行，同時交出了cpu的使用權，於是協程的概念產生了。在Python3.4正式引入了協程的概念，代碼示例如下：
import asyncio# Borrowed from http://curio.readthedocs.org/en/latest/[email protected] countdown(number, n):
while n > 0:
print('T-minus', n, '({})'.format(number)) yield from asyncio.sleep(1)
n -= 1loop = asyncio.get_event_loop()
tasks = [
asyncio.ensure_future(countdown("A", 2)),
asyncio.ensure_future(countdown("B", 3))]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()12345678910111213141516
示例顯示了在Python3.4引入兩個重要概念協程和事件循環，
通過修飾符@asyncio.coroutine定義了一個協程，而通過event loop來執行tasks中所有的協程任務。之後在Python3.5引入了新的async & await語法，從而有了原生協程的概念。
async & await
在Python3.5中，引入了aync&await 語法結構，通過」aync def」可以定義一個協程代碼片段，作用類似於Python3.4中的@asyncio.coroutine修飾符，而await則相當於」yield from」。
先來看一段代碼，這個是我剛開始使用async&await語法時，寫的一段小程序。
#!/usr/bin/env python# encoding:utf-8import asyncioimport requestsimport time
async def wait_download(url):
response = await requets.get(url)
print("get {} response complete.".format(url))
async def main():
start = time.time()
await asyncio.wait([
wait_download("http://www.163.com"),
wait_download("http://www.mi.com"),
wait_download("http://www.google.com")])
end = time.time()
print("Complete in {} seconds".format(end - start))
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
這里會收到這樣的報錯：
Task exception was never retrieved
future: <Task finished coro=<wait_download() done, defined at asynctest.py:9> exception=TypeError("object Response can't be used in 'await' expression",)>
Traceback (most recent call last):
File "asynctest.py", line 10, in wait_download
data = await requests.get(url)
TypeError: object Response can't be used in 'await' expression123456
這是由於requests.get()函數返回的Response對象不能用於await表達式，可是如果不能用於await，還怎麼樣來實現非同步呢？
原來Python的await表達式是類似於」yield from」的東西，但是await會去做參數檢查，它要求await表達式中的對象必須是awaitable的，那啥是awaitable呢？ awaitable對象必須滿足如下條件中其中之一：
1、A native coroutine object returned from a native coroutine function .
原生協程對象
2、A generator-based coroutine object returned from a function decorated with types.coroutine() .
types.coroutine()修飾的基於生成器的協程對象，注意不是Python3.4中asyncio.coroutine
3、An object with an await method returning an iterator.
實現了await method，並在其中返回了iterator的對象
根據這些條件定義，我們可以修改代碼如下：
#!/usr/bin/env python# encoding:utf-8import asyncioimport requestsimport time
async def download(url): # 通過async def定義的函數是原生的協程對象
response = requests.get(url)
print(response.text)
async def wait_download(url):
await download(url) # 這里download(url)就是一個原生的協程對象
print("get {} data complete.".format(url))
async def main():
start = time.time()
await asyncio.wait([
wait_download("http://www.163.com"),
wait_download("http://www.mi.com"),
wait_download("http://www.google.com")])
end = time.time()
print("Complete in {} seconds".format(end - start))
loop = asyncio.get_event_loop()
loop.run_until_complete(main())27282930
好了現在一個真正的實現了非同步編程的小程序終於誕生了。
而目前更牛逼的非同步是使用uvloop或者pyuv，這兩個最新的Python庫都是libuv實現的，可以提供更加高效的event loop。
uvloop和pyuv
pyuv實現了Python2.x和3.x，但是該項目在github上已經許久沒有更新了，不知道是否還有人在維護。
uvloop只實現了3.x, 但是該項目在github上始終活躍。
它們的使用也非常簡單，以uvloop為例，只需要添加以下代碼就可以了
import asyncioimport uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())123
D. python 計算程序運行了多長時間
python 計算程序運行時間：
6.760052s
一、import time
E. 在Python中使用Asyncio系統（3-4）Task 和 Future
Task 和 Future
前面我們討論了協程，以及如何在循環中運行它們才有用。現在我想簡單談談Task和Future api。你將使用最多的是Task，因為你的大部分工作將涉及使用create_task()函數運行協程，就像在第22頁的「快速開始」中設置的那樣。Future類實際上是Task的超類，它提供了與循環交互操作的所有功能。
可以這樣簡單地理解:Future表示某個活動的未來完成狀態，並由循環管理。Task是完全相同的，但是具體的「activity」是一個協程——可能是你用async def函數加上create_task()創建的協程。
Future類表示與循環交互的某個東西的狀態。這個描述太模糊了，不太有用，所以你可以將Future實例視為一個切換器，一個完成狀態的切換器。當創建Future實例時，切換設置為「尚未完成」狀態，但稍後它將是「完成」狀態。事實上，Future實例有一個名為done()的方法，它允許你檢查狀態，如示例 3-15所示。
示例 3-15. 用done()方法檢查完成狀態
Future實例還可以執行以下操作：
• 設置一個result值（用.set_result(value)設置值並且使用 .result()獲取值）
• 使用.cancel()方法取消 (並且會用使用.cancelled()檢查是否取消)
• 增加一個Future完成時回調的函數
即使Task更常見，也不可能完全避免使用Future：例如，在執行器上運行函數將返回Future實例，而不是Task。讓我們快速看一下 示例 3-16 ，了解一下直接使用Future實例是什麼感覺。
示例 3-16. 與Future實例的交互
（L3）創建一個簡單的 main函數。我們運行這個函數，等上一會兒然後在Future f上設置一個結果。
（L5）設置一個結果。
（L8）手動創建一個Future實例。注意，這個實例(默認情況下)綁定到我們的循環，但它沒有也不會被附加到任何協程(這就是Tasks的作用)。
（L9）在做任何事情之前，確認future還沒有完成。
（L11）安排main()協程，傳遞future。請記住，main()協程所做的所有工作就是sleep，然後切換Future實例。(注意main()協程還不會開始運行：協程只在事件循環運行時才開始運行。)
(L13)在這里我們在Future實例上而不是Task實例上使用run_until_complete()。這和你以前見過的不一樣。現在循環正在運行，main()協程將開始執行.
（L16）最終，當future的結果被設置時，它就完成了。完成後，可以訪問結果。
當然，你不太可能以這里所示的方式直接使用Future；代碼示例僅用於教育目的。你與asynccio的大部分聯系都是通過Task實例進行的。
你可能想知道如果在Task實例上調用set_result()會發生什麼。在Python 3.8之前可以這樣做，但現在不允許這么做了。任務實例是協程對象的包裝器，它們的結果值只能在內部設置為底層協程函數的結果，如 示例 3-17所示那樣。
示例 3-17. 在task上調用set_result
（L13）唯一的區別是我們創建的是Task實例而不是Future實例。當然，Task API要求我們提供一個協程；這里我們使用sleep()只是因為簡單方便。
（L7）正在傳入一個Task實例。它滿足函數的類型簽名(因為Task是Future的子類)，但從Python 3.8開始，我們不再允許在Task上調用set_result()：嘗試這樣做將引發RuntimeError。這個想法是，一個Task代表一個正在運行的協程，所以結果應該總是來自於task自身。
（L10, L24）但是，我們仍然可以cancel()一個任務，它將在底層協程中引發CancelledError。
Create_task? Ensure_Future? 下定決心吧！
在第22頁的「快速入門」中，我說過運行協程的方法是使用asyncio.create_task()。在引入該函數之前，有必要獲取一個循環實例並使用loop.create_task()完成相同的任務。事實上，這也可以通過一個不同的模塊級函數來實現:asyncio.ensure_future()。一些開發人員推薦create_task()，而其他人推薦ensure_future()。
在我為這本書做研究的過程中，我確信API方法asyncio.ensure_future()是引起對asyncio庫廣泛誤解的罪魁禍首。API的大部分內容都非常清晰，但在學習過程中還存在一些嚴重的障礙，這就是其中之一。當你遇到ensure_future()時，你的大腦會非常努力地將其集成到關於asyncio應該如何使用的心理模型中——但很可能會失敗!
在Python 3.6 asyncio 文檔中，這個現在已經臭名昭著的解釋突出了 ensure_future() 的問題：
asyncio.ensure_future(coro_or_future, *, _loop =None)
安排執行一個協程對象：把它包裝在future中。返回一個Task對象。如果參數是Future，則直接返回。
什麼!? 當我第一次讀到這篇文章時，我很困惑。下面希望是對ensure_future()的更清楚的描述:
這個函數很好地說明了針對終端用戶開發人員的asyncio API(高級API)和針對框架設計人員的asyncio API(低級API)之間的區別。讓我們在示例 3-18中自習看看它是如何工作的。
示例 3-18. 仔細看看ensure_future()在做什麼
（L3）一個簡單的什麼都不做的協程函數。我們只需要一些能組成協程的東西。
（L6）我們通過直接調用該函數來創建協程對象。你的代碼很少會這樣做，但我想在這里明確地表示，我們正在向每個create_task()和ensure_future()傳遞一個協程對象。
（L7）獲取一個循環。
（L9）首先，我們使用loop.create_task()在循環中調度協程，並返回一個新的Task實例。
（L10）驗證類型。到目前為止，沒有什麼有趣的。
（L12）我們展示了asyncio.ensure_future()可以被用來執行與create_task()相同的動作：我們傳入了一個協程，並返回了一個Task實例(並且協程已經被安排在循環中運行)!如果傳入的是協程，那麼loop.create_task()和asyncio.ensure_future()之間沒有區別。
（L15）如果我們給ensure_future()傳遞一個Task實例會發生什麼呢？注意我們要傳遞的Task實例是已經在第4步通過loop.create_task()創建好的。
（L16）返回的Task實例與傳入的Task實例完全相同:它在被傳遞時沒有被改變。
直接傳遞Future實例的意義何在？為什麼用同一個函數做兩件不同的事情？答案是，ensure_future()的目的是讓框架作者向最終用戶開發者提供可以處理兩種參數的API。不相信我？這是ex-BDFL自己說的：
ensure_future()的要點是，如果你有一個可能是協程或Future(後者包括一個Task，因為它是Future的子類)的東西，並且你想能夠調用一個只在Future上定義的方法(可能唯一有用的例子是cancel())。當它已經是Future(或Task)時，它什麼也不做；當它是協程時，它將它包裝在Task中。
如果您知道您有一個協程，並且希望它被調度，那麼正確的API是create_task()。唯一應該調用ensure_future()的時候是當你提供一個API(像大多數asyncio自己的API)，它接受協程或Future，你需要對它做一些事情，需要你有一個Future。
—Guido van Rossum
總而言之，asyncio.sure_future()是一個為框架設計者准備的輔助函數。這一點最容易通過與一種更常見的函數進行類比來解釋，所以我們來做這個解釋。如果你有幾年的編程經驗，你可能已經見過類似於例3-19中的istify()函數的函數。示例 3-19中listify()的函數。
示例 3-19. 一個強制輸入列表的工具函數
這個函數試圖將參數轉換為一個列表，不管輸入的是什麼。api和框架中經常使用這類函數將輸入強制轉換為已知類型，這將簡化後續代碼——在本例中，您知道參數(來自listify()的輸出)將始終是一個列表。
如果我將listify()函數重命名為ensure_list()，那麼您應該開始看到與asyncio.ensure_future()的類似之處:它總是試圖將參數強制轉換為Future(或子類)類型。這是一個實用函數，它使框架開發人員(而不是像你我這樣的終端用戶開發人員)的工作變得更容易。
實際上，asyncio標准庫模塊本身使用ensure_future()正是出於這個原因。當你下次查看API時，你會發現函數參數被描述為「可等待對象」，很可能內部使用ensure_future()強制轉換參數。例如，asyncio.gather()函數就像下面的代碼一樣:
aws參數表示「可等待對象」，包括協程、task和future。在內部，gather()使用ensure_future()進行類型強制轉換：task和future保持不變，而把協程強制轉為task。
這里的關鍵是，作為終端用戶應用程序開發人員，應該永遠不需要使用asyncio.ensure_future()。它更像是框架設計師的工具。如果你需要在事件循環上調度協程，只需直接使用asyncio.create_task()來完成。
在接下來的幾節中，我們將回到語言級別的特性，從非同步上下文管理器開始。
F. python2.7怎麼實現非同步
改進之前
之前，我的查詢步驟很簡單，就是：
前端提交查詢請求 --> 建立資料庫連接 --> 新建游標 --> 執行命令 --> 接受結果 --> 關閉游標、連接
這幾大步驟的順序執行。
這裡面當然問題很大：
建立資料庫連接實際上就是新建一個套接字。這是進程間通信的幾種方法里，開銷最大的了。
在「執行命令」和「接受結果」兩個步驟中，線程在阻塞在資料庫內部的運行過程中，資料庫連接和游標都處於閑置狀態。
這樣一來，每一次查詢都要順序的新建資料庫連接，都要阻塞在資料庫返回結果的過程中。當前端提交大量查詢請求時，查詢效率肯定是很低的。
第一次改進
之前的模塊里，問題最大的就是第一步——建立資料庫連接套接字了。如果能夠一次性建立連接，之後查詢能夠反復服用這個連接就好了。
所以，首先應該把資料庫查詢模塊作為一個單獨的守護進程去執行，而前端app作為主進程響應用戶的點擊操作。那麼兩條進程怎麼傳遞消息呢？翻了幾天Python文檔，終於構思出來：用隊列queue作為生產者（web前端）向消費者（資料庫後端）傳遞任務的渠道。生產者，會與SQL命令一起，同時傳遞一個管道pipe的連接對象，作為任務完成後，回傳結果的渠道。確保，任務的接收方與發送方保持一致。
作為第二個問題的解決方法，可以使用線程池來並發獲取任務隊列中的task，然後執行命令並回傳結果。
第二次改進
第一次改進的效果還是很明顯的，不用任何測試手段。直接點擊頁面鏈接，可以很直觀地感覺到反應速度有很明顯的加快。
但是對於第二個問題，使用線程池還是有些欠妥當。因為，CPython解釋器存在GIL問題，所有線程實際上都在一個解釋器進程里調度。線程稍微開多一點，解釋器進程就會頻繁的切換線程，而線程切換的開銷也不小。線程多一點，甚至會出現「抖動」問題（也就是剛剛喚醒一個線程，就進入掛起狀態，剛剛換到棧幀或內存的上下文，又被換回內存或者磁碟），效率大大降低。也就是說，線程池的並發量很有限。
試過了多進程、多線程，只能在單個線程里做文章了。
Python中的asyncio庫
Python里有大量的協程庫可以實現單線程內的並發操作，比如Twisted、Gevent等等。Python官方在3.5版本里提供了asyncio庫同樣可以實現協程並發。asyncio庫大大降低了Python中協程的實現難度，就像定義普通函數那樣就可以了，只是要在def前面多加一個async關鍵詞。async def函數中，需要阻塞在其他async def函數的位置前面可以加上await關鍵詞。
import asyncio
async def wait():
await asyncio.sleep(2)
async def execute(task):
process_task(task)
await wait()
continue_job()
async def函數的執行稍微麻煩點。需要首先獲取一個loop對象，然後由這個對象代為執行async def函數。
loop = asyncio.get_event_loop()
loop.run_until_complete(execute(task))
loop.close()
loop在執行execute(task)函數時，如果遇到await關鍵字，就會暫時掛起當前協程，轉而去執行其他阻塞在await關鍵詞的協程，從而實現協程並發。
不過需要注意的是，run_until_complete()函數本身是一個阻塞函數。也就是說，當前線程會等候一個run_until_complete()函數執行完畢之後，才會繼續執行下一部函數。所以下面這段代碼並不能並發執行。
for task in task_list:
loop.run_until_complete(task)
對與這個問題，asyncio庫也有相應的解決方案：gather函數。
loop = asyncio.get_event_loop()
tasks = [asyncio.ensure_future(execute(task))
for task in task_list]
loop.run_until_complete(asyncio.gather(*tasks))
loop.close()
當然了，async def函數的執行並不只有這兩種解決方案，還有call_soon與run_forever的配合執行等等，更多內容還請參考官方文檔。
Python下的I/O多路復用
協程，實際上，也存在上下文切換，只不過開銷很輕微。而I/O多路復用則完全不存在這個問題。
目前，Linux上比較火的I/O多路復用API要算epoll了。Tornado，就是通過調用C語言封裝的epoll庫，成功解決了C10K問題（當然還有Pypy的功勞）。
在Linux里查文檔，可以看到epoll只有三類函數，調用起來比較方便易懂。
創建epoll對象，並返回其對應的文件描述符（file descriptor）。
int epoll_create(int size);
int epoll_create1(int flags);
控制監聽事件。第一個參數epfd就對應於前面命令創建的epoll對象的文件描述符；第二個參數表示該命令要執行的動作：監聽事件的新增、修改或者刪除；第三個參數，是要監聽的文件對應的描述符；第四個，代表要監聽的事件。
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
等候。這是一個阻塞函數，調用者會等候內核通知所注冊的事件被觸發。
int epoll_wait(int epfd, struct epoll_event *events,
int maxevents, int timeout);
int epoll_pwait(int epfd, struct epoll_event *events,
int maxevents, int timeout,
const sigset_t *sigmask);
在Python的select庫里：
select.epoll()對應於第一類創建函數；
epoll.register()，epoll.unregister()，epoll.modify()均是對控制函數epoll_ctl的封裝；
epoll.poll()則是對等候函數epoll_wait的封裝。
Python里epoll相關API的最大問題應該是在epoll.poll()。相比於其所封裝的epoll_wait，用戶無法手動指定要等候的事件，也就是後者的第二個參數struct epoll_event *events。沒法實現精確控制。因此只能使用替代方案：select.select()函數。
根據Python官方文檔，select.select(rlist, wlist, xlist[, timeout])是對Unix系統中select函數的直接調用，與C語言API的傳參很接近。前三個參數都是列表，其中的元素都是要注冊到內核的文件描述符。如果想用自定義類，就要確保實現了fileno()方法。
其分別對應於：
rlist: 等候直到可讀
wlist: 等候直到可寫
xlist: 等候直到異常。這個異常的定義，要查看系統文檔。
select.select()，類似於epoll.poll()，先注冊文件和事件，然後保持等候內核通知，是阻塞函數。
實際應用
Psycopg2庫支持對非同步和協程，但和一般情況下的用法略有區別。普通資料庫連接支持不同線程中的不同游標並發查詢；而非同步連接則不支持不同游標的同時查詢。所以非同步連接的不同游標之間必須使用I/O復用方法來協調調度。
所以，我的大致實現思路是這樣的：首先並發執行大量協程，從任務隊列中提取任務，再向連接池請求連接，創建游標，然後執行命令，並返回結果。在獲取游標和接受查詢結果之前，均要阻塞等候內核通知連接可用。
其中，連接池返回連接時，會根據引用連接的協程數量，返回負載最輕的連接。這也是自己定義AsyncConnectionPool類的目的。
我的代碼位於：bottle-blog/dbservice.py
存在問題
當然了，這個流程目前還一些問題。
首先就是每次輪詢拿到任務之後，都會走這么一個流程。
獲取連接 --> 新建游標 --> 執行任務 --> 關閉游標 --> 取消連接引用
本來，最好的情況應該是：在輪詢之前，就建好游標；在輪詢時，直接等候內核通知，執行相應任務。這樣可以減少輪詢時的任務量。但是如果協程提前對應好連接，那就不能保證在獲取任務時，保持各連接負載均衡了。
所以這一塊，還有工作要做。
還有就是epoll沒能用上，有些遺憾。
以後打算寫點C語言的內容，或者用Python/C API，或者用Ctypes包裝共享庫，來實現epoll的調用。
最後，請允許我吐槽一下Python的epoll相關文檔：簡直太弱了！！！必須看源碼才能弄清楚功能。
G. python 期物
期物（Future）是concurrent.futures模塊和asyncio包的重要組件。
python3.4之後標准庫中有兩個名為Future的類：concurrent.futures.Future和asyncio.Future.
這兩個類的作用相同：類的實例都表示可能已經完成活著尚未完成的延遲計算。與JS庫中的Promise對象，Tornado框架中的Future類類似。
通常我們自己不應該創建期物，而只能由並發框架實例化。
這個例子中的future.result方法不會阻塞，因為future對象是有as_completed方法產生的。
在asyncio包中，BaseEventLoop.create_task(...)方法接收一個協程，排定他的運行時間，然後返回一個asyncio.Task實例（也是asyncio.Future類的實例），因為Task是Future的子類，用於包裝協程。這與Executor.submit(...)方法創建concurrent.futures.Future實例是一個道理。
因為asyncio.Future類的目的是與yield from一起使用，所以通常不需用使用以下方法：
asyncio.async(coro_or_future, *, loop=None)
這個函數統一了協程和期物：第一個參數可以是二者中的任何一個。如果是 Future或 Task 對象，那就原封不動地返回。如果是協程，那麼 async 函數會調用loop.create_task(...) 方法創建 Task 對象。loop= 關鍵字參數是可選的，用於傳入事件循環；如果沒有傳入，那麼 async 函數會通過調用 asyncio.get_event_loop() 函數獲取循環對象.
不過，在asyncio 中，基本的流程是一樣的：在一個單線程程序中使用主循環依次激活隊列里的協程。各個協程向前執行幾步，然後把控制權讓給主循環，主循環再激活隊列里的下一個協程。
asyncio.wait(...) 協程的參數是一個由期物或者協程構成的可迭代對象。wait會分別把各個協程包裝進入一個Task對象。最後的結果是，wait處理的所有對象都通過某種方法變成Future實例。wait是協程函數，因此返回的是一個協程或者生成器對象。為了驅動協程，我們把協程傳給loop.run_until_complete(...)方法。
H. python的優缺點是什麼
優點：
Python的定位是「優雅」、「明確」、「簡單」，所以Python程序看上去總是簡單易懂，初學者學Python，不但入門容易，而且將來深入下去，可以編寫那些非常非常復雜的程序。
開發效率非常高，Python有非常強大的第三方庫，基本上你想通過計算機實現任何功能，Python官方庫里都有相應的模塊進行支持，直接下載調用後，在基礎庫的基礎上再進行開發，大大降低開發周期，避免重復造輪子。
高級語言————當你用Python語言編寫程序的時候，你無需考慮諸如如何管理你的程序使用的內存一類的底層細節
可移植性————由於它的開源本質，Python已經被移植在許多平台上（經過改動使它能夠工 作在不同平台上）。如果你小心地避免使用依賴於系統的特性，那麼你的所有Python程序無需修改就幾乎可以在市場上所有的系統平台上運行
可擴展性————如果你需要你的一段關鍵代碼運行得更快或者希望某些演算法不公開，你可以把你的部分程序用C或C++編寫，然後在你的Python程序中使用它們。
可嵌入性————你可以把Python嵌入你的C/C++程序，從而向你的程序用戶提供腳本功能
速度慢，Python 的運行速度相比C語言確實慢很多，跟java相比也要慢一些，因此這也是很多所謂的大牛不屑於使用Python的主要原因，但其實這里所指的運行速度慢在大多數情況下用戶是無法直接感知到的，必須藉助測試工具才能體現出來，比如你用C運一個程序花了0.01s,用Python是0.1s,這樣C語言直接比Python快了10倍,算是非常誇張了，但是你是無法直接通過肉眼感知的，因為一個正常人所能感知的時間最小單位是0.15-0.4s左右，哈哈。其實在大多數情況下Python已經完全可以滿足你對程序速度的要求，除非你要寫對速度要求極高的搜索引擎等，這種情況下，當然還是建議你用C去實現的。
代碼不能加密，因為PYTHON是解釋性語言，它的源碼都是以名文形式存放的，不過我不認為這算是一個缺點，如果你的項目要求源代碼必須是加密的，那你一開始就不應該用Python來去實現。
線程不能利用多CPU問題，這是Python被人詬病最多的一個缺點，GIL即全局解釋器鎖（Global Interpreter Lock），是計算機程序設計語言解釋器用於同步線程的工具，使得任何時刻僅有一個線程在執行，Python的線程是操作系統的原生線程。在Linux上為pthread，在Windows上為Win thread，完全由操作系統調度線程的執行。一個python解釋器進程內有一條主線程，以及多條用戶程序的執行線程。即使在多核CPU平台上，由於GIL的存在，所以禁止多線程的並行執行。關於這個問題的折衷解決方法，我們在以後線程和進程章節里再進行詳細探討。
缺點：
Python目前主要應用領域：
雲計算: 雲計算最火的語言， 典型應用OpenStack
WEB開發: 眾多優秀的WEB框架，眾多大型網站均為Python開發，Youtube, Dropbox, 豆瓣。。。， 典型WEB框架有Django
科學運算、人工智慧: 典型庫NumPy, SciPy, Matplotlib, Enthought librarys,pandas
系統運維: 運維人員必備語言
金融：量化交易，金融分析，在金融工程領域，Python不但在用，且用的最多，而且重要性逐年提高。原因：作為動態語言的Python，語言結構清晰簡單，庫豐富，成熟穩定，科學計算和統計分析都很牛逼，生產效率遠遠高於c,c++,java,尤其擅長策略回測
圖形GUI: PyQT, WxPython,TkInter
Python在一些公司的應用：
谷歌：Google App Engine 、code.google.com 、Google earth 、谷歌爬蟲、Google廣告等項目都在大量使用Python開發
CIA: 美國中情局網站就是用Python開發的
NASA: 美國航天局(NASA)大量使用Python進行數據分析和運算
YouTube:世界上最大的視頻網站YouTube就是用Python開發的
Instagram:美國最大的圖片分享社交網站，每天超過3千萬張照片被分享，全部用python開發
Facebook:大量的基礎庫均通過Python實現的
Redhat: 世界上最流行的Linux發行版本中的yum包管理工具就是用python開發的
豆瓣: 公司幾乎所有的業務均是通過Python開發的
知乎: 國內最大的問答社區，通過Python開發(國外Quora)
春雨醫生：國內知名的在線醫療網站是用Python開發的
除上面之外，還有搜狐、金山、騰訊、盛大、網易、網路、阿里、淘寶 、土豆、新浪、果殼等公司都在使用Python完成各種各樣的任務。
1989年，為了打發聖誕節假期，Guido開始寫Python語言的編譯器。Python這個名字，來自Guido所摯愛的電視劇Monty Python』s Flying Circus。他希望這個新的叫做Python的語言，能符合他的理想：創造一種C和shell之間，功能全面，易學易用，可拓展的語言。
1991年，第一個Python編譯器誕生。它是用C語言實現的，並能夠調用C語言的庫文件。從一出生，Python已經具有了：類，函數，異常處理，包含表和詞典在內的核心數據類型，以及模塊為基礎的拓展系統。
Granddaddy of Python web frameworks, Zope 1 was released in 1999
Python 1.0 - January 1994 增加了lambda,map,filterandrece.
Python 2.0 - October 16, 2000，加入了內存回收機制，構成了現在Python語言框架的基礎
Python 2.4 - November 30, 2004, 同年目前最流行的WEB框架Django 誕生
Python 2.5 - September 19, 2006
Python 2.6 - October 1, 2008
Python 2.7 - July 3, 2010
In November 2014, it was announced that Python 2.7 would be supported until 2020, and reaffirmed that there would be no 2.8 release as users were expected to move to Python 3.4+ as soon as possible
Python 3.0 - December 3, 2008
Python 3.1 - June 27, 2009
Python 3.2 - February 20, 2011
Python 3.3 - September 29, 2012
Python 3.4 - March 16, 2014
Python 3.5 - September 13, 2015
Python 3.6 - December 16,2016
python發展史
摘自我的博客，禁止所有形式的轉載
I. 如何讓python程序每個一段時間執行一次
python定時程序（每隔一段時間執行指定函數）
[python] view plain
import os
import time
def print_ts(message):
print "[%s] %s"%(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()), message)
def run(interval, command):
print_ts("-"*100)
print_ts("Command %s"%command)
print_ts("Starting every %s seconds."%interval)
print_ts("-"*100)
while True:
try:
# sleep for the remaining seconds of interval
time_remaining = interval-time.time()%interval
print_ts("Sleeping until %s (%s seconds)..."%((time.ctime(time.time()+time_remaining)), time_remaining))
time.sleep(time_remaining)
print_ts("Starting command.")
# execute the command
status = os.system(command)
print_ts("-"*100)
print_ts("Command status = %s."%status)
except Exception, e:
print e
if __name__=="__main__":
interval = 5
command = r"ls"
run(interval, command)
J. python中timedelta方法怎麼用
#! /usr/bin/python# coding=utf-8from datetime import datetime,timedelta"""timedelta代表兩個datetime之間的時間差"""now = datetime.now()
past = past = datetime(2010,11,12,13,14,15,16)
timespan = now - past#這會得到一個負數
past - now
attrs = [
("days","日"),( 'seconds',"秒"),( 'microseconds',"毫秒")#('min',"最小"),( 'max',"最大"),]for k,v in attrs: "timespan.%s = %s #%s" % (k,getattr(timespan, k),v)"""總共相差的秒數"""timespan.total_seconds()"""實例化一個timespan
請注意它的參數順序
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])"""timespan = timedelta(days=1)
now - timespan #返回的是datetime型
now + timespan
timespan * 2 #還可以乘哦。代表二倍
timespan / 13#增加一個月from calendar import monthrange
now + timedelta(days=monthrange(start.year,start.month)[1])