Argumentul implicit mutabil (rezultat=[]) păstrează valorile între apeluri
Valoarea implicită a unui parametru (rezultat=[], memo={}) se creează o singură dată, când e definită funcția, și e aceeași listă la toate apelurile, așa că al doilea apel vede ce a adăugat primul. Folosește rezultat=None și creează lista în funcție: if rezultat is None: rezultat = [].
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
În Python, valorile implicite ale parametrilor sunt evaluate o singură dată, la definirea funcției, nu la fiecare apel. Pentru numere și texte nu contează, pentru că nu se pot modifica. Dar def f(x, rezultat=[]) creează o singură listă, refolosită de toate apelurile care nu trimit rezultat. Orice append din primul apel rămâne în listă la al doilea.
În algoritmi apare la funcții recursive care adună rezultate (def parcurge(nod, ordine=[]), def submultimi(v, drum=[], rez=[])) și la memo-uri (def fib(n, memo={})). Primul test dă rezultatul corect, al doilea conține și elementele primului. La memo, efectul poate fi chiar dorit, dar devine greșit când memo-ul depinde de date care diferă între apeluri.
Nu primești nicio eroare. În „Repară tu” testele folosesc assert și vezi rezultatul care conține elemente în plus.
De ce apare: cauzele frecvente
1Listă de rezultate ca valoare implicită
def preordine(nod, ordine=[]):
if nod:
ordine.append(nod.val)
preordine(nod.stanga, ordine)
preordine(nod.dreapta, ordine)
return ordinedef preordine(nod, ordine=None):
if ordine is None:
ordine = []
if nod:
ordine.append(nod.val)
preordine(nod.stanga, ordine)
preordine(nod.dreapta, ordine)
return ordineNone e imuabil, iar lista nouă se creează la fiecare apel de sus. Apelurile recursive primesc explicit aceeași listă.
2Memo ca valoare implicită, pe date diferite
def drumuri(r, c, harta, memo={}):
...def drumuri_harta(harta):
memo = {}
def drumuri(r, c):
...
return drumuri(0, 0)Memo-ul implicit ar păstra rezultatele de la o hartă la alta. Creat în funcția exterioară, e nou pentru fiecare hartă.
Repară eroarea, direct în pagină
Funcția frunze(arbore, rez=[]) adună recursiv frunzele unui arbore de categorii dat ca dicționar de copii. Primul test e corect, dar al doilea conține și frunzele primului, iar assert pică. Repar-o ca testele să treacă și să afișeze ['Tricouri', 'Rochii'] și ['Laptopuri'].
def frunze(arbore, nod, rez=[]):
copii = arbore.get(nod, [])
if not copii:
rez.append(nod)
for c in copii:
frunze(arbore, c, rez)
return rez
haine = {'Haine': ['Barbati', 'Femei'], 'Barbati': ['Tricouri'], 'Femei': ['Rochii']}
it = {'IT': ['Laptopuri']}
r1 = frunze(haine, 'Haine')
r2 = frunze(it, 'IT')
assert r2 == ['Laptopuri'], f"frunze in plus: {r2}"
print(r1)
print(r2)['Tricouri', 'Rochii'] ['Laptopuri']
Indiciu
Valoarea implicită [] e creată o singură dată; folosește None și creează lista în funcție.
Reparația
def frunze(arbore, nod, rez=None):
if rez is None:
rez = []
copii = arbore.get(nod, [])
if not copii:
rez.append(nod)
for c in copii:
frunze(arbore, c, rez)
return rez
haine = {'Haine': ['Barbati', 'Femei'], 'Barbati': ['Tricouri'], 'Femei': ['Rochii']}
it = {'IT': ['Laptopuri']}
r1 = frunze(haine, 'Haine')
r2 = frunze(it, 'IT')
assert r2 == ['Laptopuri'], f"frunze in plus: {r2}"
print(r1)
print(r2)De ce merge
Lista implicită rez=[] a fost creată o singură dată, la definirea funcției. Primul apel a pus în ea „Tricouri” și „Rochii”, iar al doilea apel, fără rez, a primit aceeași listă și a adăugat „Laptopuri” după ele. Ba mai mult, r1 și r2 erau aceeași listă. Cu rez=None, fiecare apel de sus creează o listă nouă, iar apelurile recursive primesc explicit lista apelului lor.
Cum o eviți pe viitor
Nu folosi niciodată liste, dicționare sau set-uri ca valori implicite. Scrie param=None și creează colecția în funcție. Și mai simplu la recursivitate: o funcție exterioară creează rezultatul și o funcție interioară îl completează. Majoritatea linterelor (Pylint, Ruff) avertizează automat pentru def f(x=[]).
Întrebări frecvente
De ce Python funcționează așa?
Linia def este executată o singură dată și atunci se calculează valorile implicite, care sunt salvate în funcție (le vezi în f.__defaults__). Python nu le recreează la fiecare apel.
Am văzut fib(n, memo={}) recomandat ca truc. E greșit?
Pentru Fibonacci merge, pentru că fib(5) are mereu același rezultat. Dar e un truc fragil: nu-l folosi când rezultatul depinde și de alte date. @lru_cache face același lucru, clar și sigur.
Erori înrudite
Backtracking-ul returnează liste goale: [[], [], []] Ai adăugat în rezultat chiar lista de lucru (rezultat.append(drum)), nu o copie a ei. La final backtracking-ul golește lista, deci toate intrările arată goale. Adaugă o copie: rezultat.append(drum[:]) sau list(drum). Memo greșit: cheia nu conține toți parametrii, iar rezultatul e greșit Ai salvat în memo rezultatul doar după i (memo[i]), dar funcția depinde și de alt parametru (capacitate, j, suma rămasă), așa că un rezultat calculat pentru o stare e refolosit pentru alta. Cheia memo-ului trebuie să conțină toți parametrii care schimbă rezultatul: memo[(i, capacitate)]. [[0] * m] * n: modifici o celulă și se schimbă toată coloana [[0] * m] * n nu creează n rânduri, ci n referințe la același rând, așa că dp[0][1] = 5 apare în toate rândurile. Creează fiecare rând separat: [[0] * m for _ in range(n)]. Învață Algoritmi și structuri de date de la zero, cu exerciții la fiecare lecție
Curs Algoritmi pentru interviuri: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 2 lecții sunt gratuite.
