# How to Create Graph Data Structure in Python?

//

Scott Campbell

Creating a Graph Data Structure in Python

The graph data structure is a fundamental concept in computer science and is widely used to represent relationships between objects or entities. In this tutorial, we will explore how to create a graph data structure in Python.

## Graphs

A graph consists of two main components: nodes (also known as vertices) and edges. Nodes represent the entities, while edges represent the relationships or connections between them.

### Types of Graphs

There are various types of graphs, including directed graphs, undirected graphs, weighted graphs, and unweighted graphs. In this tutorial, we will focus on creating an undirected graph without weights.

## Creating a Graph Class

To create a graph data structure in Python, we can define a class that represents the graph and provides methods to interact with it.

Step 1: Create a Python file and name it “graph.py”. Open the file in your preferred code editor.

Step 2: Define the Graph class using the following code:

```class Graph:
def __init__(self):
self.graph = {}
```

Here, we initialize an empty dictionary called “graph” inside the constructor (__init__ method) of our Graph class.

To add nodes to our graph, we can define a method called “add_node”. This method takes a parameter representing the node value and adds it to the graph dictionary.

Step 3: Add the following code inside the Graph class:

```def add_node(self, node):
if node not in self.graph:
self.graph[node] = []
```

In this method, we check if the given node already exists in our graph. If not, we add it as a key in the graph dictionary with an empty list as its value.

To add edges between nodes, we can define a method called “add_edge”. This method takes two parameters representing the source and Target nodes and adds an edge between them.

Step 4: Add the following code inside the Graph class:

```def add_edge(self, src, Target):
if src in self.graph and Target in self.graph[src].append(target)
self.graph[target].append(src)
```

In this method, we first check if both the source and Target nodes exist in our graph. If they do, we add an edge between them by appending each node to the other’s list of adjacent nodes.

## Visualizing the Graph

To visualize our graph, we can define a method called “print_graph”. This method prints all the nodes and their corresponding adjacent nodes.

Step 5: Add the following code inside the Graph class:

```def print_graph(self):
for node in self.graph:
print(f"{node}: {self.graph[node]}")
```

In this method, we iterate over each node in our graph and print it along with its adjacent nodes.

## Testing our Graph Class

Now that we have defined our Graph class, let’s test it by creating a graph instance and adding some nodes and edges.

Step 6: Add the following code below the Graph class definition:

```# Create a new instance of Graph
my_graph = Graph()

# Print the graph
my_graph.print_graph()
```

In this code, we create a new instance of our Graph class called “my_graph”. We then add some nodes (“A”, “B”, “C”, and “D”) and connect them with edges.

## Conclusion

In this tutorial, we learned how to create a graph data structure in Python. We defined a Graph class that allows us to add nodes and edges, as well as print the graph’s contents. The graph data structure is essential for solving various problems, such as route planning, social network analysis, and more.

Remember: Understanding graphs and their implementation in Python will open doors to solving complex problems efficiently. Explore different types of graphs and experiment with additional functionalities to enhance your understanding of this versatile data structure.