Pfthb

I'm receiving this compiler error when putting a Node onto a min-priority queue.

TypeError: '<' not supported between instances of 'Node' and 'Node'

Here is where it fails

from queue import PriorityQueue

def huffman(text):
 A = frequency(text) # returns a dictionary (frequency, character),...
 q = PriorityQueue()
 heap = build_min_heap(A) # builds min heap 
 while heap:
 temp = pop_heap(heap) # format (frequency, character)
----> q.put(Node(temp[1],temp[0],None,None))
 # Node(character, frequency, left child, right child)

def min_heapify(A, i, key=lambda a: a):
 lefti = 2 * i + 1
 righti = 2 * i + 2
 heap_size = len(A)
--->if lefti < heap_size and key(A[lefti]) < key(A[i]):

 /anaconda3/lib/python3.6/queue.py in put(self, item, block, timeout)
 141 raise Full
 142 self.not_full.wait(remaining)
--> 143 self._put(item)
 144 self.unfinished_tasks += 1
 145 self.not_empty.notify()

 /anaconda3/lib/python3.6/queue.py in _put(self, item)
 225 
 226 def _put(self, item):
--> 227 heappush(self.queue, item)
 228 
 229 def _get(self):

I found a workaround by adding an "lt" function to the Node class.

def __lt__(self, other):
 return self.frequency < other.frequency

However, is there another way to fix this using lambda expressions or modifying the min-priority queue in some way?

Maybe a key function perhaps? I understand what key(value) is doing but I don't know how would I interpret it as a Node. I tried something like the following, but it didn't work.

def key(item):
 if instanceof(item, Node):
 return item.frequency

Also to note that the heap functions also process int values and other types. This is way later in the code where I'm passing Nodes to the heap/queue.

Note: The Node is sorted by frequency.

Here is my Node class

class Node():

 def __init__(self, character=None, frequency=None, left=None, right=None):
 self.character = character
 self.frequency = frequency
 self.left = left
 self.right = right

 def isLeaf(self):
 return self.left is None and self.right is None

 def __lt__(self, other):
 return self.frequency < other.frequency

 def __repr__(self):
 return 'Node(, , , )'.format(self.character,
 self.frequency,
 self.left, self.right)

def min_heapify(A, i, key=lambda a: a):
 lefti = 2 * i + 1
 righti = 2 * i + 2
 heap_size = len(A)
 if lefti < heap_size and key(A[lefti]) < key(A[i]):
 smallesti = lefti
 else:
 smallesti = i
 if righti < heap_size and key(A[righti]) < key(A[smallesti]):
 smallesti = righti
 if smallesti != i:
 A[i], A[smallesti] = A[smallesti], A[i]
 min_heapify(A, smallesti, key)

def build_min_heap(A, key=lambda a: a):
 for i in range(len(A) // 2 - 1, -1, -1):
 swaps = min_heapify(A, i, key)
 return A

A final word, I understand that "lt" works in the Node class, but I'm trying to figure out another solution that doesn't involve modifying the Node class because other sites have comments that say to use a lambda expression (e.g. The key function should return the frequency stored in the argument to key, which should be a Node.; do we need to write the key function? Yes. It can be a simple lambda expression.) but they are vague in how to accomplish that.