为什么我在字典的实现中收到Python键错误？

由于某些原因，我无法在下图的实现中查找正确的键。由于字典的错误实现，我一直收到一个keyrerror。我已经研究了好几个小时了，仍然不知道问题出在哪里

> KeyError                                  Traceback (most recent call
> last)
> C:\Users\AppData\Local\Enthought\Canopy\App\appdata\canopy-1.4.0.1938.win-x86_64\lib\site-packages\IPython\utils\py3compat.pyc
> in execfile(fname, glob, loc)
>     195             else:
>     196                 filename = fname
> --> 197             exec compile(scripttext, filename, 'exec') in glob, loc
>     198     else:
>     199         def execfile(fname, *where):
> 
> C:\Users\ps5.py in <module>()
>      69     
>      70 
> ---> 71 bigMap = load_map(mapFile)
>      72 
> 
> C:\Users\ps5.py in load_map(mapFilename)
>      51         e1 = WeightedEdge(nx, ny, ex, ey)
>      52         
> ---> 53         g.addEdge(e1)
>      54     return g
>      55     
> 
> C:\Users\graph.py in addEdge(self, edge)
>      74         if not (src.getName() in self.nodes and dest.getName() in self.nodes):
>      75             raise ValueError('Node not in graph')
> ---> 76         self.edges[src].append([dest, (edge.getTotalDistance(), edge.getOutdoorDistance())])
>      77 
>      78     def __str__(self):
> 
> KeyError: <graph.Node object at 0x00000000080B1A90>


class Node(object): 
    def __init__(self, name): 
        self.name = str(name) 
    def getName(self): 
        return self.name
    def __str__(self): 
        return self.name

class Edge(object): 
    def __init__(self, src, dest): 
        self.src = src
        self.dest = dest
    def getSource(self): 
        return self.src
    def getDestination(self): 
        return self.dest 
    def __str__(self): 
        return str(self.src) + '->' + str(self.dest) 

class WeightedEdge(Edge): 
    def __init__(self, src, dest, totalDistance, outdoorDistance): 
        self.src = src
        self.dest = dest 
        self.totalDistance = float(totalDistance) 
        self.outdoorDistance = float(outdoorDistance) 
    def getWeight(self): 
        return self.weight
    def __str__(self): 
        return str(self.src) + '->' + str(self.dest) + ' (' + \
        str(self.totalDistance) + ', ' + str(self.outdoorDistance) + ')'
    def getTotalDistance(self):
        return self.totalDistance 
    def getOutdoorDistance(self): 
        return self.outdoorDistance

class Digraph(object): 
    def __init__(self): 
        self.nodes = set([])
        self.edges = {} 
    def addNode(self, node): 
        if node.getName() in self.nodes: 
            raise ValueError('Duplicate node') 
        else: 
            self.nodes.add(node.getName()) 
            self.edges[node] = [] 
    def addEdge(self, edge): 
        src = edge.getSource() 
        dest = edge.getDestination() 
        if not(src in self.nodes and dest in self.nodes): 
            raise ValueError('Node not in graph') 
        self.edges[src].append(dest) 
    def childrenOf(self, node): 
        return self.edges[node]
    def hasNode(self, node): 
        return str(node) in self.nodes
    def __str__(self): 
        res = ''
        for k in self.edges: 
            for d in self.edges[k]: 
                res = res + str(k) + '->' + str(d) + '\n'
        return res[:-1]

class Graph(Digraph): 
    def addEdge(self, edge): 
        Digraph.addEdge(self, edge)
        rev = Edge(edge.getDestination(), edge.getSource()) 
        Digraph.addEdge(self, rev)

class WeightedDigraph(Digraph): 

    def addEdge(self, edge):
        src = edge.getSource() 
        dest = edge.getDestination()
        if not (src.getName() in self.nodes and dest.getName() in self.nodes): 
            raise ValueError('Node not in graph')
        self.edges[src].append([dest, (edge.getTotalDistance(), edge.getOutdoorDistance())])

    def __str__(self): 
        res = ''
        for k in self.edges: 
            for d in self.edges[k]:
                res = res + str(k) + '->' + str(d[0]) + ' (' + str(float(d[1][0])) + ', ' + str(float(d[1][1])) + ')' + '\n'
        return res[:-1]

    def childrenOf(self, node): 
        children = [] 
        for child in self.edges[node]: 
            children.append(child[0]) 
        return children

def load_map(mapFilename):
    dataFile = open(mapFilename, 'r')
    g = WeightedDigraph() 
    for line in dataFile: 
        nx, ny, ex, ey = line.split() 
        nx = Node(nx) 
        ny = Node(ny) 
        if not g.hasNode(nx): 
            g.addNode(nx) 
        if not g.hasNode(ny): 
            g.addNode(ny)     
        e1 = WeightedEdge(nx, ny, ex, ey)
        g.addEdge(e1) 
   return g

bigMap = load_map(mapFile) 

>键错误回溯（最近的调用
>最后)
>C:\Users\AppData\Local\enthund\Canopy\App\AppData\Canopy-1.4.0.1938.win-x86\u 64\lib\site packages\IPython\utils\py3compat.pyc
>在execfile中（fname、glob、loc）
>195其他：
>196 filename=fname
>-->197 exec编译（脚本文本，文件名，'exec'），在glob，loc中
>198其他：
>199 def execfile（fname，*其中）：
> 
>C:\Users\ps5.py in（）
>      69     
>      70 
>-->71 bigMap=加载映射（映射文件）
>      72 
> 
>加载映射（mapFilename）中的C:\Users\ps5.py
>51 e1=加权边缘（nx、ny、ex、ey）
>      52         
>--->53克增补（e1）
>54返回g
>      55     
> 
>C:\Users\graph.py在addEdge（self，edge）中
>74如果不是（self.nodes中的src.getName（）和self.nodes中的dest.getName（））：
>75 raise VALUERROR（'节点不在图形中'）
>-->76 self.edges[src].append（[dest，（edge.getTotalInstance（），edge.getOutdoorDistance（）））
>      77 
>78 def________（自我）：
> 
>关键错误：
类节点（对象）：
定义初始化（self，name）：
self.name=str（name）
def getName（self）：
返回self.name
定义（自我）：
返回self.name
类边（对象）：
定义初始（自、src、目的地）：
self.src=src
self.dest=dest
def getSource（自）：
返回self.src
def getDestination（自我）：
返回自我目的地
定义（自我）：
返回str（self.src）+'->'+str（self.dest）
类权重边（边）：
定义初始距离（自身、src、目的地、总距离、户外距离）：
self.src=src
self.dest=dest
self.totalDistance=浮动（totalDistance）
self.outdoorDistance=浮动（outdoorDistance）
def getWeight（自身）：
回重
定义（自我）：
返回str（self.src）+'->'+str（self.dest）+'（'+\
str（自我总距离）+'，'+str（自我户外距离）+'）
def GetTotalInstance（自身）：
返回自我距离
def GetOutdoor距离（自身）：
返回自室外距离
类有向图（对象）：
定义初始化（自）：
self.nodes=set（[]）
self.edges={}
def addNode（自身，节点）：
如果self.nodes中的node.getName（）：
提升值错误（'重复节点'）
其他：
self.nodes.add（node.getName（））
self.edges[节点]=[]
def addEdge（自身、边缘）：
src=edge.getSource（）
dest=edge.getDestination（）
如果不是（self.nodes中的src和self.nodes中的dest）：
raise VALUERROR（'节点不在图形中'）
self.edges[src].append（dest）
def childrenOf（自身，节点）：
返回self.edges[节点]
def hasNode（自身，节点）：
返回self.nodes中的str（node）
定义（自我）：
res=''
对于自边中的k：
对于自边[k]中的d：
res=res+str（k）+'->'+str（d）+'\n'
返回res[：-1]
类图（有向图）：
def addEdge（自身、边缘）：
有向图.增边（自、边）
rev=Edge（Edge.getDestination（），Edge.getSource（））
有向图加增（自，修订）
类加权迁移图（有向图）：
def addEdge（自身、边缘）：
src=edge.getSource（）
dest=edge.getDestination（）
如果不是（self.nodes中的src.getName（）和self.nodes中的dest.getName（））：
raise VALUERROR（'节点不在图形中'）
self.edges[src].append（[dest，（edge.getTotalInstance（），edge.getOutdoorDistance（）））
定义（自我）：
res=''
对于自边中的k：
对于自边[k]中的d：
res=res+str（k）+'->'+str（d[0]）+'（'+str（float（d[1][0]））+'，'+str（float（d[1][1]））+'））'+'\n'
返回res[：-1]
def childrenOf（自身，节点）：
儿童=[]
对于self.edges[节点]中的子节点：
附加（子[0]）
返回儿童
def load_映射（映射文件名）：
数据文件=打开（映射文件名'r'）
g=加权图（）
对于数据文件中的行：
nx，ny，ex，ey=line.split（）
nx=节点（nx）
ny=节点（ny）
如果不是g.hasNode（nx）：
g、 addNode（nx）
如果不是g.hasNode（纽约）：
g、 addNode（纽约）
e1=加权边缘（nx、ny、ex、ey）
g、 附录（e1）
返回g
bigMap=加载映射（映射文件）

因此，您的错误似乎出现在

加权digraph.addEdge（self，edge）

中

传入一个edge对象并获取源（

src=edge.getSource（）

）。通过使用调试器，我能够查看字典

self.edges

，并且我看到键的格式是

{:}

实际调试视图给了我以下信息：

self.edges = { <__main__.Node object at 0x10f1d4350>: [] }

及

这是一个堆栈溢出问题，正好解决了这个问题：

我做了一个快速标记，它似乎修复了您的关键错误

---

此外，我强烈建议使用调试器（pydb（）就是这样一种调试器，但许多调试器都内置在IDE中），因为我就是这样发现错误的。

请添加整个堆栈tracethanks-刚刚添加了它。

def __hash__(self)

def __eq__(self, other)