asyncio huwa l-framework ta' Python għal concurrent I/O bl-użu ta' async/await. Jopera bosta operazzjonijiet I/O b'mod kooperattiv fuq single thread wieħed permezz ta' event loop — effiċjent għal high-concurrency I/O-bound work (network calls, web servers) mingħajr l-overhead tat-threads.
import asyncio
async def fetch_data(id): # an async function = a coroutine
print(f"start {id}")
await asyncio.sleep(1) # await a non-blocking I/O operation (yields control)
print(f"done {id}")
return id
asyncio.run(fetch_data(1)) # run a coroutine from sync code
Funzjoni async def hija coroutine; await tissospendiha fuq punt I/O, u tħalli l-event loop ijopera coroutines oħra b'intanto — imbagħad tirriprendi meta l-operazzjoni mwaqqfa tkumplija.
# ❌ sequential — total time ≈ 3 seconds
async def slow():
await fetch_data(1) # wait 1s
await fetch_data(2) # then wait 1s
await fetch_data(3) # then wait 1s
# ✅ concurrent — total time ≈ 1 second (all run together)
async def fast():
await asyncio.gather(fetch_data(1), fetch_data(2), fetch_data(3))
asyncio.gather jopera coroutines b'mod concurrent — waqt li waħda tistenna I/O, l-oħrajn jikompletaw. Tliet wait ta' sekonda waħda jifqugħu f'~sekonda waħda totali. Dan huwa l-valur ewlieni: sovrapposizzjoni ta' ħafna I/O waits fuq thread wieħed.
Threading: OS-managed, preemptive, real threads (GIL-limited for CPU)
asyncio: single thread, COOPERATIVE — coroutines yield at `await` points
→ lighter weight (handle thousands of connections), no thread overhead,
but one CPU-heavy coroutine blocks everything (no preemption)
async def bad():
time.sleep(5) # ❌ BLOCKS the whole event loop (sync sleep)
result = heavy_compute() # ❌ CPU work freezes all coroutines
async def good():
await asyncio.sleep(5) # ✅ non-blocking
# offload CPU work to a thread/process pool
await loop.run_in_executor(None, heavy_compute)
Biex huwa kooperattiv u single-threaded, kwalunkwe ċCall blocking/CPU-heavy tbissaħ il-coroutines kollha. Uża APIs async awatabbli, u offload il-blocking/CPU work lill-executor.
✓ High-concurrency I/O: web servers (FastAPI), web scraping, many API/DB calls,
websockets, real-time apps — thousands of concurrent connections efficiently
✗ CPU-bound work — use multiprocessing instead (asyncio doesn't help)
asyncio huwa l-approċċ modern għal high-concurrency I/O f'Python, li jippossiedi frameworks bħal FastAPI u li jippermetti handling effiċjenti ta' eluf ta' connections simultani fuq thread wieħed — ħafna ħafif minn thread-per-connection.
Fehim ta' coroutines, await, concurrent execution ma' gather, u speċjalment ir-regola kardinali (tħallix qatt l-event loop tiblokkja; offload CPU/blocking work) huwa essenzjali għall-kitba ta' async Python performanti.
L-għarfien tal-ħin meta hu tajjeb (I/O-bound concurrency) versus meta mhuwiex (CPU-bound → multiprocessing) huwa saru biex tuża dan b'mod effettiv.