„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 spui | De ce | Exemplu |
|---|---|---|
| Nivelul tău | explicația pornește de la ce știi | „Știu bazele Python: liste, dicționare, for, funcții” |
| Ce nu înțelegi | nu pierde timp cu ce e evident | „mai ales linia cu return” |
| Un exemplu de rulare | vezi 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ă?” |
| Riscurile | afli ce poate strica funcția | „marchează separat ce e riscant” |
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:
| Pas | Ce se calculează | Valoare |
|---|---|---|
| 1 | {l["curier"] for l in livrari}: mulțimea curierilor, fără duplicate | {'Mihai', 'Ana'} |
| 2 | sorted(...): lista sortată alfabetic | ['Ana', 'Mihai'] |
| 3 | pentru c = 'Ana': AWB-urile lui Ana cu livrat adevărat | [] |
| 4 | pentru c = 'Mihai': AWB-urile lui Mihai cu livrat adevărat | ['CE10000001', 'CE10000003'] |
| 5 | dicț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 rezultatVerifici 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.
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.
Înțelegi modulele vechi ale proiectului fără să-ți întrerupi colegii la fiecare linie.
Afli ce face funcția înainte să schimbi ceva în ea.
Înțelegi o construcție nouă pentru tine și pui întrebări mai bune la review.
Î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`.
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},
]
``` 