如何在Python中从图形中删除边

我正在阅读ThinkComplexity一书，我对python还不熟悉，所以我有以下代码：

class Graph(dict):
    def __init__(self, vs=[], es=[]):
        """
        :param vs: list of vertices/nodes in the graph
        :param es: list of edges/connection for the nodes
        :return: Object graph
        """

        for v in vs:
            self.add_vertex(v) #also node
        for e in es:
            self.add_edge(e) #arc/edge/line

     def add_vertex(self, v):
         """
         :param v: Add the node/vertex to the graph
         :return: Nothing just add
         """
         self[v] = {}

     def add_edge(self, e):
         """
         :param e: Add arc/edge/line to the graph here is in both directions as it is undirected graph, if there is a arc already replace it
         :return: Nothing just add
         """
         v, w = e
         self[v][w] = e
         self[w][v] = e

     def get_edge(self, v1, v2):
         try:
             if self != None:
                if self[v1][v2] == self[v2][v1]:
                     print 'got it'
                     return True

        except:
             return None


     def remove_edge(self, e, e2):
         try:
            if self != None:
                 del self[e][e2]
                 del self[e2][e]
                 print 'deleted\n', e[0], e[1]
                 return True

         except:
             return None


     def vertices(self): #get the list of nodes
         nodes = []
         for node in self.keys():
             nodes.append(node.label)
         print nodes, '\n'
         return nodes


    def edges(self):
         list_edges = []
         count = 0
         for node in self:
            for edges in self[node]:
                 count += 1
                 print self[node].values(), count
                 list_edges.append(self[node].values())

         return list_edges

    def out_vertices(self, v): #nodes connected to this node
        connected = []
        for node in v.keys():
            connected.append(node)
            print node, 'this node is connected to', v.keys()

        return connected

    def out_edges(self, v):
        list_out_edges = []
        for ed in v.values():
            print ed, 'edges from to'
            list_out_edges.append(ed)

        return list_out_edges



class Vertex(object): #nodes fro the graph
    def __init__(self, label=''):
        self.label = label

    def __repr__(self):
        return 'Vertex/Node(%s)' % repr(self.label)

    __str__= __repr__


class Edge(tuple):
     def __new__(cls, e1, e2):
        return tuple.__new__(cls, (e1, e2))

     def __repr__(self):
         return 'Edge(%s---%s) <-undirected' % (repr(self[0]), repr(self[1]))

     __str__ = __repr__

类图（dict）：
定义初始化（self，vs=[]，es=[]）：
"""
：param vs：图形中的顶点/节点列表
：param es：节点的边/连接列表
：return：对象图
"""
对于vs中的v：
self.add_顶点（v）#同时添加节点
对于es中的e：
自我添加_边（e）#弧/边/线
def添加_顶点（自身，v）：
"""
：param v：将节点/顶点添加到图形中
：return：无需添加任何内容
"""
self[v]={}
def添加_边缘（自身，e）：
"""
：param e：将弧/边/线添加到图形中此处是双向的，因为它是无向图形，如果已存在弧，则将其替换
：return：无需添加任何内容
"""
v、 w=e
自我[v][w]=e
自我[w][v]=e
def get_边缘（自身、v1、v2）：
尝试：
如果自我！=无：
如果self[v1][v2]==self[v2][v1]：
打印“明白了”
返回真值
除：
一无所获
def移除_边缘（自身、e、e2）：
尝试：
如果自我！=无：
del self[e][e2]
del self[e2][e]
打印“已删除”\n'，e[0]，e[1]
返回真值
除：
一无所获
定义顶点（自身）：#获取节点列表
节点=[]
对于self.keys（）中的节点：
nodes.append（node.label）
打印节点，'\n'
返回节点
def边缘（自）：
列表_边=[]
计数=0
对于自身中的节点：
对于自[节点]中的边：
计数+=1
打印自身[node]。值（），计数
列出_边。追加（self[node].values（））
返回列表
def out_顶点（self，v）：#连接到此节点的节点
已连接=[]
对于v.keys（）中的节点：
已连接。追加（节点）
打印节点“此节点已连接到”，v.keys（）
返回连接
def out_边缘（自身，v）：
列出_out_边=[]
对于v.values（）中的ed：
打印“从到的边”
列出边。附加（ed）
返回列表\u out\u边
类顶点（对象）：#图中的节点
定义初始化（self，标签=“”）：
self.label=标签
定义报告（自我）：
返回“顶点/节点（%s）”%repr（self.label）
__str\uuuuuu=\uuuuuuu repr__
类边（元组）：
定义新（cls、e1、e2）：
返回元组。\uuuu新的\uuuu（cls，（e1，e2））
定义报告（自我）：
返回边（%s---%s）如下：

def remove_edge(g, e, e2):
   try:
       if g != None:
           del g[e][e2]
           del g[e2][e]
           print 'deleted\n', e[0], e[1]
       return True

   except:
       return None 

字典中的键可以是对象，而不仅仅是str，并且需要以两种方式执行，因为它是无向的
，因此您的图形是一个字典（字典），对于边u，v，条目v中有一个条目u，反之亦然。我猜您正在搜索如何从字典中删除元素是的，我看到了，但如何获取该边缘的密钥？啊哈，我看到了字典密钥可以是对象，不一定是str，很酷。谢谢。请阅读此处的“hashable”段落。你介意修一下凹痕吗？小心点。您的代码之所以有效，是因为
Edge
是
tuple
的一个子类，但是
dict
键不能只是任意对象；它们只能是散列对象（本质上是指不可变的类型，如
str
、
int
、
tuple
，但不能是
list
）。有关更多详细信息，请阅读Python wiki：