igraph
The first step of most applications is to generate a graph. This section will explain a number of ways to do that. Read the api/index
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()
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
.
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 dictionariesGraph.TupleList
: from a list of tuplesGraph.ListDict
: from a dict of listsGraph.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:
Graph.to_dict_list
Graph.to_tuple_list
Graph.to_list_dict
Graph.to_dict_dict
See the api/index
of each function for details and examples.
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]])
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, will try to figure it out or, if that fails, it will complain.
can read from and write to networkx and graph-tool graph formats:
>>> g = Graph.from_networkx(nwx)
and
>>> g = Graph.from_graph_tool(gt)
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)
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.
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.
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.
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)
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.
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.
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
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