使用邻接表的方法构造带权图，并利用Dijkstra算法寻找从某个源点到其他所有顶点的最短路径，要求： （1）写出完整的带权图的实现程序，不能直接import pythonds中的Graph和Vertex模块； （2）允许使用pythonds中的PriorityQueue模块辅助实现Dijkstra算法； （3）需要详细描述算法的设计思路，并对程序添加详细的注释。

好的，下面是一个使用邻接表实现的带权图和Dijkstra算法的程序示例：

from queue import PriorityQueue

# 定义节点类
class Vertex:
    def __init__(self, node):
        self.id = node
        self.adjacent = {}
        self.distance = float('inf')
        self.visited = False
        self.previous = None

    def add_neighbor(self, neighbor, weight=0):
        self.adjacent[neighbor] = weight

    def get_connections(self):
        return self.adjacent.keys()

    def get_id(self):
        return self.id

    def get_weight(self, neighbor):
        return self.adjacent[neighbor]

    def set_distance(self, dist):
        self.distance = dist

    def get_distance(self):
        return self.distance

    def set_previous(self, prev):
        self.previous = prev

    def set_visited(self):
        self.visited = True

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

# 定义图类
class Graph:
    def __init__(self):
        self.vertices = {}

    def add_vertex(self, node):
        self.vertices[node] = Vertex(node)

    def add_edge(self, start, end, weight=0):
        if start not in self.vertices:
            self.add_vertex(start)
        if end not in self.vertices:
            self.add_vertex(end)
        self.vertices[start].add_neighbor(self.vertices[end], weight)

    def get_vertex(self, node):
        if node in self.vertices:
            return self.vertices[node]
        else:
            return None

    def get_vertices(self):
        return self.vertices.keys()

# 定义Dijkstra算法函数
def dijkstra(graph, start):
    start.set_distance(0)
    pq = PriorityQueue()
    pq.put(start)

    while not pq.empty():
        current_vertex = pq.get()

        for neighbor in current_vertex.get_connections():
            temp_dist = current_vertex.get_distance() + current_vertex.get_weight(neighbor)

            if temp_dist < neighbor.get_distance():
                neighbor.set_distance(temp_dist)
                neighbor.set_previous(current_vertex)

                if not neighbor.visited:
                    neighbor.set_visited()
                    pq.put(neighbor)

# 测试代码
g = Graph()
g.add_vertex('A')
g.add_vertex('B')
g.add_vertex('C')
g.add_vertex('D')
g.add_vertex('E')
g.add_vertex('F')

g.add_edge('A', 'B', 2)
g.add_edge('A', 'C', 5)
g.add_edge('B', 'C', 1)
g.add_edge('B', 'D', 3)
g.add_edge('C', 'D', 2)
g.add_edge('C', 'E', 5)
g.add_edge('D', 'E', 1)
g.add_edge('D', 'F', 4)
g.add_edge('E', 'F', 1)

start_vertex = g.get_vertex('A')
dijkstra(g, start_vertex)

for v in g.get_vertices():
    print("Shortest distance to vertex", v, "is", g.get_vertex(v).get_distance())

在上面的程序中，我们首先定义了节点类Vertex和图类Graph，其中节点类Vertex包含节点id、邻居节点、距离、是否被访问和前驱节点等信息，图类Graph包含节点列表等信息。我们可以使用add_vertex方法和add_edge方法向图中添加节点和边。

在实现Dijkstra算法时，我们需要使用优先队列PriorityQueue来存储节点，以支持以最小距离为关键字的优先级排序。在dijkstra函数中，我们首先将起点的距离设置为0，并将起点加入优先队列中。然后，我们循环遍历队列中的节点，对于每个节点的邻居节点，计算从起点到该邻居节点的距离，并更新该邻居节点的距离和前驱节点信息。最后，我们使用put方法将更新后的节点重新加入优先队列中。

在测试代码中，我们创建了一个带权图，并使用dijkstra函数计算了从起点A到其它节点的最短路径。输出结果为每个节点的id和距离。

需要注意的是，上面的程序只是一个简单的示例，实际应用中可能需要增加更多的功能和处理异常情况的代码。