Python networkx library quick start guide

Python
NetworkX Library
Quick Start Guide
Mohammed Zuhair Al-Taie
Big Data Centre - Universiti Teknologi Malaysia - 2016

python networkx library – quick start guide
The fast developments in the Web and Internet in the last decade and the advancements in computing and
communication have drawn people in innovative ways
Sites, such as Twitter, Facebook, LinkedIn, and MySpace allow people to make new virtual relationships.
Sending and receiving emails, visiting a Webpage or posting a comment on a blog site leaves a digital
footprint that can be traced back to the person or group behind it.
Vast amounts of network data are being generated and collected.
How can we analyse these data?
New Age of Web Usage

Networks in real world fall into the following four major types
Social networks: Networks in which vertices represent people and edges represent some form of
social interaction between vertices including friendship, kinship, information flow, disease outbreak,
etc.
Information networks: Man-made networks in which data items are linked together in some way.
The best-known example is the World Wide Web (WWW)
Technological networks: Man-made networks that are designed to distribute commodity or
resources. One of the greatest examples is the Internet.
Biological networks: Networks that represent patterns of interaction between biological elements.
Real-World Networks

A graph is a set of points and lines that connect them.
It is a way of representing the relationships among a collection of objects.
Points are called 'vertices', and lines are called 'edges‘.
A graph G with a set X of vertices together with a set E of edges is written as G = (X, E)
Graph: Basic Concepts

There are several different types of graphs to represent the relationship between nodes:
Undirected graph, Directed graph, Weighted graph, Planar graph, Orthogonal graph, Grid-based
graph, etc.
The degree of a vertex is the number of edges incident to it.
For directed graphs, out-degree measure is the number of outgoing edges, while in-degree measure is the
number of incoming edges.
Types of Graphs

NetworkX is a Python language software package and an open-source tool for the creation, manipulation,
and study of the structure, dynamics, and functions of complex networks.
Complex networks are networks with non-trivial topological features—features that do not occur in simple networks
such as lattices or random graphs but often occur in real graphs. E.g.: circadian rhythms, electrochemical reactions,
laser arrays, neuron networks, Josephson junction arrays..., etc.
NetworkX can load, store and analyze networks, generate new networks, build network models, and draw
networks.
It is a computational network modelling tool and not a software tool development.
The first public release of the library, which is all based on Python, was in April 2005.
The library can engage with languages other than Python such as C, C++, and FORTRAN.
What is NetworkX?

Although NetworkX is not ideal for large-scale problems with fast processing requirements, it is a great option
for real-world network analysis:
Most of the core algorithms rely on extremely fast legacy code.
It uses standard graph algorithms
It has an extensive set of native readable and writable formats.
It is easy to install and use on major platforms with a strong online up-to-date documentation.
It is Ideal for representing networks of different types like e.g. classic graphs, random graphs, and
synthetic networks.
It takes advantage of Python’s ability to import data from outer sources.
NetworkX includes many graph generator functions and facilities to read and write graphs in many
formats such as .edgelist, .adjlist, .gml, .graphml, .pajek, etc.
Why NetworkX

The library is implemented as dictionary of dictionaries with a node-centric view of network
based on nodes and connections between them.
Nodes can be any hashable object such as a text string, an image, an XML object, another Graph, a
customized node object, etc.
Python’s none object should not be used as a node as it determines whether optional function
arguments have been assigned in many functions.
Each graph, node, and edge can hold key/value attribute pairs (e.g. weights, labels, and colours) in an
associated attribute dictionary (the keys must be hashable).
Edges are represented as tuples with optional edge data and can hold arbitrary data (e.g. weights, time
series, etc.)
NetworkX: Data Structure

Several packages and tools are available in Python for network analysis and visualization:
networkX: http://networkx.lanl.gov/
PyCX Project: http://pycx.sf.net/
ComplexNetworkSim
SimPy
graph-tool [http://graph-tool.skewed.de/]
pyGraphViz (GraphViz) [http://www.graphviz.org/]
igraph [http://igraph.org/]
python-graph
gephi [http://gephi.org/]
NetworkX was not designed as a graph drawing package.
However, it provides basic drawing capabilities through matplotlib.
NetworkX provides an interface to that package.
For more complex visualization techniques, it is preferred to use the open source GraphViz software package
Python: Visualization Packages

scipy: a Matlab-like library for Python.
lots of features: linear algebra, Fourier transform,
www.scipy.org
numpy: www.numpy.org
matplotlib: www.matplotlib.org
NetworkX: Required Packages

>>> Import networkx as nx # import library
>>> G = nx.Graph() # create new simple undirected graphs
>>> EG = nx.empty_graph(100) # create an empty graph
>>> DG = nx.DiGraph # create a simple directed graphs
>>> MG = nx.MultiGraph() # create undirected with parallel edges
>>> MDG = nx.MultiDiGraph() # create directed with parallel edges
>>> CG = nx.complete_graph(10) # create a complete graph
>>> PG = nx.path_graph(5) # create a chain of nodes
>>> CBG = nx.complete_bipartite_graph(n1, n2) # create bipartite
>>> GG = nx.grid_graph([10, 10, 10, 10]) # arbitrary dimensional lattice
To get graph attributes
>>> G.graph
To convert to undirected
>>> G.to_undirected()
To convert to directed
>>> G.to_directed()
To clear a graph from nodes and edges
>>> G.clear()
Graph Types

To add one node at a time
>>> G.add_node(1)
To add a list of nodes
>>> G.add_nodes_from([2, 3, 4, 5]) # takes any iterable collection
To add nbunch of nodes
>>> H = nx.path_graph(10)
>>> G.add_nodes_from(H)
To add a graph as a node
>>> G.add_node(H)
To print the number of nodes
>>> G.number_of_nodes()
To print graph nodes
>>> G.nodes()
To print type of nodes
>>> type(G.nodes()) # it will show class list
To relabel nodes
>>> nx.relabel_nodes(G, mapping, copy = True) # mapping  new labels
To check node membership
>>> G.has_node(1)
Network Nodes

To add an edge
>>> G.add_edge(1, 2)
To add a list of edges
>>> G.add_edges_from([5, 6]) # automatically add nodes if not exist
To add edges from a list
>>> edge = (3, 4)
>>> G.add_edge(*edge)
To check edge membership
>>> G.has_edge(3, 4)
To print the number of edges
>>> G.number_of_edges()
To remove an edge
>>> G.remove_edge(1, 2)
To remove a list of edges
>>> G.remove_edges_from([(1, 2), (3, 4)])
To print graph edges
>>> G.edges()
General read format
>>> nx.read_format(“path/to/file.txt”,...options...)
To read edge list from file
>>> el = nx.read_edgelist(“test.edges”, comments = “#”)
To read adjacency list from file
>>> al = nx.read_adjlist(“test2.adj”)
General write format
>>> nx.write_format(g,“path/to/file.txt”,...options...)
To write edge list
>>> nx.write_edgelist(G, “newFile.edges”, comments = “#”, data = True)
To print type of edges
>>> type(G.edges()) # it will show class list
Network Edges

To create an empty directed graph
>>> DG = nx.DiGraph() # creates simple directed graphs
To add weighted edges to DG
>>> DG.add_weighted_edges_from([(7, 8, 2.7), (9, 10, 0.5)])
To calculate outdegree
>>> DG.out_degree()
To calculate outdegree with attributes included
>>> DG.out_degree(with_labels = True) # Boolean should be capitalized
To calculate successors
>>> DG.successors(1)
To calculate predecessors
>>> DG.predecessors(1)
To calculate neighbors
>>> DG.neighbors(1)
To convert directed graphs to undirected
>>> DG.to_undirected()
Directed Graphs

To add attributes
>>> G = nx.Graph(day = “Wednesday”)
To update attributes
>>> G.graph[“day”] = “Thursday”
To add attributes to nodes
>>> G.add_node(1, time = “5am”) # attributes are optional
>>> G.add_nodes_from([3], time = “2am”)
To get node attributes
>>> G.node[1]
To add attributes to edges
>>> G.add_edges_from([(11, 12), (13, 14)], color = “blue”)
To get edge attributes
>>> G[1][2]
To get a particular attribute value
>>> G[1][2][“color”]
Attributed Graphs

To add weighted edges to a graph
>>> G.add_edge(15, 16, weight = 3.3)
>>> G.add_edge(17, 18, weight = 4.3)
To calculate node degree without weight
>>> G.degree(1)
To calculate node degree with weight included
>>> G.degree(1, weight = “weight”)
To calculate all node degrees
>>> G.degree(weight = “weight”)
Weighted Graphs

To build a multigraph
>>> MG = nx.MultiGraph()
To add edges to MG
>>> MG.add_weighted_edges_from([1, 2, 0.75), (1, 2, 1,25), (2, 3, 0.75)])
To calculate degrees
>>> MG.degree(weight = “weight”)
Multigraphs

>>> nx.subgraph(G, nbunch) # induce subgraph of G on nodes in nbunch
>>> nx.union(G1, G2) # graph union
>>> nx.disjoint_union(G1, G2) # graph union/all node are different
>>> nx.cartesian_product(G1, G2) # return Cartesian product graph
>>> nx.compose(G1, G2) # combine graphs identifying common nodes
>>> nx.complement(G) # graph complement
>>> nx.create_empty_graph(G) # return an empty copy of the same graph class
>>> nx.convert_to_undirected(G) # return an undirected copy of G
>>> nx.convert_to_directed(G) # return a directed copy of G
Classic Graph Operations

Using a call to one of the classic small graphs
>>> petersen = nx.petersen_graph()
>>> tutte = nx.tutte_graph()
>>> maze = nx.sedgewick_maze_graph()
>>> tet = nx.tetrahedral_graph()
Using a (constructive) generator for a classic graph
>>> k_5 = nx.complete_graphs(10)
>>> k_3_5 = nx.complete_bipartite_graph(3, 5)
>>> barbell = nx.barbell_graph(15, 15)
>>> lollipop = nx.lollipop_graph(5, 10)
Using a stochastic graph generator
>>> er = nx.erdos_renyi_graph(50, 0.5)
>>> ws = nx.watts_strogatz_graph(20, 2, 0.5)
>>> ba = nx.barabasi_albert_graph(50, 5)
>>> red = nx.random_lobster(100, 0.9, 0.9)
Graph Generators

Algorithms Package (networkx.algorithms)
bipartite
block
boundary
centrality (package)
clique
cluster
components (package)
core
cycles
dag
distance measures
ow (package)
isolates
isomorphism (package)
link analysis (package)
matching
mixing
mst
operators
shortest paths (package)
smetric

Reading and Writing
Adjacency List
Multiline Adjacency List
Edge List
GEXF
GML
Pickle
GraphML
LEDA
YAML
SparseGraph6
Pajek
GIS Shapefile

To find connected components
>>> nx.connected_components(G)
To sort nodes based on node degree
>>> sorted(nx.degree(G).values())
To calculate degree of a specific node
>>> G.degree(1)
To calculate all degrees
>>> G.degree()
To see if network is connected
>>> nx.is_connected(G)
To calculate network global clustering coefficient
>>> nx.clustering(G)
To calculate the clustering coefficient of each node
>>> nx.clustering(G, with_labels = True)
To calculate coefficient for a particular node
>>> nx.clustering(G, 1)
To find the shortest path between two nodes
>>> nx.shortest_path(G, 1, 3)
To find the length of the shortest path between two nodes
>>> nx.shortest_path_length(G, 3, 1)
Basic Network Analysis (1)

To find in-degree distribution of G
>>> G.in_degree()
To find out-degree distribution of G
>>> G.out_degree()
To calculate number of nodes
>>> G.order()
>>> nx.number_of_nodes(G)
>>> len(G)
To calculate number of edges
>>> G.size()
>>> nx.number_of_edges(G)
To find network diameter
>>> nx.diameter(G)
To find network radius
>>> nx.radius(G)
To find cores in network
>>> nx.find_cores(G)
Basic Network Analysis (2)

To calculate degree centrality
>>> nx.degree_centrality(G)
To calculate betweenness centrality
>>> nx.betweenness_centrality(G)
To calculate closeness centrality
>>> nx.closeness_centrality(G)
To calculate eigenvector centrality
>>> nx.eigenvector_centrality(G)
Centrality measures

>>> import matplotlib.pyplot as plt # Can use GraphViz
To clear the previous graph
>>> plt.clf()
To draw a graph
>>> nx.draw(G)
>>> nx.draw_random(G)
>>> nx.draw_circular(G)
>>> nx.draw_spectral(G)
To show the graph
>>> plt.show() # to show the file
To save the graph
>>> plt.savefig(“myFig.png”) # save as .png file
To close the file
>>> plt.close()
To extract the main connected component from G
>>> nx.connected_component_subgraphs(G) # graph should be undirected
Drawing Graphs

Python networkx library quick start guide

More Related Content

What's hot (20)

Similar to Python networkx library quick start guide (20)

More from Universiti Technologi Malaysia (UTM) (11)

Recently uploaded (20)

Python networkx library quick start guide