TypeError: can only concatenate tuple (not "int") to tuple
Aduni un număr la un tuplu. În Dijkstra, cauza tipică e d = heapq.heappop(heap), care dă perechea întreagă (distanta, nod), iar d + cost încearcă să lipească un număr de tuplu. Despachetează perechea: d, u = heapq.heappop(heap), apoi d + cost.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Mesajul spune că operatorul + are în stânga un tuple. Pentru tupluri, + înseamnă lipire (concatenare) cu alt tuplu, deci un număr (int) în dreapta nu are sens. În algoritmii pe grafuri tuplurile apar peste tot: heap-ul conține (distanta, nod), listele de vecini conțin (vecin, cost), coada BFS conține (nod, pasi).
Când uiți să despachetezi, o variabilă pe care o crezi număr e de fapt toată perechea. d = heapq.heappop(heap) face din d tuplul (0, 'A'), iar d + cost dă eroarea. La fel for v in graf[u]: d + v când v e (vecin, cost).
Varianta unsupported operand type(s) for +: 'int' and 'tuple' e aceeași problemă cu operanzii inversați (cost + d). Citește linia indicată și afișează variabilele implicate: una dintre ele arată ca (3, 'B').
De ce apare: cauzele frecvente
1Rezultatul lui heappop nedespachetat
d = heapq.heappop(heap)
for v, cost in graf[u]:
nou = d + costd, u = heapq.heappop(heap)
for v, cost in graf[u]:
nou = d + costHeap-ul conține perechi, deci și heappop returnează o pereche. Despachetarea dă distanța și nodul separat.
2Vecinii sunt perechi, dar îi parcurgi ca noduri
for v in graf[u]:
nou = d + vfor v, cost in graf[u]:
nou = d + costFiecare vecin e (nod, cost); despachetează-l în buclă.
3Ordinea câmpurilor inversată
heapq.heappush(heap, (nod, d))
d, nod = heapq.heappop(heap)heapq.heappush(heap, (d, nod))
d, nod = heapq.heappop(heap)Distanța trebuie să fie primul câmp ca să fie comparată, iar despachetarea trebuie să urmeze aceeași ordine.
Repară eroarea, direct în pagină
Funcția distante(graf, start) calculează distanțele minime cu Dijkstra. Codul dă TypeError: can only concatenate tuple (not "int") to tuple. Repar-o ca să afișeze {'A': 0, 'B': 1, 'C': 3}.
import heapq
def distante(graf, start):
dist = {start: 0}
heap = [(0, start)]
while heap:
d = heapq.heappop(heap)
u = d[1]
for v, cost in graf[u]:
nou = d + cost
if nou < dist.get(v, float('inf')):
dist[v] = nou
heapq.heappush(heap, (nou, v))
return dist
graf = {'A': [('B', 1), ('C', 4)], 'B': [('C', 2)], 'C': []}
print(distante(graf, 'A')){'A': 0, 'B': 1, 'C': 3}Indiciu
heapq.heappop(heap) returnează perechea (distanta, nod); despacheteaz-o în două variabile.
Reparația
import heapq
def distante(graf, start):
dist = {start: 0}
heap = [(0, start)]
while heap:
d, u = heapq.heappop(heap)
if d > dist[u]:
continue
for v, cost in graf[u]:
nou = d + cost
if nou < dist.get(v, float('inf')):
dist[v] = nou
heapq.heappush(heap, (nou, v))
return dist
graf = {'A': [('B', 1), ('C', 4)], 'B': [('C', 2)], 'C': []}
print(distante(graf, 'A'))De ce merge
Heap-ul conține perechi (distanta, nod), deci d era toată perechea (0, 'A'), iar d + cost încerca să lipească un număr de un tuplu. Cu d, u = heapq.heappop(heap), d e distanța și u e nodul. Verificarea d > dist[u] sare peste intrările vechi din heap. Drumul A → B → C (3) e mai scurt decât muchia directă A → C (4).
Alte forme ale mesajului
TypeError: unsupported operand type(s) for +: 'int' and 'tuple'TypeError: unsupported operand type(s) for -: 'tuple' and 'int'TypeError: '<' not supported between instances of 'tuple' and 'int'
Cum o eviți pe viitor
Despachetează tuplurile imediat ce le scoți dintr-o structură: d, u = heappop(heap), for v, cost in graf[u], nod, pasi = coada.popleft(). Scrie într-un comentariu forma elementelor (# heap: (distanta, nod)) și respectă aceeași ordine la push și la pop. Un print al primului element scos lămurește repede tipul.
Întrebări frecvente
De ce uneori mesajul e unsupported operand type(s)?
Depinde de ordine și de operator: tuplu + 1 dă can only concatenate tuple, iar 1 + tuplu sau tuplu - 1 dau unsupported operand type(s). Cauza e aceeași: un tuplu folosit ca număr.
Pot folosi clase în loc de tupluri?
Da, de exemplu un dataclass(order=True). Câmpurile cu nume elimină confuziile, dar tuplurile rămân cele mai simple pentru heap.
Erori înrudite
Dijkstra dă distanțe greșite: nodul e marcat vizitat când e pus în heap La Dijkstra, prima distanță găsită spre un nod nu e neapărat cea mai mică. Dacă marchezi nodul ca vizitat când îl pui în heap, nu mai poți îmbunătăți distanța lui. Actualizează distanța ori de câte ori găsești una mai mică și ignoră la scoatere intrările vechi (if d > dist[u]: continue). TypeError: unsupported operand type(s) for +: 'int' and 'NoneType' Ai adunat un număr cu rezultatul unei funcții care a returnat None: de obicei o funcție recursivă care, într-o ramură, face apelul recursiv fără return în fața lui. Pune return pe fiecare ramură a funcției. TypeError: heappush expected 2 arguments, got 1 heapq.heappush primește două argumente: lista heap și elementul. Ai dat doar elementul (de obicei un tuplu). Scrie heapq.heappush(heap, (distanta, nume)). Dacă primești got 3, ai uitat parantezele tuplului. Î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.
