graph.py

class Graph:
    def __init__(self, graph_dict = {}, directed = False):
        self.graph_dict = graph_dict
        self.directed = directed
    
    def __str__(self):
        M = self.getMatrix()
        S = '\n'.join([''.join(['{:4}'.format(item) for item in row]) for row in M])
        return "\n"+S+"\n"
    
    def nodes(self):
        return list(self.graph_dict.keys())
    
    def addNode(self, node_id):
        self.graph_dict[node_id] = {}
        return self
    
    def createEdge(self, node_idA, node_idB, weight = 1):
        nodeA_connections = self.graph_dict.get(node_idA)
        nodeA_connections.update({node_idB:weight})
        self.graph_dict.update({node_idA:nodeA_connections})
        return self

    def deleteEdge(self, node_idA, node_idB):
        del self.graph_dict[node_idA][node_idB]

    def removeEdge(self, node_idA, node_idB):
        self.deleteEdge(node_idA, node_idB)
        if (not self.directed):
            self.deleteEdge(node_idB, node_idA)

    def removeNode(self, node_id):
        connections = self.graph_dict[node_id]
        for node_adj in set(connections):
            self.deleteEdge(node_id,node_adj)
            self.deleteEdge(node_adj,node_id)
        del self.graph_dict[node_id]

    def addEdge(self, node_idA, node_idB, weight = 1):
        self.createEdge(node_idA, node_idB, weight)
        if (not self.directed):
            self.createEdge(node_idB, node_idA, weight)
        return self

    def getEdgeWeight(self, node_idA, node_idB):
        return self.graph_dict.get(node_idA).get(node_idB,0) 

    def getMatrix(self):
        matrix = [[self.getEdgeWeight(i,j) for j in self.nodes()] for i in self.nodes()] 
        return matrix


adj_dict_weights = {
  "v0": {"v1":1},
  "v1": {"v0":1,"v2":1,"v3":1},
  "v2": {"v1":1,"v3":1},
  "v3": {"v1":1,"v2":1}
}
graph = Graph()

graph.addNode(1)
graph.addNode(2)
graph.addNode(3)
print(graph)

graph.addEdge(1,2)
graph.addEdge(1,3)
print(graph)

graph.removeNode(3)
print(graph)

graph.removeEdge(1,2)
print(graph)