TypeError: object of type 'Queue' has no len()
queue.Queue e o coadă pentru fire de execuție, nu o structură de date pentru algoritmi: nu are len(), iar while coada: nu se oprește niciodată. Pentru BFS folosește collections.deque, cu append, popleft și while coada.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Modulul queue (Queue, LifoQueue, PriorityQueue) e făcut pentru comunicarea între fire de execuție. Un fir pune elemente, altul le scoate, iar get() așteaptă dacă nu e nimic în coadă. Clasa nu implementează len(), de aceea len(coada) dă object of type 'Queue' has no len().
Varianta și mai înșelătoare e while coada:. Un obiect Queue e mereu considerat adevărat, chiar și gol, deci bucla nu se oprește. Când coada se golește, coada.get() blochează programul în așteptarea unui element care nu mai vine. Nu primești nicio eroare: programul pur și simplu se blochează (în editorul nostru, e oprit după câteva secunde).
Pentru BFS și alte algoritmi pe un singur fir, structura potrivită e collections.deque: append adaugă la final, popleft scoate de la început, ambele în O(1), iar len și while coada: funcționează normal.
De ce apare: cauzele frecvente
1len() pe un queue.Queue
import queue
coada = queue.Queue()
coada.put(start)
while len(coada) > 0:
nod = coada.get()from collections import deque
coada = deque([start])
while coada:
nod = coada.popleft()deque are lungime și e fals când e goală, deci bucla se oprește după ultimul nod.
2while coada: cu queue.Queue se blochează
while coada:
nod = coada.get()while not coada.empty():
nod = coada.get()empty() e metoda corectă pentru Queue. Totuși, pentru algoritmi deque e mai simplă și mai rapidă, pentru că nu folosește blocări între fire.
3PriorityQueue în loc de heapq
from queue import PriorityQueue
pq = PriorityQueue()
while len(pq):
cost, nod = pq.get()import heapq
heap = [(0, start)]
while heap:
cost, nod = heapq.heappop(heap)La Dijkstra, o listă simplă cu heapq face același lucru, fără costul sincronizării și cu while heap: care se oprește corect.
Repară eroarea, direct în pagină
Funcția bfs(graf, start) parcurge graful în lățime cu queue.Queue, dar dă TypeError: object of type 'Queue' has no len(). Rescrie coada cu collections.deque ca programul să afișeze ordinea de vizitare ['A', 'B', 'C', 'D'].
import queue
def bfs(graf, start):
coada = queue.Queue()
coada.put(start)
vizitat = {start}
ordine = []
while len(coada) > 0:
nod = coada.get()
ordine.append(nod)
for v in graf[nod]:
if v not in vizitat:
vizitat.add(v)
coada.put(v)
return ordine
graf = {'A': ['B', 'C'], 'B': ['D'], 'C': ['D'], 'D': []}
print(bfs(graf, 'A'))['A', 'B', 'C', 'D']
Indiciu
Folosește deque([start]), popleft() și while coada:.
Reparația
from collections import deque
def bfs(graf, start):
coada = deque([start])
vizitat = {start}
ordine = []
while coada:
nod = coada.popleft()
ordine.append(nod)
for v in graf[nod]:
if v not in vizitat:
vizitat.add(v)
coada.append(v)
return ordine
graf = {'A': ['B', 'C'], 'B': ['D'], 'C': ['D'], 'D': []}
print(bfs(graf, 'A'))De ce merge
queue.Queue nu are lungime, iar dacă ai fi scris while coada:, programul s-ar fi blocat la get() pe coada goală. deque e o coadă obișnuită: append pune nodul la final, popleft îl scoate pe primul, iar coada goală e falsă, deci bucla se oprește după ultimul nod. Ordinea FIFO păstrează proprietatea BFS: nodurile sunt vizitate nivel cu nivel.
Alte forme ale mesajului
TypeError: object of type 'PriorityQueue' has no len()TypeError: object of type 'LifoQueue' has no len()Programul a rulat prea mult și a fost oprit. Verifică dacă ai o buclă infinită.
Cum o eviți pe viitor
Reține împărțirea: collections.deque pentru cozi și stive în algoritmi, heapq pe o listă pentru cozi cu priorități, iar modulul queue doar când chiar ai fire de execuție care își trimit date. Când un BFS „se blochează” fără eroare, verifică întâi ce tip de coadă folosești și cum se oprește bucla.
Întrebări frecvente
Atunci de ce există queue.Queue?
Pentru programele cu mai multe fire de execuție: un fir produce sarcini, altul le consumă, iar Queue se ocupă de sincronizare. Pentru asta, get() care așteaptă e chiar comportamentul dorit.
Pot folosi qsize()?
coada.qsize() returnează mărimea aproximativă și merge pe un singur fir, dar e mai lentă decât deque și nu are rost într-un algoritm.
Erori înrudite
AttributeError: 'list' object has no attribute 'popleft' popleft() există doar la collections.deque, nu la liste. Creează coada cu from collections import deque și coada = deque([start]); lista.pop(0) ar merge, dar e O(n) la fiecare scoatere. BFS-ul nu se mai oprește pe un graf cu ciclu (lipsesc nodurile vizitate) BFS-ul pune în coadă vecinii fără să verifice dacă au mai fost descoperiți, iar pe un graf cu ciclu (sau neorientat) aceleași noduri intră în coadă la nesfârșit; editorul oprește programul după limita de timp. Marchează nodul ca vizitat când îl pui în coadă. IndexError: pop from an empty deque Ai apelat coada.popleft() (sau pop()) pe un deque gol: bucla a continuat după ce coada s-a golit, sau ai scos de două ori pentru un singur element pus. Folosește while coada: și scoate un singur element pe iterație. Î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.
