Use python to implement Dijkstra's algorithm

The implementation of the Dijkstra's Algorithm:

def dijkstra(g, s):
    from priority_queue import PriorityQueue, less_than

    result = []
    class Record:
        def __init__(self, v, parent = -1, cost = WEIGHT_LIMIT):
            self.vertex = v 
            self.parent = parent 
            self.cost = cost
        def __lt__(self, other):
            return self.cost < other.cost
        def get_key(self):
            return self.vertex
        key = property(get_key)

    n = len(g)
    sequence = [Record(i) for i in range(n)]
    sequence[s].cost = 0
    pq = PriorityQueue(less_than, sequence)
    while pq:
        u = pq.pop()
        for v in g.adj(u.vertex):
            nc = u.cost + v.weight
            try:
                if nc < pq[v.vertex].cost:
                    pq.modify(v.vertex, Record(v.vertex, u.vertex, nc))
            except IndexError:
                pass
        result.append(u)
    return result

def print_shortest_path_tree(result, s):
    def get_shortest_path(dic, v, cache):
        ret = cache[v]
        if len(ret) == 0:
            r = dic[v]
            if r.parent != -1:
                pret = get_shortest_path(dic, r.parent, cache)
                ret = "%s->%s" % (pret, v)
            else:
                ret = str(v)
            cache[v] = ret
        return ret
    n = len(result)
    dic = {result[i].vertex: result[i] for i in range(n)}
    cache = ["" for i in range(n)]
    i = n - 1
    while i >= 0:
        get_shortest_path(dic, i, cache)
        i -= 1
    for i in range(n):
        if i != s:
            print("%s: %s" % (cache[i], dic[i].cost))

The class WeightedGraph:

class WeightedGraph:
    class Edge:
        def __init__(self, v, w):
            self.vertex = v
            self.weight = w
        def __repr__(self):
            return "%s(%s)" % (self.vertex, self.weight)

    def __init__(self, v):
        self.vertices = [None for i in range(v)]
        self.empty_list = []

    def add_edge(self, u, v, w = 1):
        l = self.vertices[u]
        e = WeightedGraph.Edge(v, w)
        if l != None:
            l.append(e)
        else:
            l = [e]
            self.vertices[u] = l

    def __bool__(self):
        return len(self.vertices) > 0
    __nonzero__ = __bool__

    def __len__(self):
        return len(self.vertices)

    def number_of_edges(self):
        e = 0
        for l in self.vertices:
            e += len(l)
        return e

    def adj(self, v):
        l = self.vertices[v]
        if l == None:
            l = self.empty_list
        return l

    def __repr__(self):
        ret = ""
        v = len(self.vertices)
        i = 0
        while i < v:
            if self.vertices[i]:
                if len(ret) > 0:
                    ret += "\n"
                ret += ("%s: %s" % (i, self.vertices[i]))
            i += 1
        return ret

The class PriorityQueue:

from __future__ import print_function

import copy

def less_than(a,  b): return a < b
def big_than(a, b): return a > b

def get_key(v):
    ret = None
    if isinstance(v, int) or isinstance(v, float) or isinstance(v, str):
        ret = v
    elif isinstance(v, list) or isinstance(v, tuple):
        ret = v[0]
    else:
        ret = v.key
    return ret

def sink(sequence, i, comparator, positions):
    n = len(sequence)
    if i >= 0 and i < n:
        while True:
            c = (i + 1) * 2
            r = i
            if c < n and comparator(sequence[c], sequence[r]):
                r = c
            c -= 1
            if c < n and comparator(sequence[c], sequence[r]):
                r = c
            if r != i:
                if positions != None:
                    positions[get_key(sequence[i])] = r
                    positions[get_key(sequence[r])] = i
                sequence[i], sequence[r] = sequence[r], sequence[i]
                i = r
            else:
                break

def rise(sequence, i, comparator, positions):
    n = len(sequence)
    if i >= 0 and i < n:
        while i != 0:
            p = (i - 1) // 2
            if comparator(sequence[i], sequence[p]):
                if positions != None:
                    positions[get_key(sequence[i])] = p
                    positions[get_key(sequence[p])] = i
                sequence[i], sequence[p] = sequence[p], sequence[i]
                i = p
            else:
                break

def make_heap(sequence, comparator):
    n = len(sequence)
    i = 1
    while i < n:
        rise(sequence, i, comparator, None)
        i += 1
    return sequence

class PriorityQueue:
    def __init__(self, comparator, sequence):
        self.comparator = comparator
        self.elements = make_heap(sequence, self.comparator)
        self.positions = {get_key(self.elements[i]): i for i in range(len(self.elements))}

    def __len__(self):
        return len(self.elements)

    def __bool__(self):
        return len(self.elements) > 0
    __nonzero__ = __bool__

    def __repr__(self):
        return str(self.elements)

    def top(self):
        if self.elements:
            return self.elements[0]
        raise IndexError("The priority queue is empty")

    def pop(self):
        ret = None
        n = len(self.elements)
        if n > 0:
            ret = self.elements[0]
            if n > 1:
                self.elements[0] = self.elements[n - 1]
                self.elements.pop(-1)
                sink(self.elements, 0, self.comparator, self.positions)
            else:
                self.elements = []
        else:
            raise IndexError("The priority queue is empty")
        return ret

    def modify(self, key, value):
        i = self.positions.get(key)
        if i != None:
            old_value = self.elements[i]
            self.elements[i] = value
            del self.positions[key]
            self.positions[get_key(value)] = i
            if self.comparator(old_value, value):
                sink(self.elements, i, self.comparator, self.positions)
            else:
                rise(self.elements, i, self.comparator, self.positions)
        else:
            raise IndexError("The specific element %s is not in the priority queue" % key)

    def __getitem__(self, key):
        i = self.positions.get(key)
        if i != None:
            return self.elements[i]
        else:
            raise IndexError("The specific element %s is not in the priority queue" % key)
            
if __name__ == "__main__":
    sequence = [7, 2, 5, 8, 1, 0, 3, 9]
    pq = PriorityQueue(less_than, copy.copy(sequence))
    result = []
    while pq:
        e = pq.pop()
        result.append(e)
    assert result == sorted(sequence)

    pq = PriorityQueue(less_than, copy.copy(sequence))
    pq.modify(0, -1)
    print(pq)
    pq.modify(9, -2)
    print(pq)
    pq.modify(-2, 10)
    print(pq)
    pq.modify(-1, 20)
    print(pq)