Obiective

1. Introducere în programarea asincronă
2. Înțelegerea conceptelor de evenimente, corutine și loop-uri de evenimente
3. Utilizarea bibliotecii asyncio pentru a crea aplicații asincrone în Python
4. Exemple practice de utilizare a bibliotecii asyncio

1. Introducere în programarea asincronă

Programarea asincronă se referă la modelul de programare în care execuția unei funcții se poate suspenda temporar pentru a permite altor funcții să ruleze în același timp. Acest model este util pentru a gestiona operațiunile I/O, cum ar fi citirea și scrierea în fișiere sau comunicarea în rețea, care pot bloca execuția programului.

În Python, biblioteca asyncio permite programarea asincronă prin folosirea unor sintaxe specifice și a unui loop de evenimente care gestionează corutinele.

2. Concepte de bază: evenimente, corutine și loop-uri de evenimente

• Evenimente: în contextul programării asincrone, un eveniment este o acțiune care se întâmplă în timpul execuției programului, cum ar fi primirea de date de la un server sau finalizarea unei operațiuni de scriere într-un fișier.

• Corutine: o corutină este o funcție specială definită cu sintaxa async def. Corutinele pot suspenda execuția lor folosind cuvântul cheie await, iar alte corutine pot continua în acest timp. Spre deosebire de funcțiile normale, corutinele nu pot fi apelate direct; în schimb, ele sunt programate să ruleze într-un loop de evenimente.

• Loop-uri de evenimente: un loop de evenimente este o componentă centrală a programării asincrone. El gestionează corutinele și programează execuția lor în funcție de evenimente. În Python, asyncio oferă un loop de evenimente implicit, dar puteți crea și loop-uri personalizate.

3. Utilizarea bibliotecii asyncio

Pentru a utiliza asyncio, trebuie să importați biblioteca și să definiți corutinele dorite. De exemplu, o corutină simplă care așteaptă un anumit număr de secunde arată astfel:

import asyncio

async def asteapta_secunde(secunde):
    print(f'Așteaptă {secunde} secunde...')
    await asyncio.sleep(secunde)
    print(f'Așteptarea de {secunde} secunde s-a încheiat.')

Pentru a rula corutina, trebuie să o programați într-un loop de evenimente, folosind funcția asyncio.run():

asyncio.run(asteapta_secunde(2))

4. Exemple practice de utilizare a bibliotecii asyncio

1. Descărcare de pagini web în paralel:

import aiohttp
import asyncio

async def descarca_pagina(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            continut = await response.text()
            return continut

async def descarca_pagini(urls):
    tasks = [descarca_pagina(url) for url in urls]
    pagini = await asyncio.gather(*tasks)
    return pagini

urls = ['https://example.com', 'https://example.org', 'https://example.net']
pagini = asyncio.run(descarca_pagini(urls))
for url, pagina in zip(urls, pagini):
    print(f'Descărcat {url}: {len(pagina)} caractere')

2. Execuția simultană a mai multor corutine:

import asyncio

async def asteapta_si_afiseaza(text, secunde):
    await asyncio.sleep(secunde)
    print(text)

async def main():
    task1 = asyncio.create_task(asteapta_si_afiseaza("Text1", 2))
    task2 = asyncio.create_task(asteapta_si_afiseaza("Text2", 3))
    task3 = asyncio.create_task(asteapta_si_afiseaza("Text3", 1))

    await asyncio.gather(task1, task2, task3)

asyncio.run(main())

În acest exemplu, avem o corutină asteapta_si_afiseaza care așteaptă un anumit număr de secunde și apoi afișează un text. Funcția main creează trei task-uri asincrone și le execută simultan folosind asyncio.gather. Rezultatul este afișarea textelor în ordinea în care se termină așteptarea, nu în ordinea în care au fost create task-urile.

Aceasta a fost o introducere în utilizarea bibliotecii asyncio pentru programarea asincronă în Python. În această lecție, am discutat despre conceptele de bază, cum să utilizați asyncio și exemple practice pentru a vă ajuta să înțelegeți cum funcționează această bibliotecă.