RecursionError: maximum recursion depth exceeded
Funcția ta se apelează pe ea însăși de prea multe ori: la un lanț cu mii de blocuri, o validare recursivă (un apel pe bloc) depășește limita de aproximativ 1000 de apeluri. Scrie validarea cu o buclă for, nu recursiv.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Fiecare apel de funcție ocupă loc pe stiva de apeluri. Python oprește programul când stiva depășește o limită (implicit 1000 de niveluri, vezi sys.getrecursionlimit()), ca să nu blocheze procesul. Mesajul înseamnă că ai ajuns la limită.
În codul de blockchain există două situații. Prima: o funcție recursivă corectă, dar folosită pe date mari, de exemplu valideaza(lant, i) care verifică blocul i și se cheamă pentru i + 1; merge pe 10 blocuri, dar pică la 3000. A doua: recursivitate infinită, unde lipsește cazul de oprire sau nu se apropie de el (la Merkle, o funcție care se cheamă cu aceeași listă). Traceback-ul arată aceeași linie repetată de foarte multe ori. Mărirea limitei cu sys.setrecursionlimit doar amână problema; un lanț crește mereu, deci validarea se scrie cu o buclă.
De ce apare: cauzele frecvente
1Validare recursivă pe un lanț lung
def valideaza(lant, i=1):
if i == len(lant):
return True
if lant[i]["hash_anterior"] != lant[i - 1]["hash"]:
return False
return valideaza(lant, i + 1)def valideaza(lant):
for i in range(1, len(lant)):
if lant[i]["hash_anterior"] != lant[i - 1]["hash"]:
return False
return TrueBucla folosește un singur nivel de stivă, oricât de lung ar fi lanțul.
2Rădăcina Merkle fără caz de oprire
def radacina(nivel):
urmator = [h(a + b) for a, b in zip(nivel[::2], nivel[1::2])]
return radacina(urmator)def radacina(nivel):
if len(nivel) == 1:
return nivel[0]
urmator = [h(a + b) for a, b in zip(nivel[::2], nivel[1::2])]
return radacina(urmator)Fără if len(nivel) == 1, funcția nu se oprește niciodată.
Repară eroarea, direct în pagină
Funcția valideaza de mai jos verifică legăturile unui lanț recursiv, câte un apel pe bloc, iar pe un lanț de 3000 de blocuri dă RecursionError: maximum recursion depth exceeded. Rescrie-o cu o buclă, păstrând numele și ce întoarce, ca programul să afișeze rezultatul pentru lanțul bun și pentru cel stricat.
import hashlib
def h(t):
return hashlib.sha256(t.encode()).hexdigest()
lant = [{"hash": h("geneza"), "hash_anterior": "0" * 64}]
for i in range(1, 3000):
lant.append({"hash": h(f"bloc{i}"), "hash_anterior": lant[-1]["hash"]})
def valideaza(lant, i=1):
if i == len(lant):
return True
if lant[i]["hash_anterior"] != lant[i - 1]["hash"]:
return False
return valideaza(lant, i + 1)
print("Blocuri:", len(lant))
print("Valid:", valideaza(lant))
lant[2500]["hash_anterior"] = "f" * 64
print("După modificare:", valideaza(lant))Blocuri: 3000 Valid: True După modificare: False
Indiciu
O buclă for peste indicii blocurilor nu crește stiva de apeluri.
Reparația
import hashlib
def h(t):
return hashlib.sha256(t.encode()).hexdigest()
lant = [{"hash": h("geneza"), "hash_anterior": "0" * 64}]
for i in range(1, 3000):
lant.append({"hash": h(f"bloc{i}"), "hash_anterior": lant[-1]["hash"]})
def valideaza(lant):
for i in range(1, len(lant)):
if lant[i]["hash_anterior"] != lant[i - 1]["hash"]:
return False
return True
print("Blocuri:", len(lant))
print("Valid:", valideaza(lant))
lant[2500]["hash_anterior"] = "f" * 64
print("După modificare:", valideaza(lant))De ce merge
Varianta recursivă adăuga un nivel pe stiva de apeluri pentru fiecare bloc, iar la 3000 de blocuri depășea limita de aproximativ 1000. Bucla for verifică fiecare pereche de blocuri consecutive în același apel de funcție, deci funcționează pentru orice lungime. Rezultatul e același: lanțul bun e valid, iar cel modificat la blocul 2500 nu.
Alte forme ale mesajului
RecursionError: maximum recursion depth exceeded in comparisonRecursionError: maximum recursion depth exceeded while calling a Python objectRecursionError: maximum recursion depth exceeded while getting the str of an object
Cum o eviți pe viitor
Pentru structuri care cresc fără limită (lanțul, istoricul tranzacțiilor, lista de noduri vizitate) scrie algoritmii cu bucle sau cu o coadă explicită. Recursivitatea e potrivită pentru structuri cu adâncime mică, cum e arborele Merkle (adâncimea e log2 din numărul de tranzacții). Testează funcțiile și pe date mari, de exemplu un lanț generat cu câteva mii de blocuri.
Întrebări frecvente
Pot mări limita cu sys.setrecursionlimit?
Poți, dar nu rezolvi nimic: lanțul va crește peste noua limită, iar o limită prea mare poate opri procesul cu totul. Bucla e reparația corectă.
De ce arborele Merkle recursiv nu dă eroarea?
Pentru că fiecare nivel înjumătățește lista. Chiar la un milion de tranzacții sunt doar vreo 20 de niveluri.
Erori înrudite
ValueError: Circular reference detected Structura dată lui json.dumps se conține pe ea însăși: un bloc care ține referință la blocul anterior întreg, care ține la rândul lui referință înapoi, sau o listă adăugată în ea însăși. Serializează doar valorile (de ex. hash-ul anterior), nu obiectele legate între ele. TypeError: 'int' object is not iterable Ai pus un număr acolo unde Python aștepta o colecție: de obicei for i in len(lant) în loc de for i in range(len(lant)), sau sum(...) / max(...) pe o singură valoare. Folosește range(...) sau parcurge direct lista. Blocul geneză pică validarea (lant[i - 1] când i = 0) Validarea pornește de la indexul 0, iar pentru geneză lant[i - 1] devine lant[-1], adică ultimul bloc, deci legătura pare ruptă. Verifică legăturile de la i = 1: range(1, len(lant)). Geneza se verifică separat. Învață Blockchain de la zero, cu exerciții la fiecare lecție
Curs Blockchain și criptomonede: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
