Heim >Backend-Entwicklung >Python-Tutorial >Was für ein Artefakt! Ein effizientes Python-Crawler-Framework, das einfacher zu verwenden ist als Anfragen!
Was für ein Artefakt! Ein effizientes Python-Crawler-Framework, das einfacher zu verwenden ist als Anfragen!
- WBOYnach vorne
- 2023-04-13 14:25:031441Durchsuche
Kürzlich wurde das Python-Back-End-Projekt des Unternehmens umstrukturiert und die gesamte Back-End-Logik grundsätzlich geändert, um eine „asynchrone“ Coroutine-Implementierung zu verwenden. Als ich den Bildschirm voller Code betrachtete, der mit Async Await (der Implementierung von Coroutinen in Python) dekoriert war, fühlte ich mich plötzlich verwirrt und ratlos.
Obwohl ich schon früher gelernt habe, was eine „Coroutine“ ist, habe ich sie noch nicht eingehend erforscht, also habe ich diese Gelegenheit einfach genutzt, um sie sorgfältig zu lernen. Was ist eine Coroutine?
Einfach ausgedrückt ist Coroutine eine Art Existenz, die auf Threads basiert, aber leichter als Threads ist. Für den Systemkernel haben Coroutinen unsichtbare Eigenschaften, daher wird dieser leichtgewichtige Thread, der von Programmierern verwaltet wird, die ihre eigenen Programme schreiben, oft als „User Space Thread“ bezeichnet. Was sind die Vorteile von Coroutine gegenüber Multithreading?
1. Die Kontrolle über den Thread liegt in den Händen des Betriebssystems, während die Kontrolle über die Coroutine vollständig in den Händen des Benutzers liegt. Daher kann die Verwendung von Coroutinen den Kontextwechsel reduzieren Das Programm läuft und verbessert effektiv die Effizienz des Programms. 
pip install httpx
best practice Wie das Sprichwort sagt: Effizienz entscheidet über Erfolg oder Misserfolg. Ich habe asynchrone und synchrone httpx-Methoden verwendet, um den Zeitverbrauch von Batch-http-Anfragen zu vergleichen ~Werfen wir zunächst einen Blick auf die zeitaufwändige Leistung synchroner http-Anfragen: #🎜🎜 #import asyncio
import httpx
import threading
import time
def sync_main(url, sign):
response = httpx.get(url).status_code
print(f'sync_main: {threading.current_thread()}: {sign}2 + 1{response}')
sync_start = time.time()
[sync_main(url='http://www.baidu.com', sign=i) for i in range(200)]
sync_end = time.time()
print(sync_end - sync_start)Der Code ist relativ einfach. Sie können sehen, dass in sync_main der synchrone HTTP-Zugriff auf Baidu 200 Mal implementiert ist.
Die Ausgabe nach dem Ausführen ist wie folgt (ein Teil der Schlüsselausgabe wird abgefangen ...):
sync_main: <_MainThread(MainThread, started 4471512512)>: 192: 200 sync_main: <_MainThread(MainThread, started 4471512512)>: 193: 200 sync_main: <_MainThread(MainThread, started 4471512512)>: 194: 200 sync_main: <_MainThread(MainThread, started 4471512512)>: 195: 200 sync_main: <_MainThread(MainThread, started 4471512512)>: 196: 200 sync_main: <_MainThread(MainThread, started 4471512512)>: 197: 200 sync_main: <_MainThread(MainThread, started 4471512512)>: 198: 200 sync_main: <_MainThread(MainThread, started 4471512512)>: 199: 200 16.56578803062439
Sie können sehen, dass in der obigen Ausgabe der Hauptthread ist nicht umgeschaltet (da es sich ursprünglich um einen Single-Thread handelt!) Anfragen werden der Reihe nach ausgeführt (da es sich um synchrone Anfragen handelt).
Die Ausführung des Programms dauerte insgesamt 16,6 Sekunden.
Versuchen wir unten eine „asynchrone“ http-Anfrage:
import asyncio
import httpx
import threading
import time
client = httpx.AsyncClient()
async def async_main(url, sign):
response = await client.get(url)
status_code = response.status_code
print(f'async_main: {threading.current_thread()}: {sign}:{status_code}')
loop = asyncio.get_event_loop()
tasks = [async_main(url='http://www.baidu.com', sign=i) for i in range(200)]
async_start = time.time()
loop.run_until_complete(asyncio.wait(tasks))
async_end = time.time()
loop.close()
print(async_end - async_start)Der obige Code verwendet das Schlüsselwort „asyncawait“ in async_main, um „asynchrones“ http über asyncio (asynchrone io-Bibliotheksanforderung) zu implementieren Baidu-Homepage 200 Mal durchsuchen und die benötigte Zeit ausdrucken).
Nachdem Sie den Code ausgeführt haben, können Sie die folgende Ausgabe sehen (einige Schlüsselausgaben wurden abgefangen ...).
async_main: <_MainThread(MainThread, started 4471512512)>: 56: 200 async_main: <_MainThread(MainThread, started 4471512512)>: 99: 200 async_main: <_MainThread(MainThread, started 4471512512)>: 67: 200 async_main: <_MainThread(MainThread, started 4471512512)>: 93: 200 async_main: <_MainThread(MainThread, started 4471512512)>: 125: 200 async_main: <_MainThread(MainThread, started 4471512512)>: 193: 200 async_main: <_MainThread(MainThread, started 4471512512)>: 100: 200 4.518340110778809
Sie können sehen, dass, obwohl die Reihenfolge durcheinander ist (56, 99, 67 ...) (das liegt daran, dass das Programm ständig zwischen Coroutinen wechselt), der Hauptthread nicht wechselt (das Wesentliche). von Coroutinen) Immer noch Single-Threaded).
Der Vorgang dauerte insgesamt 4,5 Sekunden.
Im Vergleich zu den 16,6 Sekunden, die die synchrone Anfrage benötigte, wurde sie um fast 73 % verkürzt!
Wie das Sprichwort sagt: Ein Schritt ist schnell und jeder Schritt ist schnell. In Bezug auf den Zeitverbrauch ist „asynchrones“ httpx tatsächlich viel schneller als synchrones http. Natürlich können „Coroutinen“ nicht nur Schnittstellentests im Hinblick auf die Anforderungseffizienz ermöglichen. Nach der Beherrschung von „Coroutinen“ glaube ich, dass das technische Niveau von Freunden auch auf ein höheres Niveau gebracht werden kann, wodurch ein besseres Test-Framework entworfen werden kann.
Okay, das sind alle heute geteilten Inhalte. Wenn es dir gefällt, gib ihm bitte ein „Gefällt mir“~
Das obige ist der detaillierte Inhalt vonWas für ein Artefakt! Ein effizientes Python-Crawler-Framework, das einfacher zu verwenden ist als Anfragen!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!