#173: Create Graphs with NetworkX

Today we make a small deviation from the plots of Matplotlib and work with networks and graphs (as in computer science). Having a structure that allows us to define objects and their relation to each other is not only interesting for theoretical problems. In this post we look at the basics and next week we put that knowledge into practical use.

Install NetworkX

NetworkX allows us to work with complex networks and analyse their structure. We can install it with this command:

pip install networkx

If you want to get NumPy and SciPy with NetworkX, you can use this command instead:

pip install networkx[default]

Creating a graph

We can create a graph with the Graph() method:

import networkx as nx

G = nx.Graph()

This gives us an undirected graph, a graph in which the direction of an edge between two nodes does not matter.

Add nodes

We can add nodes one by one or in bulk:

G.add_node(1)

G.add_nodes_from([2, 3])

NetworkX allows us to use any arbitrary (hashable) Python objects for our nodes – except None. That allows us to use strings with more useful names for our graphs:

G.add_node("A")

G.add_nodes_from(["B", "C"])

We can ask the graph about the number of nodes and what nodes it has:

G.number_of_nodes()
# 6

G.nodes()
# NodeView((1, 2, 3, 'A', 'B', 'C'))

Add edges

We can connect the nodes with edges. As with nodes, we can add a single edge or add edges in bulk:

G.add_edge(1, 2)

G.add_edges_from([(1, 'A'), (2, 3), ("B", "C")])

We can ask the graph about the number of edges and what edges exist:

G.number_of_edges()
# 4

G.edges()
# EdgeView([(1, 2), (1, 'A'), (2, 3), ('B', 'C')])

Draw the graph

We can get the graphical representation of our graph with the draw() method:

import matplotlib.pyplot as plt

options = {
    'node_color': 'deepskyblue',
    'node_size': 400,
    'width': 3,
    'with_labels': True
}

nx.draw(G, **options)

As you can see from the import, NetworkX uses Matplotlib for its drawings. The code above draws our graph with a random location for the nodes and will look differently on each run:

The connections in our graph are visible.

If you want a representation that changes less, you can use the draw_circular() method:

nx.draw_circular(G, **options)

This puts all nodes in a circle and draws the edges between them:

The nodes are now all on a circle

The order of the nodes may still vary, but at least the nodes are in an expected position.

Directed graphs

If we want to create a graph in which the direction of the edge matters, we can create a directed graph with the DiGraph() method:

G = nx.DiGraph()
G.add_node(1)
G.add_nodes_from([2, 3])
G.add_node("A")
G.add_nodes_from(["B", "C"])
G.add_edge(1, 2)
G.add_edges_from([(1, 'A'), (2, 3), ("B", "C")])

Everything else stays the same, but now the order in which we place our nodes in the edges matters. We see the effect when we print our directed graph:

The nodes are connected as before, but now you see a little arrow that indicates the direction.

The nodes and the edges are the same as before, but now we have a little arrow head on the edge that shows in which direction the connection goes.