Возврат лямбда-узла <Node

Question

Я получаю эту ошибку компилятора при помещении узла в очередь с минимальным приоритетом.

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

Вот где это не удается

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):

Я нашел обходной путь, добавивфункция "lt" для класса Node.

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

Однако есть ли другой способ исправить это с помощью лямбда-выражений или каким-либо образом изменить очередь с минимальным приоритетом?

Может быть, ключевая функция, возможно?Я понимаю, что делает ключ (значение), но я не знаю, как бы я интерпретировал его как узел.Я попробовал что-то вроде следующего, но это не сработало.

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

Также отметим, что функции кучи также обрабатывают значения int и другие типы.Это намного позже в коде, где я передаю узлы в кучу / очередь.

Примечание. Узел сортируется по частоте.

Вот мой класс Node

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

Последнее слово, я понимаю, что "lt" работает в классе Node, но я пытаюсь найти другое решение, которое невключают в себя изменение класса Node, потому что на других сайтах есть комментарии, в которых говорится об использовании лямбда-выражения (например, функция ключа должна возвращать частоту, хранящуюся в аргументе для ключа, который должен быть узлом; нужно ли нам писать функцию ключа? Да. Это может быть простое лямбда-выражение.) Но они расплывчаты в том, как этого добиться.