åè¨
å顾ä¹å讲äºpythonè¯æ³ç¼ç¨ ï¼å ³äºä»é¶å ¥é¨pythonç第ä¸éï¼ç¼ç¨è¯æ³å¿ ä¿®å 容ï¼æ¯å¦python3åºç¡å ¥é¨ï¼å表ä¸å ç»ï¼å符串ï¼åå ¸ï¼æ¡ä»¶ä¸¶å¾ªç¯åå ¶ä»è¯å¥ä¸¶å½æ°ä¸¶é¢å对象丶å¼å¸¸åæ件å¤çåç½ç»ç¼ç¨ç¯
1.è·æä¸èµ·ä»é¶å¼å§å¦pythonï¼ä¸ï¼ç¼ç¨è¯æ³å¿ ä¿®
2.è·æä¸èµ·ä»é¶å¼å§å¦pythonï¼äºï¼ç½ç»ç¼ç¨
ãæ¬ç¯è®²ï¼python并åç¼ç¨ï¼å¤çº¿ç¨/å¤è¿ç¨/åç¨ã
æ¬ç³»åææ ¹æ®ä»¥ä¸å¦ä¹ 路线å±å¼è®²è¿°ï¼ç±äºå 容è¾å¤ï¼
ãä»é¶å¼å§å¦pythonå°é«çº§è¿é¶è·¯çº¿å¾ã
pythonææ¡£+ç¬è®°+äºè§£æ¥å+æºç è·åæ¹å¼
ãéç¨äºé¶åºç¡å¦ä¹ åè¿é¶äººç¾¤çpythonèµæºï¼ã
ãâ è ¾è®¯è®¤è¯pythonå®æ´é¡¹ç®å®ææç¨ç¬è®°PDFã
ãâ¡ åå 个大åpythoné¢è¯ä¸é¢PDFã
ã⢠pythonå ¨å¥è§é¢æç¨ï¼é¶åºç¡-é«çº§è¿é¶JSéåï¼ã
ã⣠ç¾ä¸ªé¡¹ç®å®æ+æºç +ç¬è®°ã
ã⤠ç¼ç¨è¯æ³-æºå¨å¦ä¹ -å ¨æ å¼å-æ°æ®åæ-ç¬è«-APPéåçå ¨å¥é¡¹ç®+ææ¡£ã
ã⥠交æµå¦ä¹ ã
ã⦠æ³è¦å ¼èæ¥åã
第ä¸ç« ï¼å¤çº¿ç¨
1.线ç¨åè¿ç¨
线ç¨åè¿ç¨æ¯æä½ç³»ç»ä¸ç两个éè¦æ¦å¿µï¼å®ä»¬é½æ¯å¹¶åç¼ç¨çåºç¡ã线ç¨æ¯æä½ç³»ç»è½å¤è¿è¡è¿ç®è°åº¦çæå°åä½ï¼èè¿ç¨åæ¯æä½ç³»ç»è¿è¡èµæºåé åè°åº¦çåºæ¬åä½ã
线ç¨åè¿ç¨çåºå«ï¼
- 线ç¨æ¯è¿ç¨çä¸é¨åï¼ä¸ä¸ªè¿ç¨å¯ä»¥å å«å¤ä¸ªçº¿ç¨ï¼èä¸ä¸ªçº¿ç¨åªè½å±äºä¸ä¸ªè¿ç¨ã
- è¿ç¨æ¥æç¬ç«çå å空é´ï¼è线ç¨å ±äº«è¿ç¨çå å空é´ã
- è¿ç¨ä¹é´çéä¿¡éè¦ä½¿ç¨IPCï¼Inter-Process Communicationï¼æºå¶ï¼è线ç¨ä¹é´å¯ä»¥ç´æ¥å ±äº«æ°æ®ã
- è¿ç¨çå建åéæ¯æ¯çº¿ç¨æ ¢ï¼å 为è¿ç¨éè¦åé åéæ¾ç¬ç«çå å空é´ï¼è线ç¨åªéè¦åé åéæ¾ä¸äºå¯åå¨åæ 空é´ã
å¨Pythonä¸ï¼å¯ä»¥ä½¿ç¨threading模åæ¥å建å管ç线ç¨ãä¸é¢æ¯ä¸ä¸ªç®åç线ç¨ç¤ºä¾ï¼
import threading
def worker():
print('Worker thread started')
# do some work here
print('Worker thread finished')
# create a new thread
t = threading.Thread(target=worker)
# start the thread
t.start()
# wait for the thread to finish
t.join()
å¨è¿ä¸ªç¤ºä¾ä¸ï¼æ们å建äºä¸ä¸ªå为workerçå½æ°ï¼å®å°å¨ä¸ä¸ªæ°ç线ç¨ä¸è¿è¡ãæ们使ç¨threading.Threadç±»å建äºä¸ä¸ªæ°ç线ç¨å¯¹è±¡ï¼å¹¶å°workerå½æ°ä½ä¸ºç®æ ä¼ éç»å®ãç¶åï¼æ们使ç¨start()æ¹æ³å¯å¨çº¿ç¨ï¼å¹¶ä½¿ç¨join()æ¹æ³çå¾ çº¿ç¨å®æã
2.使ç¨çº¿ç¨
å¨Pythonä¸ï¼ä½¿ç¨çº¿ç¨å¯ä»¥éè¿threading模åæ¥å®ç°ãä¸é¢æ¯ä¸ä¸ªç®åçä¾åï¼å±ç¤ºäºå¦ä½ä½¿ç¨çº¿ç¨ï¼
import threading
def worker():
"""线ç¨æ§è¡çä»»å¡"""
print("Worker thread started")
# æ§è¡ä¸äºä»»å¡
print("Worker thread finished")
# å建线ç¨
t = threading.Thread(target=worker)
# å¯å¨çº¿ç¨
t.start()
# 主线ç¨ç»§ç»æ§è¡å
¶ä»ä»»å¡
print("Main thread finished")
å¨ä¸é¢çä¾åä¸ï¼æ们é¦å å®ä¹äºä¸ä¸ªworkerå½æ°ï¼å®å°å¨ä¸ä¸ªåç¬ç线ç¨ä¸æ§è¡ãç¶åï¼æ们使ç¨threading.Threadç±»å建äºä¸ä¸ªæ°ç线ç¨ï¼å¹¶å°workerå½æ°ä½ä¸ºåæ°ä¼ éç»å®ãæåï¼æ们è°ç¨startæ¹æ³æ¥å¯å¨çº¿ç¨ã
注æï¼çº¿ç¨æ¯å¼æ¥æ§è¡çï¼å æ¤ä¸»çº¿ç¨ä¸ä¼çå¾ çº¿ç¨å®æãå¨ä¸é¢çä¾åä¸ï¼ä¸»çº¿ç¨ä¼ç«å³ç»§ç»æ§è¡ï¼è¾åºMain thread finishedãå¦ææ们å¸æçå¾ çº¿ç¨å®æåå继ç»æ§è¡ä¸»çº¿ç¨ï¼å¯ä»¥ä½¿ç¨joinæ¹æ³ï¼
# çå¾
线ç¨å®æ
t.join()
# 主线ç¨ç»§ç»æ§è¡å
¶ä»ä»»å¡
print("Main thread finished")
å¨ä¸é¢ç代ç ä¸ï¼æ们å¨å¯å¨çº¿ç¨åè°ç¨äºt.join()æ¹æ³ï¼è¿å°é»å¡ä¸»çº¿ç¨ï¼ç´å°çº¿ç¨å®æãç¶åï¼ä¸»çº¿ç¨æä¼ç»§ç»æ§è¡ã
3.å¤çº¿ç¨å ¨å±åé
å¨å¤çº¿ç¨ç¼ç¨ä¸ï¼å¤ä¸ªçº¿ç¨å¯ä»¥å ±äº«å ¨å±åéãä½æ¯éè¦æ³¨æçæ¯ï¼å¤ä¸ªçº¿ç¨åæ¶å¯¹åä¸ä¸ªå ¨å±åéè¿è¡è¯»åæä½æ¶ï¼å¯è½ä¼åºç°æ°æ®ç«äºï¼Data Raceï¼çé®é¢ï¼å¯¼è´ç¨åºåºç°ä¸å¯é¢æçç»æã
为äºé¿å æ°æ®ç«äºï¼å¯ä»¥ä½¿ç¨çº¿ç¨éï¼Thread Lockï¼æ¥ä¿è¯åä¸æ¶å»åªæä¸ä¸ªçº¿ç¨å¯ä»¥è®¿é®å ±äº«åéãPythonä¸æä¾äºLockãRLockãSemaphoreçå¤ç§éæºå¶ï¼å¯ä»¥æ ¹æ®å®é éæ±éæ©åéçéã
ä¸é¢æ¯ä¸ä¸ªä½¿ç¨Lockæ¥ä¿è¯å¤çº¿ç¨å ±äº«å ¨å±åéå®å ¨ç示ä¾ä»£ç ï¼
import threading
# å®ä¹å
¨å±åé
count = 0
# å®ä¹çº¿ç¨é
lock = threading.Lock()
# å®ä¹çº¿ç¨å½æ°
def add():
global count
for i in range(100000):
# è·åé
lock.acquire()
count += 1
# éæ¾é
lock.release()
# å建两个线ç¨
t1 = threading.Thread(target=add)
t2 = threading.Thread(target=add)
# å¯å¨çº¿ç¨
t1.start()
t2.start()
# çå¾
线ç¨æ§è¡å®æ¯
t1.join()
t2.join()
# è¾åºç»æ
print(count)
å¨ä¸é¢ç代ç ä¸ï¼æ们å®ä¹äºä¸ä¸ªå ¨å±åécountï¼å¹¶ä½¿ç¨Lockæ¥ä¿è¯å¤ä¸ªçº¿ç¨å¯¹countè¿è¡è¯»åæä½æ¶çå®å ¨æ§ãå¨æ¯ä¸ªçº¿ç¨ä¸ï¼æ们é¦å è·åéï¼ç¶å对countè¿è¡å 1æä½ï¼æåéæ¾éãè¿æ ·å°±å¯ä»¥ä¿è¯åä¸æ¶å»åªæä¸ä¸ªçº¿ç¨å¯ä»¥è®¿é®countï¼é¿å äºæ°æ®ç«äºçé®é¢ã
éè¦æ³¨æçæ¯ï¼ä½¿ç¨éä¼å¸¦æ¥ä¸å®çæ§è½æ失ï¼å 为æ¯æ¬¡è·åéåéæ¾éé½éè¦ä¸å®çæ¶é´ãå æ¤ï¼å¨å®é åºç¨ä¸ï¼éè¦æ ¹æ®å®é æ åµæ¥éæ©åéçéæºå¶ï¼é¿å è¿åº¦ä½¿ç¨é导è´ç¨åºæ§è½ä¸éã
4.å ±äº«å ¨å±åéæ带æ¥çé®é¢
å¨å¤çº¿ç¨ç¼ç¨ä¸ï¼å¤ä¸ªçº¿ç¨å¯ä»¥å ±äº«å ¨å±åéãä½æ¯ï¼å ±äº«å ¨å±åéä¹ä¼å¸¦æ¥ä¸äºé®é¢ï¼
- ãç«äºæ¡ä»¶ãï¼å½å¤ä¸ªçº¿ç¨åæ¶è®¿é®åä¿®æ¹åä¸ä¸ªå ¨å±åéæ¶ï¼å¯è½ä¼åºç°ç«äºæ¡ä»¶ï¼å¯¼è´ç¨åºåºç°ä¸å¯é¢æµçç»æã
- ãæ°æ®ä¸ä¸è´ãï¼å½å¤ä¸ªçº¿ç¨åæ¶ä¿®æ¹åä¸ä¸ªå ¨å±åéæ¶ï¼å¯è½ä¼å¯¼è´æ°æ®ä¸ä¸è´çé®é¢ï¼å³æäºçº¿ç¨çå°çåéå¼ä¸å ¶ä»çº¿ç¨çå°çä¸åã
- ãæ»éãï¼å½å¤ä¸ªçº¿ç¨åæ¶çå¾ å¯¹æ¹éæ¾æ个èµæºæ¶ï¼å¯è½ä¼åºç°æ»éçæ åµï¼å¯¼è´ç¨åºæ æ³ç»§ç»æ§è¡ã
å æ¤ï¼å¨å¤çº¿ç¨ç¼ç¨ä¸ï¼éè¦æ³¨æå¯¹å ±äº«å ¨å±åéç访é®åä¿®æ¹ï¼é¿å åºç°ä¸è¿°é®é¢ãå¯ä»¥ä½¿ç¨éãæ¡ä»¶åéçæºå¶æ¥ä¿è¯çº¿ç¨ä¹é´çåæ¥åäºæ¥ã
5.解å³çº¿ç¨åæ¶ä¿®æ¹å ¨å±åéçæ¹å¼
å¨å¤çº¿ç¨ç¼ç¨ä¸ï¼å ±äº«å ¨å±åéå¯è½ä¼å¸¦æ¥ä¸äºé®é¢ï¼ä¾å¦ï¼
- ãç«äºæ¡ä»¶ãï¼å¤ä¸ªçº¿ç¨åæ¶ä¿®æ¹åä¸ä¸ªå ¨å±åéï¼å¯è½ä¼å¯¼è´æ°æ®ä¸ä¸è´æè åºç°ææä¹å¤çç»æã
- ãæ»éãï¼å¤ä¸ªçº¿ç¨åæ¶çå¾ å¯¹æ¹éæ¾èµæºï¼å¯¼è´ç¨åºæ æ³ç»§ç»æ§è¡ã
为äºè§£å³è¿äºé®é¢ï¼å¯ä»¥éç¨ä»¥ä¸æ¹å¼ï¼
- ã使ç¨éãï¼å¨è®¿é®å ±äº«åéæ¶ï¼ä½¿ç¨éæ¥ä¿è¯åä¸æ¶å»åªæä¸ä¸ªçº¿ç¨å¯ä»¥ä¿®æ¹åéãPythonä¸æä¾äºthreading模åä¸çLockç±»æ¥å®ç°éã
- ã使ç¨çº¿ç¨å®å ¨çæ°æ®ç»æãï¼Pythonä¸æä¾äºä¸äºçº¿ç¨å®å ¨çæ°æ®ç»æï¼ä¾å¦Queueãdequeçï¼å¯ä»¥å¨å¤çº¿ç¨ç¯å¢ä¸å®å ¨å°è®¿é®åä¿®æ¹æ°æ®ã
- ã使ç¨å±é¨åéãï¼å°å ¨å±åéä½ä¸ºåæ°ä¼ éç»çº¿ç¨å½æ°ï¼è®©çº¿ç¨å½æ°å¨å±é¨åéä¸è¿è¡æä½ï¼é¿å å¤ä¸ªçº¿ç¨åæ¶ä¿®æ¹åä¸ä¸ªå ¨å±åéã
- ã使ç¨çº¿ç¨æ¬å°åå¨ãï¼Pythonä¸æä¾äºthreading模åä¸çlocalç±»ï¼å¯ä»¥å¨æ¯ä¸ªçº¿ç¨ä¸å建ä¸ä¸ªç¬ç«çåéï¼é¿å å¤ä¸ªçº¿ç¨ä¹é´å ±äº«åéã
6.äºæ¥é
å¨å¤çº¿ç¨ç¼ç¨ä¸ï¼äºæ¥éæ¯ä¸ç§å¸¸ç¨çåæ¥æºå¶ï¼ç¨äºä¿æ¤å ±äº«èµæºï¼é²æ¢å¤ä¸ªçº¿ç¨åæ¶ä¿®æ¹åä¸ä¸ªåé导è´æ°æ®ä¸ä¸è´çé®é¢ã
äºæ¥éçåºæ¬ææ³æ¯ï¼å¨è®¿é®å ±äº«èµæºä¹åï¼å è·åéï¼å¦æéå·²ç»è¢«å ¶ä»çº¿ç¨è·åï¼åå½å线ç¨ä¼è¢«é»å¡ï¼ç´å°é被éæ¾ä¸ºæ¢ãå¨è®¿é®å®å ±äº«èµæºä¹åï¼éæ¾éï¼è®©å ¶ä»çº¿ç¨å¯ä»¥è·åé并访é®å ±äº«èµæºã
å¨Pythonä¸ï¼å¯ä»¥ä½¿ç¨threading模åä¸çLockç±»æ¥å®ç°äºæ¥éãLockç±»æ两个åºæ¬æ¹æ³ï¼
- acquire([blocking])ï¼è·åéï¼å¦æéå·²ç»è¢«å ¶ä»çº¿ç¨è·åï¼åå½å线ç¨ä¼è¢«é»å¡ãå¦æblocking为Falseï¼åè·åé失败æ¶ä¼ç«å³è¿åFalseï¼èä¸æ¯é»å¡çå¾ ã
- release()ï¼éæ¾éï¼è®©å ¶ä»çº¿ç¨å¯ä»¥è·åé并访é®å ±äº«èµæºã ä¸é¢æ¯ä¸ä¸ªä½¿ç¨äºæ¥éçä¾åï¼
import threading
# å
±äº«åé
count = 0
# å建äºæ¥é
lock = threading.Lock()
# 线ç¨å½æ°
def worker():
global count
for i in range(100000):
# è·åé
lock.acquire()
try:
count += 1
finally:
# éæ¾é
lock.release()
# å建å¤ä¸ªçº¿ç¨
threads = []
for i in range(10):
t = threading.Thread(target=worker)
threads.append(t)
# å¯å¨çº¿ç¨
for t in threads:
t.start()
# çå¾
ææ线ç¨æ§è¡å®æ¯
for t in threads:
t.join()
# è¾åºç»æ
print(count)
å¨ä¸é¢çä¾åä¸ï¼æ们å建äºä¸ä¸ªå ±äº«åécountï¼å¹¶ä½¿ç¨äºæ¥éæ¥ä¿æ¤å®ãå¨æ¯ä¸ªçº¿ç¨ä¸ï¼æ们å è·åéï¼ç¶åä¿®æ¹countçå¼ï¼æåéæ¾éãè¿æ ·å°±å¯ä»¥ä¿è¯å¤ä¸ªçº¿ç¨ä¸ä¼åæ¶ä¿®æ¹countçå¼ï¼ä»èé¿å äºæ°æ®ä¸ä¸è´çé®é¢ãæåè¾åºcountçå¼ï¼å¯ä»¥çå°å®çå¼ä¸º1000000ï¼ç¬¦åé¢æã
7.æ»é
æ»éæ¯æ两个æå¤ä¸ªçº¿ç¨å¨æ§è¡è¿ç¨ä¸ï¼å äºå¤ºèµæºèé æçä¸ç§äºç¸çå¾ çç°è±¡ï¼è¥æ å¤åå¹²æ¶é£å®ä»¬é½å°æ æ³ç»§ç»æ§è¡ä¸å»ãå¨å¤çº¿ç¨ç¼ç¨ä¸ï¼æ»éæ¯ä¸ç§å¸¸è§çé®é¢ï¼éè¦ç¹å«æ³¨æã
ãæ»éç产çé常éè¦æ»¡è¶³ä»¥ä¸å个æ¡ä»¶ãï¼
- äºæ¥æ¡ä»¶ï¼ä¸ä¸ªèµæºæ¯æ¬¡åªè½è¢«ä¸ä¸ªçº¿ç¨ä½¿ç¨ã
- 请æ±ä¸ä¿ææ¡ä»¶ï¼ä¸ä¸ªçº¿ç¨å 请æ±èµæºèé»å¡æ¶ï¼å¯¹å·²è·å¾çèµæºä¿æä¸æ¾ã
- ä¸å¥å¤ºæ¡ä»¶ï¼çº¿ç¨å·²è·å¾çèµæºï¼å¨æªä½¿ç¨å®ä¹åï¼ä¸è½è¢«å ¶ä»çº¿ç¨å¼ºè¡å¥å¤ºï¼åªè½ç±è¯¥çº¿ç¨èªå·±éæ¾ã
- 循ç¯çå¾ æ¡ä»¶ï¼è¥å¹²çº¿ç¨ä¹é´å½¢æä¸ç§å¤´å°¾ç¸æ¥ç循ç¯çå¾ èµæºçå ³ç³»ã
ã为äºé¿å æ»éç产çï¼å¯ä»¥éç¨ä»¥ä¸å ç§æ¹å¼ãï¼
- é¿å 使ç¨å¤ä¸ªéï¼å°½é使ç¨ä¸ä¸ªéæ¥æ§å¶å¤ä¸ªèµæºç访é®ã
- é¿å ææéçæ¶é´è¿é¿ï¼å°½é缩çéçæææ¶é´ã
- é¿å 循ç¯çå¾ ï¼å°½éæç §åºå®ç顺åºè·åéã
- 使ç¨è¶ æ¶æºå¶ï¼å½çå¾ æ¶é´è¶ è¿ä¸å®æ¶é´åï¼èªå¨éæ¾éï¼é¿å é¿æ¶é´çå¾ é æçæ»éã
8.线ç¨æ±
线ç¨æ± æ¯ä¸ç§çº¿ç¨ç®¡çææ¯ï¼å®å¯ä»¥å¨ç¨åºå¯å¨æ¶å建ä¸å®æ°éç线ç¨ï¼æ¾å ¥ä¸ä¸ªæ± ä¸ï¼å½éè¦ä½¿ç¨çº¿ç¨æ¶ï¼å°±ä»æ± ä¸ååºä¸ä¸ªçº¿ç¨æ§è¡ä»»å¡ï¼ä»»å¡æ§è¡å®æ¯åï¼çº¿ç¨å¹¶ä¸ä¼è¢«éæ¯ï¼èæ¯æ¾åæ± ä¸çå¾ ä¸ä¸æ¬¡ä»»å¡çå°æ¥ã
使ç¨çº¿ç¨æ± å¯ä»¥é¿å é¢ç¹å建åéæ¯çº¿ç¨çå¼éï¼æé«ç¨åºçæ§è½åæçãå¨Pythonä¸ï¼å¯ä»¥ä½¿ç¨æ ååºä¸çconcurrent.futures模åæ¥å®ç°çº¿ç¨æ± ã
ä¸é¢æ¯ä¸ä¸ªç®åç线ç¨æ± 示ä¾ï¼
import concurrent.futures
import time
def worker(num):
print(f"Thread-{num} started")
time.sleep(1)
print(f"Thread-{num} finished")
if __name__ == '__main__':
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
for i in range(5):
executor.submit(worker, i)
å¨è¿ä¸ªç¤ºä¾ä¸ï¼æ们å建äºä¸ä¸ªå å«3个线ç¨ç线ç¨æ± ï¼ç¶åæ交äº5个任å¡ç»çº¿ç¨æ± æ§è¡ãç±äºçº¿ç¨æ± ä¸åªæ3个线ç¨ï¼å æ¤åªæ3个任å¡ä¼åæ¶æ§è¡ï¼å ¶ä½çä»»å¡ä¼çå¾ ç©ºé²çº¿ç¨çåºç°ã
è¾åºç»æå¦ä¸ï¼
Thread-0 started
Thread-1 started
Thread-2 started
Thread-0 finished
Thread-3 started
Thread-1 finished
Thread-4 started
Thread-2 finished
Thread-3 finished
Thread-4 finished
å¯ä»¥çå°ï¼çº¿ç¨æ± ä¸ç3个线ç¨ä¾æ¬¡æ§è¡äº5个任å¡ï¼ä»»å¡çæ§è¡é¡ºåºä¸æ交ç顺åºæ å ³ã
第äºç« ï¼å¤è¿ç¨
1.è¿ç¨çç¶æ
ãå¨æä½ç³»ç»ä¸ï¼è¿ç¨æ以ä¸å ç§ç¶æãï¼
- ã就绪ç¶æï¼Readyï¼ãï¼è¿ç¨å·²ç»åå¤å¥½è¿è¡ï¼çå¾ åé CPUæ¶é´çã
- ãè¿è¡ç¶æï¼Runningï¼ãï¼è¿ç¨æ£å¨è¿è¡ï¼å ç¨CPUæ¶é´çã
- ãé»å¡ç¶æï¼Blockedï¼ãï¼è¿ç¨å 为æäºåå æ æ³ç»§ç»æ§è¡ï¼ä¾å¦çå¾ I/Oæä½å®ææçå¾ æ个èµæºçéæ¾ã
- ãæèµ·ç¶æï¼Suspendedï¼ãï¼è¿ç¨è¢«æåï¼ä¸åå ç¨CPUæ¶é´çï¼ä½æ¯å®çç¶æä¿¡æ¯ä»ç¶ä¿åå¨å åä¸ã
- ãç»æ¢ç¶æï¼Terminatedï¼ãï¼è¿ç¨å·²ç»å®ææ§è¡æ被强å¶ç»æ¢ã
è¿ç¨çç¶æ转æ¢é常æ¯ç±æä½ç³»ç»å æ ¸è¿è¡æ§å¶çï¼ä¾å¦å½ä¸ä¸ªè¿ç¨çå¾ I/Oæä½å®ææ¶ï¼æä½ç³»ç»ä¼å°è¯¥è¿ç¨çç¶æä»å°±ç»ªç¶æ转æ¢ä¸ºé»å¡ç¶æï¼å½I/Oæä½å®æåï¼æä½ç³»ç»ä¼å°è¯¥è¿ç¨çç¶æä»é»å¡ç¶æ转æ¢ä¸ºå°±ç»ªç¶æï¼çå¾ åé CPUæ¶é´çã
2.线ç¨çå建-multiprocessing
å¨ Python ä¸ï¼å¯ä»¥ä½¿ç¨ multiprocessing 模åæ¥å建å¤è¿ç¨ãmultiprocessing 模åæä¾äºä¸ä¸ª Process ç±»ï¼å¯ä»¥ç¨æ¥å建è¿ç¨ãä¸é¢æ¯ä¸ä¸ªç®åçä¾åï¼
import multiprocessing
def worker():
"""åè¿ç¨è¦æ§è¡çä»»å¡"""
print('Worker')
if __name__ == '__main__':
# å建åè¿ç¨
p = multiprocessing.Process(target=worker)
# å¯å¨åè¿ç¨
p.start()
# çå¾
åè¿ç¨ç»æ
p.join()
å¨ä¸é¢çä¾åä¸ï¼æ们é¦å å®ä¹äºä¸ä¸ª worker å½æ°ï¼å®æ¯åè¿ç¨è¦æ§è¡çä»»å¡ãç¶åï¼æä»¬ä½¿ç¨ multiprocessing.Process ç±»å建äºä¸ä¸ªåè¿ç¨ï¼å¹¶å° worker å½æ°ä½ä¸ºåæ°ä¼ éç»äº Process ç±»çæé å½æ°ãæ¥çï¼æ们è°ç¨ start æ¹æ³å¯å¨åè¿ç¨ï¼æåè°ç¨ join æ¹æ³çå¾ åè¿ç¨ç»æã
éè¦æ³¨æçæ¯ï¼å¨ Windows ç³»ç»ä¸ï¼ç±äº multiprocessing 模å使ç¨äº fork ç³»ç»è°ç¨ï¼è Windows ä¸æ¯æ forkï¼å æ¤éè¦å¨ if __name__ == '__main__': è¯å¥ä¸è°ç¨åè¿ç¨ç代ç ãè¿æ¯å ä¸ºå¨ Windows ä¸ï¼æ¯ä¸ªè¿ç¨é½ä¼æ§è¡ä¸éç¨åºçææ代ç ï¼è if __name__ == '__main__': è¯å¥å¯ä»¥ä¿è¯åè¿ç¨åªä¼æ§è¡æå®ç代ç ã
3.è¿ç¨ä¸¶çº¿ç¨å¯¹æ¯
è¿ç¨å线ç¨é½æ¯å®ç°å¹¶åç¼ç¨çæ¹å¼ï¼ä½æ¯å®ä»¬æ以ä¸ä¸åç¹ï¼
- ãèµæºå ç¨ãï¼è¿ç¨æ¥æç¬ç«çå å空é´ï¼è线ç¨å ±äº«è¿ç¨çå å空é´ãå æ¤ï¼å建è¿ç¨çå¼éæ¯å建线ç¨å¤§ï¼åæ¶è¿ç¨é´çéä¿¡ä¹æ¯çº¿ç¨é´çéä¿¡å¤æã
- ã并åæ§ãï¼ç±äºçº¿ç¨å ±äº«è¿ç¨çå å空é´ï¼å æ¤çº¿ç¨é´çéä¿¡åæ°æ®å ±äº«æ¯è¿ç¨é´çéä¿¡åæ°æ®å ±äº«æ´å®¹æãåæ¶ï¼çº¿ç¨çåæ¢æ¯è¿ç¨çåæ¢æ´å¿«ï¼å æ¤çº¿ç¨ç并åæ§æ¯è¿ç¨é«ã
- ãå®å ¨æ§ãï¼ç±äºçº¿ç¨å ±äº«è¿ç¨çå å空é´ï¼å æ¤å¤ä¸ªçº¿ç¨åæ¶è®¿é®åä¸åå åæ¶ï¼å¯è½ä¼åºç°ç«äºæ¡ä»¶ï¼å¯¼è´æ°æ®ä¸ä¸è´æè ç¨åºå´©æºãèè¿ç¨ä¹é´çå å空é´æ¯ç¬ç«çï¼å æ¤è¿ç¨é´çæ°æ®ä¸ä¼ç¸äºå½±åã
- ãç¼ç¨å¤æ度ãï¼ç±äºè¿ç¨é´çéä¿¡åæ°æ®å ±äº«æ¯è¾å¤æï¼å æ¤ç¼åå¤è¿ç¨ç¨åºçå¤æ度æ¯ç¼åå¤çº¿ç¨ç¨åºçå¤æ度é«ã
æ»çæ¥è¯´ï¼è¿ç¨éåäºCPUå¯éåä»»å¡ï¼è线ç¨éåäºIOå¯éåä»»å¡ãå¨å®é åºç¨ä¸ï¼éè¦æ ¹æ®å ·ä½çåºæ¯éæ©åéç并åç¼ç¨æ¹å¼ã
4.è¿ç¨é´çéä¿¡-Queue
å¨å¤è¿ç¨ç¼ç¨ä¸ï¼ä¸åè¿ç¨ä¹é´çæ°æ®æ¯æ æ³ç´æ¥å ±äº«çï¼å 为æ¯ä¸ªè¿ç¨é½æèªå·±ç¬ç«çå å空é´ãå æ¤ï¼ä¸ºäºå®ç°è¿ç¨é´çéä¿¡ï¼æ们éè¦ä½¿ç¨ä¸äºç¹æ®çæºå¶ã
å ¶ä¸ï¼æ常ç¨çè¿ç¨é´éä¿¡æ¹å¼æ¯ä½¿ç¨éåï¼Queueï¼ãéåæ¯ä¸ç§å è¿å åºï¼FIFOï¼çæ°æ®ç»æï¼å¯ä»¥ç¨æ¥å¨å¤ä¸ªè¿ç¨ä¹é´ä¼ éæ°æ®ã
å¨Pythonä¸ï¼æ们å¯ä»¥ä½¿ç¨multiprocessing模åä¸çQueueç±»æ¥å®ç°è¿ç¨é´éä¿¡ãQueueç±»æä¾äºput()åget()æ¹æ³ï¼ç¨äºåéåä¸æ·»å æ°æ®åä»éåä¸ååºæ°æ®ã
ä¸é¢æ¯ä¸ä¸ªç®åçä¾åï¼æ¼ç¤ºäºå¦ä½ä½¿ç¨Queueå®ç°è¿ç¨é´éä¿¡ï¼
from multiprocessing import Process, Queue
def worker(q):
while True:
item = q.get()
if item is None:
break
print(item)
if __name__ == '__main__':
q = Queue()
p = Process(target=worker, args=(q,))
p.start()
for i in range(10):
q.put(i)
q.put(None)
p.join()
å¨è¿ä¸ªä¾åä¸ï¼æ们å建äºä¸ä¸ªè¿ç¨pï¼å®çå·¥ä½æ¯ä»éåqä¸ååºæ°æ®å¹¶æå°åºæ¥ã主è¿ç¨åéåä¸æ·»å äº10个æ°æ®ï¼ç¶ååæ·»å ä¸ä¸ªNoneï¼è¡¨ç¤ºæ°æ®å·²ç»å ¨é¨æ·»å å®æ¯ãæåï¼ä¸»è¿ç¨çå¾ è¿ç¨pæ§è¡å®æ¯ã
éè¦æ³¨æçæ¯ï¼å½æ们åéåä¸æ·»å æ°æ®æ¶ï¼å¦æéå已满ï¼put()æ¹æ³ä¼é»å¡ï¼ç´å°éåä¸æ空é²ä½ç½®ãåæ ·å°ï¼å½æ们ä»éåä¸ååºæ°æ®æ¶ï¼å¦æéå为空ï¼get()æ¹æ³ä¹ä¼é»å¡ï¼ç´å°éåä¸ææ°æ®å¯åã
é¤äºQueueä¹å¤ï¼Pythonä¸è¿æä¾äºä¸äºå ¶ä»çè¿ç¨é´éä¿¡æ¹å¼ï¼æ¯å¦PipeãValueåArrayçãè¿äºæ¹å¼åæç¹ç¹ï¼å¯ä»¥æ ¹æ®å ·ä½çéæ±éæ©åéçæ¹å¼
5.è¿ç¨æ± çå建-pool
å¨Pythonä¸ï¼æ们å¯ä»¥ä½¿ç¨multiprocessing模åä¸çPoolç±»æ¥å建è¿ç¨æ± ãè¿ç¨æ± æ¯ä¸ç»å¯éç¨çè¿ç¨ï¼å¯ä»¥å¨éè¦æ¶åé ç»ä»»å¡ãè¿æ ·å¯ä»¥é¿å é¢ç¹å°å建åéæ¯è¿ç¨ï¼ä»èæé«ç¨åºçæçã
ä¸é¢æ¯ä¸ä¸ªä½¿ç¨è¿ç¨æ± çä¾åï¼
import multiprocessing
def worker(num):
"""è¿ç¨æ± ä¸çä»»å¡"""
print('Worker %d is running' % num)
if __name__ == '__main__':
# å建è¿ç¨æ± ï¼æ± ä¸æ3个è¿ç¨
pool = multiprocessing.Pool(processes=3)
# åè¿ç¨æ± ä¸æ·»å ä»»å¡
for i in range(5):
pool.apply_async(worker, args=(i,))
# å
³éè¿ç¨æ± ï¼ä¸åæ¥åæ°çä»»å¡
pool.close()
# çå¾
ææä»»å¡å®æ
pool.join()
print('All workers done.')
å¨è¿ä¸ªä¾åä¸ï¼æ们é¦å å建äºä¸ä¸ªè¿ç¨æ± ï¼æ± ä¸æ3个è¿ç¨ãç¶ååè¿ç¨æ± ä¸æ·»å äº5个任å¡ï¼æ¯ä¸ªä»»å¡é½æ¯è°ç¨workerå½æ°ãæåï¼æä»¬å ³éäºè¿ç¨æ± ï¼å¹¶çå¾ ææä»»å¡å®æã
éè¦æ³¨æçæ¯ï¼è¿ç¨æ± ä¸çä»»å¡å¿ é¡»æ¯å¯åºååçï¼å 为è¿ç¨æ± ä¼å°ä»»å¡åéç»åè¿ç¨æ§è¡ãå¦æä»»å¡ä¸å å«ä¸å¯åºååç对象ï¼ä¼å¯¼è´è¿ç¨æ± æ æ³æ£å¸¸å·¥ä½ã
第ä¸ç« ï¼åç¨
åç¨æ¯ä¸ç§è½»é级ç线ç¨ï¼ä¹ç§°ä¸ºå¾®çº¿ç¨æè ç¨æ·çº§çº¿ç¨ãåç¨çç¹ç¹æ¯å¨ä¸ä¸ªçº¿ç¨ä¸ï¼å¯ä»¥æå¤ä¸ªåç¨ï¼åç¨ä¹é´å¯ä»¥ç¸äºåæ¢ï¼ä»èå®ç°å¹¶åæ§è¡ã
å¨Pythonä¸ï¼åç¨æ¯éè¿çæå¨å®ç°çãéè¿yieldå ³é®åï¼å¯ä»¥å°ä¸ä¸ªå½æ°åæä¸ä¸ªçæå¨ï¼ä»èå®ç°åç¨çåè½ãå¨åç¨ä¸ï¼å¯ä»¥ä½¿ç¨yieldå ³é®åæ¥æåå½æ°çæ§è¡ï¼å¹¶è¿åä¸ä¸ªå¼ç»è°ç¨è ãå½åç¨å次被è°ç¨æ¶ï¼å¯ä»¥ä»ä¸ä¸æ¬¡æåçä½ç½®ç»§ç»æ§è¡ã
Pythonä¸çåç¨æ两ç§å®ç°æ¹å¼ï¼ä½¿ç¨çæå¨å®ç°çåç¨å使ç¨async/awaitå ³é®åå®ç°çåç¨ã
ã使ç¨çæå¨å®ç°çåç¨ãï¼
def coroutine():
while True:
value = yield
print('Received value:', value)
c = coroutine()
next(c) # å¯å¨åç¨
c.send(10) # åéå¼ç»åç¨
ã使ç¨async/awaitå ³é®åå®ç°çåç¨ãï¼
import asyncio
async def coroutine():
while True:
value = await asyncio.sleep(1)
print('Received value:', value)
loop = asyncio.get_event_loop()
loop.run_until_complete(coroutine())
å¨ä½¿ç¨async/awaitå ³é®åå®ç°çåç¨ä¸ï¼éè¦ä½¿ç¨asyncio模åæä¾çäºä»¶å¾ªç¯æ¥è¿è¡åç¨ãå¨åç¨ä¸ï¼å¯ä»¥ä½¿ç¨awaitå ³é®åæ¥æåå½æ°çæ§è¡ï¼å¹¶çå¾ ä¸ä¸ªå¼æ¥æä½å®æãå½å¼æ¥æä½å®æåï¼åç¨ä¼ä»awaitè¯å¥å¤ç»§ç»æ§è¡ã
åç¨çä¼ç¹æ¯å¯ä»¥é¿å 线ç¨åæ¢çå¼éï¼ä»èæé«ç¨åºçæ§è½ãåæ¶ï¼åç¨ä¹å¯ä»¥é¿å 线ç¨ä¹é´çç«äºæ¡ä»¶åæ»éé®é¢ãä½æ¯ï¼åç¨ä¹æä¸äºç¼ºç¹ï¼ä¾å¦ä¸è½å©ç¨å¤æ ¸CPUçä¼å¿ï¼ä»¥åä¸è½è¿è¡é»å¡å¼IOæä½ã
1.åç¨çæä¹
åç¨æ¯ä¸ç§è½»é级ç线ç¨ï¼å¯ä»¥å¨å个线ç¨ä¸å®ç°å¹¶åãä¸çº¿ç¨ç¸æ¯ï¼åç¨çåæ¢å¼éæ´å°ï¼å¯ä»¥æ´é«æå°å©ç¨CPUèµæºãåç¨çæä¹å¨äºï¼
- ãæé«ç¨åºç并åæ§è½ãï¼åç¨å¯ä»¥å¨å个线ç¨ä¸å®ç°å¹¶åï¼é¿å äºçº¿ç¨åæ¢çå¼éï¼æé«äºç¨åºç并åæ§è½ã
- ãç®åç¼ç¨æ¨¡åãï¼åç¨å¯ä»¥ä½¿ç¨åæ¥çç¼ç¨æ¨¡åï¼é¿å äºå¤æç线ç¨åæ¥é®é¢ï¼ä½¿å¾ç¼ç¨æ´å ç®åã
- ãæ¯æé«å¹¶åãï¼åç¨å¯ä»¥æ¯æ大éç并åä»»å¡ï¼å¯ä»¥ç¨äºé«å¹¶åçç½ç»ç¼ç¨ãç¬è«çåºæ¯ã
- ãæé«ä»£ç å¯è¯»æ§ãï¼åç¨å¯ä»¥ä½¿ç¨åæ¥çç¼ç¨æ¨¡åï¼ä»£ç å¯è¯»æ§æ´é«ï¼æäºç»´æ¤ã
æ»ä¹ï¼åç¨æ¯ä¸ç§é«æãç®åãå¯è¯»æ§å¼ºç并åç¼ç¨æ¨¡åï¼å¯ä»¥æé«ç¨åºç并åæ§è½ï¼æ¯æé«å¹¶åï¼ç®åç¼ç¨æ¨¡åã
2.asyncioäºä»¶å¾ªç¯
å¨Pythonä¸ï¼åç¨æ¯ä¸ç§è½»é级ç并åç¼ç¨æ¹å¼ï¼å®å¯ä»¥å¨å线ç¨ä¸å®ç°å¹¶åæ§è¡ãåç¨çæä¹å¨äºå¯ä»¥æé«ç¨åºç并åæ§è½ï¼åå°çº¿ç¨åæ¢çå¼éï¼åæ¶ä¹å¯ä»¥ç®åç¼ç¨æ¨¡åï¼ä½¿å¾ä»£ç æ´å æäºç解åç»´æ¤ã
å¨Python 3.4å以ä¸çæ¬ä¸ï¼æ ååºä¸æä¾äºasyncio模åï¼å®æ¯Pythonä¸å®ç°åç¨ç主è¦æ¹å¼ä¹ä¸ãasyncio模åæä¾äºä¸ä¸ªäºä»¶å¾ªç¯ï¼Event Loopï¼ï¼å®å¯ä»¥å¨å线ç¨ä¸å®ç°å¤ä¸ªåç¨ç并åæ§è¡ãäºä»¶å¾ªç¯ä¼ä¸æå°ä»åç¨éåä¸ååºåç¨å¹¶æ§è¡ï¼å½åç¨éå°IOæä½æ¶ï¼ä¼èªå¨æ起并åæ¢å°å ¶ä»åç¨æ§è¡ï¼çå¾ IOæä½å®æååæ¢å¤æ§è¡ã
asyncioäºä»¶å¾ªç¯ç使ç¨æ¹å¼å¦ä¸ï¼
ã1.å建ä¸ä¸ªäºä»¶å¾ªç¯å¯¹è±¡ãï¼
import asyncio
loop = asyncio.get_event_loop()
ã2.å°åç¨å¯¹è±¡å å ¥äºä»¶å¾ªç¯ä¸ãï¼
async def coroutine():
# åç¨ä»£ç
loop.run_until_complete(coroutine())
ã3.å¯å¨äºä»¶å¾ªç¯ãï¼
loop.run_forever()
å¨äºä»¶å¾ªç¯ä¸ï¼å¯ä»¥ä½¿ç¨async/awaitå ³é®åå®ä¹åç¨å½æ°ï¼ä½¿ç¨asyncio模åæä¾çåç§æ¹æ³å®ç°åç¨ä¹é´çéä¿¡ååä½ãä¾å¦ï¼å¯ä»¥ä½¿ç¨asyncio.sleep()æ¹æ³å®ç°åç¨ç延æ¶æä½ï¼ä½¿ç¨asyncio.wait()æ¹æ³çå¾ å¤ä¸ªåç¨çå®æçã
3.awaitå ³é®å
å¨Pythonä¸ï¼awaitæ¯ä¸ä¸ªå ³é®åï¼ç¨äºçå¾ ä¸ä¸ªåç¨å®æãå½ä¸ä¸ªåç¨è°ç¨å¦ä¸ä¸ªåç¨æ¶ï¼å®å¯ä»¥ä½¿ç¨awaitå ³é®åæ¥çå¾ å¦ä¸ä¸ªåç¨å®æ并è¿åç»æãå¨çå¾ æé´ï¼å½ååç¨ä¼è¢«æèµ·ï¼ç´å°è¢«çå¾ çåç¨å®æã
ä¾å¦ï¼å设æ两个åç¨AåBï¼Aéè¦çå¾ Bå®æåæè½ç»§ç»æ§è¡ãå¨åç¨Aä¸ï¼å¯ä»¥ä½¿ç¨awaitå ³é®åæ¥çå¾ åç¨Bå®æï¼
async def coroutine_b():
# åç¨Bç代ç
async def coroutine_a():
# åç¨Aç代ç
result = await coroutine_b()
# 继ç»æ§è¡åç¨Aç代ç
å¨è¿ä¸ªä¾åä¸ï¼å½åç¨Aè°ç¨await coroutine_b()æ¶ï¼å®ä¼çå¾ åç¨Bå®æ并è¿åç»æãå¨çå¾ æé´ï¼åç¨Aä¼è¢«æèµ·ï¼ç´å°åç¨Bå®æãä¸æ¦åç¨Bå®æ并è¿åç»æï¼åç¨Aä¼ç»§ç»æ§è¡ã
使ç¨awaitå ³é®åå¯ä»¥ä½¿åç¨ä¹é´çè°ç¨æ´å ç®æ´åç´è§ï¼åæ¶ä¹å¯ä»¥é¿å 使ç¨åè°å½æ°çå¤æçå¼æ¥ç¼ç¨æ¨¡å¼ã
4.concurrentåfuture对象
å¨Pythonä¸ï¼asyncio模åæä¾äºä¸ç§åºäºåç¨çå¼æ¥ç¼ç¨æ¹å¼ãå¨åç¨ä¸ï¼æ们å¯ä»¥ä½¿ç¨async/awaitå ³é®åæ¥å®ä¹å¼æ¥å½æ°ï¼ä½¿ç¨asyncio模åæä¾çäºä»¶å¾ªç¯æ¥è°åº¦åç¨çæ§è¡ã
é¤äºåç¨ä¹å¤ï¼asyncioè¿æä¾äºä¸äºå ¶ä»ç并åç¼ç¨å·¥å ·ï¼å æ¬concurrentåfuture对象ã
- concurrent对象
concurrent对象æ¯asyncioä¸çä¸ä¸ªéè¦æ¦å¿µï¼å®è¡¨ç¤ºä¸ä¸ªåç¨çæ§è¡ç¶æãå¨asyncioä¸ï¼æ们å¯ä»¥ä½¿ç¨asyncio.create_task()å½æ°æ¥å建ä¸ä¸ªconcurrent对象ï¼è¯¥å½æ°æ¥åä¸ä¸ªåç¨å¯¹è±¡ä½ä¸ºåæ°ï¼å¹¶è¿åä¸ä¸ªconcurrent对象ã
ä¾å¦ï¼ä¸é¢ç代ç å建äºä¸ä¸ªåç¨å¯¹è±¡ï¼å¹¶ä½¿ç¨create_task()å½æ°å°å ¶è½¬æ¢ä¸ºconcurrent对象ï¼
import asyncio
async def my_coroutine():
print('Coroutine started')
await asyncio.sleep(1)
print('Coroutine ended')
async def main():
task = asyncio.create_task(my_coroutine())
await task
asyncio.run(main())
å¨ä¸é¢ç代ç ä¸ï¼æ们使ç¨create_task()å½æ°å°my_coroutine()å½æ°è½¬æ¢ä¸ºconcurrent对象ï¼å¹¶å°å ¶èµå¼ç»taskåéãç¶åï¼æ们使ç¨awaitå ³é®åçå¾ task对象çå®æã
- future对象
future对象æ¯asyncioä¸çå¦ä¸ä¸ªéè¦æ¦å¿µï¼å®è¡¨ç¤ºä¸ä¸ªå¼æ¥æä½çç»æãå¨asyncioä¸ï¼æ们å¯ä»¥ä½¿ç¨asyncio.Future()å½æ°æ¥å建ä¸ä¸ªfuture对象ï¼è¯¥å½æ°è¿åä¸ä¸ªæªå®æçfuture对象ã
ä¾å¦ï¼ä¸é¢ç代ç å建äºä¸ä¸ªæªå®æçfuture对象ï¼
import asyncio
async def my_coroutine():
print('Coroutine started')
await asyncio.sleep(1)
print('Coroutine ended')
return 'Result'
async def main():
future = asyncio.Future()
await asyncio.sleep(1)
future.set_result(await my_coroutine())
print(future.result())
asyncio.run(main())
å¨ä¸é¢ç代ç ä¸ï¼æ们使ç¨asyncio.Future()å½æ°å建äºä¸ä¸ªæªå®æçfuture对象ï¼å¹¶å°å ¶èµå¼ç»futureåéãç¶åï¼æ们使ç¨awaitå ³é®åçå¾ 1ç§éï¼ç¶åè°ç¨my_coroutine()å½æ°ï¼å¹¶å°å ¶ç»æ设置为future对象çç»æãæåï¼æ们æå°future对象çç»æã
5.asyncioå¼æ¥è¿ä»£å¨åä¸ä¸æ管ç
é¤äºconcurrentåfuture对象ä¹å¤ï¼asyncioè¿æä¾äºä¸äºå ¶ä»ç并åç¼ç¨å·¥å ·ï¼å æ¬å¼æ¥è¿ä»£å¨åä¸ä¸æ管çã
å¼æ¥è¿ä»£å¨æ¯ä¸ç§ç¹æ®çè¿ä»£å¨ï¼å®å¯ä»¥å¨å¼æ¥ç¯å¢ä¸ä½¿ç¨ãå¨asyncioä¸ï¼æ们å¯ä»¥ä½¿ç¨async for循ç¯æ¥éåå¼æ¥è¿ä»£å¨ã
ä¾å¦ï¼ä¸é¢ç代ç 使ç¨async for循ç¯éåä¸ä¸ªå¼æ¥è¿ä»£å¨ï¼
import asyncio
async def my_coroutine():
for i in range(5):
await asyncio.sleep(1)
yield i
async def main():
async for i in my_coroutine():
print(i)
asyncio.run(main())
å¨ä¸é¢ç代ç ä¸ï¼æ们å®ä¹äºä¸ä¸ªå¼æ¥çæå¨å½æ°my_coroutine()ï¼å®ä½¿ç¨yieldè¯å¥è¿åä¸ä¸ªå¼ï¼å¹¶å¨æ¯æ¬¡è¿åå¼ä¹é´æå1ç§éãç¶åï¼æ们使ç¨async for循ç¯éåmy_coroutine()å½æ°è¿åçå¼æ¥è¿ä»£å¨ï¼å¹¶æå°æ¯ä¸ªè¿åå¼ã
ä¸ä¸æ管çæ¯ä¸ç§å¨å¼æ¥ç¯å¢ä¸ç®¡çèµæºçæ¹å¼ãå¨asyncioä¸ï¼æ们å¯ä»¥ä½¿ç¨async withè¯å¥æ¥ç®¡çå¼æ¥ä¸ä¸æã
ä¾å¦ï¼ä¸é¢ç代ç 使ç¨async withè¯å¥ç®¡çä¸ä¸ªå¼æ¥ä¸ä¸æï¼
import asyncio
class MyContext:
async def __aenter__(self):
print('Entering context')
await asyncio.sleep(1)
return self
async def __aexit__(self, exc_type, exc, tb):
print('Exiting context')
await asyncio.sleep(1)
async def main():
async with MyContext() as context:
print('Inside context')
asyncio.run(main())
å¨ä¸é¢ç代ç ä¸ï¼æ们å®ä¹äºä¸ä¸ªMyContextç±»ï¼å®å®ç°äº__aenter__()å__aexit__()æ¹æ³ãaenter()æ¹æ³å¨è¿å ¥ä¸ä¸ææ¶è¢«è°ç¨ï¼aexit()æ¹æ³å¨éåºä¸ä¸ææ¶è¢«è°ç¨ãå¨main()å½æ°ä¸ï¼æ们使ç¨async withè¯å¥ç®¡çMyContext对象ï¼å¹¶å¨ä¸ä¸æä¸æå°ä¸æ¡æ¶æ¯ãå½æ们è¿å ¥åéåºä¸ä¸ææ¶ï¼aenter()å__aexit__()æ¹æ³ä¼è¢«è°ç¨ï¼å¹¶æå1ç§éã
6.å¼æ¥æä½MySQL
å¨Pythonä¸ï¼æ们å¯ä»¥ä½¿ç¨å¼æ¥IOåºasyncioæ¥å®ç°å¼æ¥æä½MySQLæ°æ®åºãä¸é¢æ¯ä¸ä¸ªç®åç示ä¾ï¼
import asyncio
import aiomysql
async def test_mysql():
# è¿æ¥MySQLæ°æ®åº
conn = await aiomysql.connect(host='localhost', port=3306,
user='root', password='password',
db='test', charset='utf8mb4')
# å建游æ
cur = await conn.cursor()
# æ§è¡SQLè¯å¥
await cur.execute("SELECT * FROM users")
# è·åæ¥è¯¢ç»æ
result = await cur.fetchall()
# è¾åºæ¥è¯¢ç»æ
print(result)
# å
³é游æ åè¿æ¥
await cur.close()
conn.close()
# è¿è¡å¼æ¥å½æ°
loop = asyncio.get_event_loop()
loop.run_until_complete(test_mysql())
å¨ä¸é¢ç示ä¾ä¸ï¼æ们使ç¨äºaiomysqlåºæ¥è¿æ¥MySQLæ°æ®åºï¼å¹¶ä½¿ç¨async/awaitè¯æ³æ¥æ§è¡å¼æ¥æä½ãé¦å ï¼æ们使ç¨aiomysql.connect()æ¹æ³æ¥è¿æ¥MySQLæ°æ®åºï¼ç¶å使ç¨await conn.cursor()æ¹æ³å建游æ ï¼ä½¿ç¨await cur.execute()æ¹æ³æ§è¡SQLè¯å¥ï¼ä½¿ç¨await cur.fetchall()æ¹æ³è·åæ¥è¯¢ç»æï¼æå使ç¨await cur.close()æ¹æ³å ³é游æ ï¼ä½¿ç¨conn.close()æ¹æ³å ³éè¿æ¥ã
éè¦æ³¨æçæ¯ï¼å¨ä½¿ç¨aiomysqlåºæ¶ï¼æ们éè¦å¨è¿æ¥MySQLæ°æ®åºæ¶æå®charset='utf8mb4'ï¼ä»¥æ¯æä¸æå符éã
7.å¼æ¥ç¬è«
å¼æ¥ç¬è«æ¯æ使ç¨åç¨æ¥å®ç°ç¬è«ç¨åºï¼éè¿å¼æ¥éé»å¡çæ¹å¼æ¥æé«ç¬åæçãå¨Pythonä¸ï¼å¯ä»¥ä½¿ç¨asyncioåºæ¥å®ç°å¼æ¥ç¬è«ã
ä¸é¢æ¯ä¸ä¸ªç®åçå¼æ¥ç¬è«ç¤ºä¾ï¼
import asyncio
import aiohttp
from bs4 import BeautifulSoup
async def fetch(session, url):
async with session.get(url) as response:
return await response.text()
async def get_links(session, url):
html = await fetch(session, url)
soup = BeautifulSoup(html, 'html.parser')
links = []
for link in soup.find_all('a'):
href = link.get('href')
if href and href.startswith('http'):
links.append(href)
return links
async def main():
async with aiohttp.ClientSession() as session:
links = await get_links(session, 'https://www.baidu.com')
for link in links:
print(link)
if __name__ == '__main__':
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
å¨è¿ä¸ªç¤ºä¾ä¸ï¼æ们使ç¨äºaiohttpåºæ¥åéå¼æ¥HTTP请æ±ï¼ä½¿ç¨BeautifulSoupåºæ¥è§£æHTML页é¢ï¼ä½¿ç¨asyncioåºæ¥å®ç°åç¨ã
é¦å å®ä¹äºä¸ä¸ªfetchå½æ°ï¼ç¨äºåéHTTP请æ±å¹¶è¿åååºå 容ãç¶åå®ä¹äºä¸ä¸ªget_linkså½æ°ï¼ç¨äºè·å页é¢ä¸çææé¾æ¥ãæåï¼å¨mainå½æ°ä¸ä½¿ç¨aiohttpåºå建ä¸ä¸ªå¼æ¥HTTP客æ·ç«¯ä¼è¯ï¼è°ç¨get_linkså½æ°è·åé¾æ¥ï¼å¹¶æå°åºæ¥ã
éè¦æ³¨æçæ¯ï¼å¨ä½¿ç¨aiohttpåºæ¶ï¼éè¦ä½¿ç¨async withè¯å¥æ¥å建ä¸ä¸ªå¼æ¥HTTP客æ·ç«¯ä¼è¯ï¼ä»¥ç¡®ä¿ä¼è¯å¨ä½¿ç¨å®æ¯åè½å¤æ£ç¡®å ³éã
pythonææ¡£+ç¬è®°+äºè§£æ¥å+æºç è·åæ¹å¼
ãéç¨äºé¶åºç¡å¦ä¹ åè¿é¶äººç¾¤çpythonèµæºï¼ã
ãâ è ¾è®¯è®¤è¯pythonå®æ´é¡¹ç®å®ææç¨ç¬è®°PDFã
ãâ¡ åå 个大åpythoné¢è¯ä¸é¢PDFã
ã⢠pythonå ¨å¥è§é¢æç¨ï¼é¶åºç¡-é«çº§è¿é¶JSéåï¼ã
ã⣠ç¾ä¸ªé¡¹ç®å®æ+æºç +ç¬è®°ã
ã⤠ç¼ç¨è¯æ³-æºå¨å¦ä¹ -å ¨æ å¼å-æ°æ®åæ-ç¬è«-APPéåçå ¨å¥é¡¹ç®+ææ¡£ã
ã⥠交æµå¦ä¹ ã
ã⦠æ³è¦å ¼èæ¥åã
ãä¸ç« 讲ï¼pythonæ°æ®åºç¼ç¨ã