使用邻接表的方法构造带权图，并利用Dijkstra算法寻找从某个源点到其他所有顶点的最短路径，要求： （1）写出完整的带权图的实现程序，不能直接import pythonds中的Graph和Vertex模块； （2）允许使用pythonds中的PriorityQueue模块辅助实现Dijkstra算法； （3）测试代码

好的，我理解你的问题了。下面是一个完整的实现程序，包括带权图的构造和使用Dijkstra算法寻找最短路径的代码：

from pythonds3.priorityQueue import PriorityQueue

class Vertex:
    def __init__(self, key):
        self.id = key
        self.connectedTo = {}
        self.distance = float('inf')
        self.visited = False
        self.previous = None

    def addNeighbor(self, nbr, weight=0):
        self.connectedTo[nbr] = weight

    def getConnections(self):
        return self.connectedTo.keys()

    def getId(self):
        return self.id

    def getWeight(self, nbr):
        return self.connectedTo[nbr]

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

    def getDistance(self):
        return self.distance

    def setVisited(self):
        self.visited = True

    def getVisited(self):
        return self.visited

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

    def getPrevious(self):
        return self.previous

class Graph:
    def __init__(self):
        self.vertices = {}
        self.numVertices = 0

    def addVertex(self, key):
        self.numVertices += 1
        newVertex = Vertex(key)
        self.vertices[key] = newVertex
        return newVertex

    def getVertex(self, key):
        if key in self.vertices:
            return self.vertices[key]
        else:
            return None

    def addEdge(self, fromVert, toVert, weight=0):
        if fromVert not in self.vertices:
            self.addVertex(fromVert)
        if toVert not in self.vertices:
            self.addVertex(toVert)
        self.vertices[fromVert].addNeighbor(self.vertices[toVert], weight)

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

    def __iter__(self):
        return iter(self.vertices.values())

def dijkstra(aGraph, start):
    pq = PriorityQueue()
    start.setDistance(0)
    pq.buildHeap([(v.getDistance(), v) for v in aGraph])
    while not pq.isEmpty():
        currentVert = pq.delMin()
        for nextVert in currentVert.getConnections():
            newDist = currentVert.getDistance() \
                    + currentVert.getWeight(nextVert)
            if newDist < nextVert.getDistance():
                nextVert.setDistance(newDist)
                nextVert.setPrevious(currentVert)
                pq.decreaseKey(nextVert, newDist)

def shortest(v, path):
    if v.getPrevious():
        path.append(v.getPrevious().getId())
        shortest(v.getPrevious(), path)
    return

g = Graph()
g.addEdge('A', 'B', 2)
g.addEdge('A', 'C', 3)
g.addEdge('B', 'C', 1)
g.addEdge('B', 'D', 1)
g.addEdge('C', 'D', 4)
g.addEdge('D', 'E', 3)

start = g.getVertex('A')
dijkstra(g, start)

for v in g:
    path = [v.getId()]
    shortest(v, path)
    print('The shortest path for vertex', v.getId(), 'is', path[::-1], 'with a distance of', v.getDistance())

这个实现程序中，我们首先定义了Vertex类来表示每个顶点，并将每个顶点存储在一个字典中。在Vertex类中，我们存储了每个顶点的邻接点、权重、距离、是否访问过以及前一个顶点。然后，我们定义了Graph类来管理所有的顶点和边。在Graph类中，我们可以添加新的顶点和边，获取所有的顶点以及实现__iter__方法来迭代所有的顶点。最后，我们使用Dijkstra算法来寻找从某个源点到其他所有顶点的最短路径，并输出结果。

希望这个实现程序能够帮助到你！