Graph generation
The first step of most igraph applications is to generate a graph. This section will explain a number of ways to do that. Read the API reference for details on each function and class.
The Graph
class is the main object used to generate graphs:
>>> from igraph import Graph
To copy a graph, use Graph.copy()
:
>>> g_new = g.copy()
From nodes and edges
Nodes are always numbered from 0 upwards. To create a generic graph with a specified number of nodes (e.g. 10) and a list of edges between them, you can use the generic constructor:
>>> g = Graph(n=10, edges=[[0, 1], [2, 3]])
If not specified, the graph is undirected. To make a directed graph:
>>> g = Graph(n=10, edges=[[0, 1], [2, 3]], directed=True)
To specify edge weights (or any other vertex/edge attributes), use dictionaries:
>>> g = Graph(
... n=4, edges=[[0, 1], [2, 3]],
... edge_attrs={'weight': [0.1, 0.2]},
... vertex_attrs={'color': ['b', 'g', 'g', 'y']}
... )
To create a bipartite graph from a list of types and a list of edges, use Graph.Bipartite()
.
From Python builtin structures (lists, tuples, dicts)
igraph supports a number of “conversion” methods to import graphs from Python builtin data structures such as dictionaries, lists and tuples:
Graph.DictList()
: from a list of dictionaries
Graph.TupleList()
: from a list of tuples
Graph.ListDict()
: from a dict of lists
Graph.DictDict()
: from a dict of dictionaries
Equivalent methods are available to export a graph, i.e. to convert a graph into a representation that uses Python builtin data structures:
See the API reference of each function for details and examples.
From matrices
To create a graph from an adjacency matrix, use Graph.Adjacency()
or, for weighted matrices, Graph.Weighted_Adjacency()
:
>>> g = Graph.Adjacency([[0, 1, 1], [0, 0, 0], [0, 0, 1]])
This graph is directed and has edges [0, 1], [0, 2] and [2, 2] (a self-loop).
To create a bipartite graph from a bipartite adjacency matrix, use Graph.Biadjacency()
:
>>> g = Graph.Biadjacency([[0, 1, 1], [1, 1, 0]])
From files
To load a graph from a file in any of the supported formats, use Graph.Load()
. For instance:
>>> g = Graph.Load('myfile.gml', format='gml')
If you don’t specify a format, igraph will try to figure it out or, if that fails, it will complain.
From external libraries
igraph can read from and write to networkx and graph-tool graph formats:
>>> g = Graph.from_networkx(nwx)
and
>>> g = Graph.from_graph_tool(gt)
From pandas DataFrame(s)
A common practice is to store edges in a pandas.DataFrame, where the two first columns are the source and target vertex ids,
and any additional column indicates edge attributes. You can generate a graph via Graph.DataFrame()
:
>>> g = Graph.DataFrame(edges, directed=False)
It is possible to set vertex attributes at the same time via a separate DataFrame. The first column is assumed to contain all vertex ids (including any vertices without edges) and any additional columns are vertex attributes:
>>> g = Graph.DataFrame(edges, directed=False, vertices=vertices)
From a formula
To create a graph from a string formula, use Graph.Formula()
, e.g.:
>>> g = Graph.Formula('D-A:B:F:G, A-C-F-A, B-E-G-B, A-B, F-G, H-F:G, H-I-J')
Note
This particular formula also assigns the ‘name’ attribute to vertices.
Complete graphs
To create a complete graph, use Graph.Full()
:
>>> g = Graph.Full(n=3)
where n is the number of nodes. You can specify directedness and whether self-loops are included:
>>> g = Graph.Full(n=3, directed=True, loops=True)
A similar method, Graph.Full_Bipartite()
, generates a complete bipartite graph. Finally, the metho Graph.Full_Citation()
created the full citation graph, in which a vertex with index i has a directed edge to all vertices with index strictly smaller than i.
Tree and star
Graph.Tree()
can be used to generate regular trees, in which almost each vertex has the same number of children:
>>> g = Graph.Tree(n=7, n_children=2)
creates a tree with seven vertices - of which four are leaves. The root (0) has two children (1 and 2), each of which has two children (the four leaves). Regular trees can be directed or undirected (default).
The method Graph.Star()
creates a star graph, which is a subtype of a tree.
Lattice
Graph.Lattice()
creates a regular square lattice of the chosen size. For instance:
>>> g = Graph.Lattice(dim=[3, 3], circular=False)
creates a 3×3 grid in two dimensions (9 vertices total). circular is used to connect each edge of the lattice back onto the other side, a process also known as “periodic boundary condition” that is sometimes helpful to smoothen out edge effects.
The one dimensional case (path graph or cycle graph) is important enough to deserve its own constructor Graph.Ring()
, which can be circular or not:
>>> g = Graph.Ring(n=4, circular=False)
Graph Atlas
The book ‘An Atlas of Graphs’ by Roland C. Read and Robin J. Wilson contains all unlabeled undirected graphs with up to seven vertices, numbered from 0 up to 1252. You can create any graph from this list by index with Graph.Atlas()
, e.g.:
>>> g = Graph.Atlas(44)
The graphs are listed:
in increasing order of number of nodes;
for a fixed number of nodes, in increasing order of the number of edges;
for fixed numbers of nodes and edges, in increasing order of the degree sequence, for example 111223 < 112222;
for fixed degree sequence, in increasing number of automorphisms.
Famous graphs
A curated list of famous graphs, which are often used in the literature for benchmarking and other purposes, is available on the igraph C core manual. You can generate any graph in that list by name, e.g.:
>>> g = Graph.Famous('Zachary')
will teach you some about martial arts.
Random graphs
Stochastic graphs can be created according to several different models or games:
Barabási-Albert model:
Graph.Barabasi()
Erdős-Rényi:
Graph.Erdos_Renyi()
Watts-Strogatz
Graph.Watts_Strogatz()
stochastic block model
Graph.SBM()
random tree
Graph.Tree_Game()
forest fire game
Graph.Forest_Fire()
random geometric graph
Graph.GRG()
growing
Graph.Growing_Random()
establishment game
Graph.Establishment()
preference, the non-growing variant of establishment
Graph.Preference()
asymmetric preference
Graph.Asymmetric_Prefernce()
recent degree
Graph.Recent_Degree()
k-regular (each node has degree k)
Graph.K_Regular()
non-growing graph with edge probabilities proportional to node fitnesses
Graph.Static_Fitness()
non-growing graph with prescribed power-law degree distribution(s)
Graph.Static_Power_Law()
random graph with a given degree sequence
Graph.Degree_Sequence()
bipartite
Graph.Random_Bipartite()
Other graphs
Finally, there are some ways of generating graphs that are not covered by the previous sections:
Kautz graphs
Graph.Kautz()
De Bruijn graphs
Graph.De_Bruijn()
graphs from LCF notation
Graph.LCF()
small graphs of any “isomorphism class”
Graph.Isoclass()
graphs with a specified degree sequence
Graph.Realize_Degree_Sequence()