...
← Curs AI pentru programatori: toate lecțiile
Lecția 6 · Primii pași cu AI în cod

„Explică-mi codul”: AI-ul ca mentor pe cod necunoscut

La primul job citești mult mai mult cod decât scrii. Un asistent AI e un mentor răbdător, disponibil oricând, dacă știi să-i ceri explicația potrivită: la nivelul tău, pe partea pe care n-o înțelegi, cu un exemplu de rulare și cu riscurile marcate. Apoi verifici explicația rulând codul.

Cod scris de altcineva

În a doua săptămână la ColetExpres, Andrei primește un tichet: raportul zilnic al curierilor arată greșit. Raportul folosește o funcție scrisă acum doi ani de un coleg care a plecat din firmă:

def livrate_pe_curier(livrari):
    curieri = sorted({l["curier"] for l in livrari})
    return {c: [l["awb"] for l in livrari if l["curier"] == c and l["livrat"]] for c in curieri}

Andrei știe bazele Python, dar o mulțime și un dicționar construite cu comprehension-uri, cu o listă înăuntru, pe o singură linie, nu se citesc ușor. Întreabă asistentul: „ce face codul ăsta?”

Funcția grupează livrările după curier și returnează, pentru fiecare curier, lista AWB-urilor livrate, folosind o set comprehension și o dict comprehension.

Corect, dar inutil pentru Andrei: rezumatul repetă numele funcției și folosește exact termenii pe care nu-i înțelege. Asistentul nu știa ce știe Andrei și ce anume îl încurcă.

Ce face o explicație utilă

Ce îi spuiDe ceExemplu
Nivelul tăuexplicația pornește de la ce știi„Știu bazele Python: liste, dicționare, for, funcții”
Ce nu înțeleginu pierde timp cu ce e evident„mai ales linia cu return”
Un exemplu de rularevezi valorile concrete, nu definiții„pas cu pas pe livrari_test, ce valoare are c”
Cazurile limităafli ce se întâmplă la margini„ce se întâmplă la o listă goală?”
Riscurileafli ce poate strica funcția„marchează separat ce e riscant”
Important

Un exemplu de rulare pe date concrete e cea mai bună parte a unei explicații: îl poți verifica. O frază ca „funcția grupează livrările” nu se poate verifica; „pentru Mihai lista devine ['CE10000001', 'CE10000003']” se poate.

Urmărirea valorilor, ca la tablă

Cu un prompt bun, asistentul îți desface linia în bucăți și îți arată valorile pentru o intrare mică. Pentru trei livrări (Mihai livrat, Ana nelivrat, Mihai livrat) răspunsul arată cam așa:

PasCe se calculeazăValoare
1{l["curier"] for l in livrari}: mulțimea curierilor, fără duplicate{'Mihai', 'Ana'}
2sorted(...): lista sortată alfabetic['Ana', 'Mihai']
3pentru c = 'Ana': AWB-urile lui Ana cu livrat adevărat[]
4pentru c = 'Mihai': AWB-urile lui Mihai cu livrat adevărat['CE10000001', 'CE10000003']
5dicționarul final{'Ana': [], 'Mihai': ['CE10000001', 'CE10000003']}

Același cod scris „lung”, cu bucle obișnuite, pe care asistentul ți-l poate da doar ca explicație (nu ca înlocuitor):

def livrate_pe_curier(livrari):
    curieri = sorted({l["curier"] for l in livrari})
    rezultat = {}
    for c in curieri:
        lista = []
        for l in livrari:
            if l["curier"] == c and l["livrat"]:
                lista.append(l["awb"])
        rezultat[c] = lista
    return rezultat

Verifici explicația rulând codul

Explicația asistentului e și ea un text plauzibil, deci o verifici. Cel mai simplu: rulezi funcția pe aceeași intrare și compari cu tabelul. Andrei a rulat-o local, pe datele din exemplu și pe o listă goală:

def livrate_pe_curier(livrari):
    curieri = sorted({l["curier"] for l in livrari})
    return {c: [l["awb"] for l in livrari if l["curier"] == c and l["livrat"]] for c in curieri}

livrari_test = [
    {"awb": "CE10000001", "curier": "Mihai", "livrat": True},
    {"awb": "CE10000002", "curier": "Ana", "livrat": False},
    {"awb": "CE10000003", "curier": "Mihai", "livrat": True},
]

print(livrate_pe_curier(livrari_test))
print(livrate_pe_curier([]))
{'Ana': [], 'Mihai': ['CE10000001', 'CE10000003']}
{}

Se potrivește: Ana apare cu o listă goală (are o livrare, dar nelivrată), iar lista goală de livrări dă un dicționar gol. Dacă explicația ar fi spus altceva (de exemplu că Ana nu apare deloc), Andrei ar fi știut imediat că asistentul a greșit.

Atenție

Când îi ceri să marcheze riscurile, un asistent bun observă, de exemplu, că funcția aruncă KeyError dacă o livrare nu are cheia "livrat", și că parcurge toată lista de livrări o dată pentru fiecare curier (lent la sute de mii de livrări). Pe astea le verifici și le notezi în tichet; nu le repari în aceeași modificare dacă tichetul e despre altceva.

Greșeli frecvente

  • „Ce face codul ăsta?” fără nivel și fără ce nu înțelegi: primești un rezumat.
  • Accepți explicația fără s-o verifici: o explicație poate fi la fel de greșită ca un cod.
  • Primești o rescriere în loc de explicație și o pui în proiect „că arată mai bine”, fără să fi înțeles originalul.
  • Nu întrebi de cazurile limită: listă goală, cheie lipsă, valori None.
  • Lipești o funcție fără datele cu care e apelată: exemplul de rulare va fi inventat.
OnboardingPrima săptămână

Înțelegi modulele vechi ale proiectului fără să-ți întrerupi colegii la fiecare linie.

TicheteBug în cod vechi

Afli ce face funcția înainte să schimbi ceva în ea.

ReviewCod de la colegi

Înțelegi o construcție nouă pentru tine și pui întrebări mai bune la review.

Exercițiul tău

În editor ai funcția din raportul curierilor și datele de test. Scrie deasupra un prompt care cere o explicație pentru cineva care știe bazele Python: spune ce parte nu înțelegi, cere un exemplu de rulare pas cu pas pe livrari_test și întreabă ce se întâmplă la o listă goală. Codul rămâne între delimitatori.

  • Spune nivelul tău (știi bazele Python / începător / junior).
  • Spune ce parte nu înțelegi (de ex. linia cu return).
  • Cere un exemplu de rulare pas cu pas, cu valorile variabilelor.
  • Întreabă ce se întâmplă la o listă goală.
  • Lasă codul între ` și`.
De exemplu: „Știu bazele Python. Nu înțeleg mai ales linia cu return. Arată-mi pas cu pas valorile pe livrari_test și spune-mi ce se întâmplă la o listă goală.”

Soluția exercițiului

Știu bazele Python (variabile, liste, dicționare, bucle for, funcții), dar n-am mai văzut comprehension-uri puse una în alta.
Explică-mi funcția de mai jos, mai ales linia cu return, pe care nu o înțeleg.
Arată-mi un exemplu de rulare pas cu pas pe livrari_test: ce valoare au curieri și c la fiecare pas și ce se adaugă în listă.
Spune-mi și ce se întâmplă dacă primește o listă goală.
Dacă vezi ceva riscant în cod, marchează separat.

```python
def livrate_pe_curier(livrari):
    curieri = sorted({l["curier"] for l in livrari})
    return {c: [l["awb"] for l in livrari if l["curier"] == c and l["livrat"]] for c in curieri}

livrari_test = [
    {"awb": "CE10000001", "curier": "Mihai", "livrat": True},
    {"awb": "CE10000002", "curier": "Ana", "livrat": False},
    {"awb": "CE10000003", "curier": "Mihai", "livrat": True},
]
```
Excelent! Continuă cu lecția următoare →
prompt.txtPrompt
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Primii pași cu AI în cod Lecția 6 · „Explică-mi codul”: AI-ul ca mentor pe cod necunoscut
Progres 0% 0 din 12
Lecția curentă 6 / 10 Primii pași cu ai în cod