Scribd
Upload
35 views

"A" "C" "B" "C" "E" "C" "A" "B" "D" "E" "D" "C" "E" "C" "B" "F"

This document discusses representing graphs as dictionaries in Python and defining functions to generate edges, find isolated nodes, and create a Graph class. It includes examples of creating a graph, adding vertices and edges, and iterating over the graph. NetworkX is also used to draw example graphs visually.

Uploaded by

3PA01Vanya Nayla Reza Basri
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
35 views

"A" "C" "B" "C" "E" "C" "A" "B" "D" "E" "D" "C" "E" "C" "B" "F"

This document discusses representing graphs as dictionaries in Python and defining functions to generate edges, find isolated nodes, and create a Graph class. It includes examples of creating a graph, adding vertices and edges, and iterating over the graph. NetworkX is also used to draw example graphs visually.

Uploaded by

3PA01Vanya Nayla Reza Basri
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

## Blok program ini Anda mencoba mendefinisikan node dan hubungan

Antara node dalam bent


graph = { "a" : {"c"},
"b" : {"c", "e"},
"c" : {"a", "b", "d", "e"},
"d" : {"c"},
"e" : {"c", "b"},
"f" : {}
}

## Blok program ini Anda mencoba membuat EDGE dari informasi yang
sudah Anda definisikan sebelumnya.
def generate_edges(graph):
edges = []
for node in graph:
for neighbour in graph[node]:
edges.append({node, neighbour})

return edges

print(generate_edges(graph))

[{'c', 'a'}, {'c', 'b'}, {'b', 'e'}, {'c', 'b'}, {'c', 'a'}, {'c',
'd'}, {'c', 'e'}, {'c', 'd'}, {'c', 'e'}, {'b', 'e'}]

## Blok program ini Anda mendefinisikan sebuah fungsi untuk mengetahui


node mana yang tidak memiliki edge
def find_isolated_nodes(graph):
""" returns a set of isolated nodes. """
isolated = set()
for node in graph:
if not graph[node]:
isolated.add(node)
return isolated

print(find_isolated_nodes(graph))

{'f'}

""" A Python Class


A simple Python graph class, demonstrating the essential
facts and functionalities of graphs.
"""

class Graph(object):

def __init__(self, graph_dict=None):


""" initializes a graph object
If no dictionary or None is given,
an empty dictionary will be used
"""
if graph_dict == None:
graph_dict = {}
self._graph_dict = graph_dict

def edges(self, vertice):


""" returns a list of all the edges of a vertice"""
return self._graph_dict[vertice]

def all_vertices(self):
""" returns the vertices of a graph as a set """
return set(self._graph_dict.keys())

def all_edges(self):
""" returns the edges of a graph """
return self.__generate_edges()

def add_vertex(self, vertex):


""" If the vertex "vertex" is not in
self._graph_dict, a key "vertex" with an empty
list as a value is added to the dictionary.
Otherwise nothing has to be done.
"""
if vertex not in self._graph_dict:
self._graph_dict[vertex] = []

def add_edge(self, edge):


""" assumes that edge is of type set, tuple or list;
between two vertices can be multiple edges!
"""
edge = set(edge)
vertex1, vertex2 = tuple(edge)
for x, y in [(vertex1, vertex2), (vertex2, vertex1)]:
if x in self._graph_dict:
self._graph_dict[x].add(y)
else:
self._graph_dict[x] = [y]

def __generate_edges(self):
""" A static method generating the edges of the
graph "graph". Edges are represented as sets
with one (a loop back to the vertex) or two
vertices
"""
edges = []
for vertex in self._graph_dict:
for neighbour in self._graph_dict[vertex]:
if {neighbour, vertex} not in edges:
edges.append({vertex, neighbour})
return edges
def __iter__(self):
self._iter_obj = iter(self._graph_dict)
return self._iter_obj

def __next__(self):
""" allows us to iterate over the vertices """
return next(self._iter_obj)

def __str__(self):
res = "vertices: "
for k in self._graph_dict:
res += str(k) + " "
res += "\nedges: "
for edge in self.__generate_edges():
res += str(edge) + " "
return res

g = { "a" : {"d"},
"b" : {"c"},
"c" : {"b", "c", "d", "e"},
"d" : {"a", "c"},
"e" : {"c"},
"f" : {}
}

graph = Graph(g)

for vertice in graph:


print("Edges of vertice {vertice}: ", graph.edges(vertice))

Edges of vertice {vertice}: {'d'}


Edges of vertice {vertice}: {'c'}
Edges of vertice {vertice}: {'c', 'b', 'd', 'e'}
Edges of vertice {vertice}: {'c', 'a'}
Edges of vertice {vertice}: {'c'}
Edges of vertice {vertice}: {}

graph.add_edge({"ab", "fg"})
graph.add_edge({"xyz", "bla"})

print("")
print("Vertices of graph:")
print(graph.all_vertices())

print("Edges of graph:")
print(graph.all_edges())

Vertices of graph:
{'d', 'xyz', 'bla', 'ab', 'c', 'f', 'fg', 'b', 'a', 'e'}
Edges of graph:
[{'d', 'a'}, {'c', 'b'}, {'c'}, {'c', 'd'}, {'c', 'e'}, {'ab', 'fg'},
{'bla', 'xyz'}]

import networkx as nx
import matplotlib.pyplot as plt

# Creating a Graph
G = nx.Graph() # Right now G is empty

G.add_node(1)
G.add_nodes_from([2,3])

G.add_edge(1,2)

e = (2,3)
G.add_edge(*e) # * unpacks the tuple
G.add_edges_from([(1,2), (1,3)])

G.nodes()

NodeView((1, 2, 3))

G.edges()

EdgeView([(1, 2), (1, 3), (2, 3)])

G.add_edge(1, 2)
G.add_edge(2, 3)
G.add_edge(3, 4)
G.add_edge(1, 4)
G.add_edge(1, 5)

nx.draw(G, with_labels = True)


plt.savefig("contoh-graf-1.png")

<Figure size 432x288 with 0 Axes>

# drawing in circular layout


nx.draw_circular(G, with_labels = True)
nx.draw_planar(G, with_labels = True)

nx.draw_random(G, with_labels = True)


nx.draw_spectral(G, with_labels = True)

nx.draw_spring(G, with_labels = True)


nx.draw_shell(G, with_labels = True)

You might also like