igraph.io.objects

Generates a graph from one or two dataframes.

Constructs a graph from a dict-of-dicts representation.

Each key can be an integer or a string and represent a vertex. Each value is a dict representing edges (outgoing if the graph is directed) from that vertex. Each dict key is an integer/string for a target vertex, such that an edge will be created between those two vertices. Integers are interpreted as vertex_ids from 0 (as used in igraph), strings are interpreted as vertex names, in which case vertices are given separate numeric ids. Each value is a dictionary of edge attributes for that edge.

Example:

>>> {'Alice': {'Bob': {'weight': 1.5}, 'David': {'weight': 2}}}

creates a graph with three vertices (Alice, Bob, and David) and two edges:

• Alice - Bob (with weight 1.5)
• Alice - David (with weight 2)

Constructs a graph from a list-of-dictionaries representation.

This function is useful when you have two lists of dictionaries, one for vertices and one for edges, each containing their attributes (e.g. name, weight). Of course, the edge dictionary must also contain two special keys that indicate the source and target vertices connected by that edge. Non-list iterables should work as long as they yield dictionaries or dict-like objects (they should have the 'items' and '__getitem__' methods). For instance, a database query result is likely to be fit as long as it's iterable and yields dict-like objects with every iteration.

>>> vertices = [{'name': 'apple'}, {'name': 'pear'}, {'name': 'peach'}]
>>> edges = [{'source': 'apple', 'target': 'pear', 'weight': 1.2},
...          {'source': 'apple', 'target': 'peach', 'weight': 0.9}]
>>> g = Graph.DictList(vertices, edges)

Constructs a graph from a dict-of-lists representation.

This function is used to construct a graph from a dictionary of lists. Other, non-list sequences (e.g. tuples) and lazy iterators are are accepted. For each key x, its corresponding value must be a sequence of multiple values y: the edge (x,y) will be created in the graph. x and y must be either one of:

• two integers: the vertices with those ids will be connected
• two strings: the vertices with those names will be connected

If names are used, the order of vertices is not guaranteed, and each vertex will be given the vertex_name_attr attribute.

>>> mydict = {'apple': ['pear', 'peach'], 'pear': ['peach']}
>>> g = Graph.ListDict(mydict)

Constructs a graph from a list-of-tuples representation.

This representation assumes that the edges of the graph are encoded in a list of tuples (or lists). Each item in the list must have at least two elements, which specify the source and the target vertices of the edge. The remaining elements (if any) specify the edge attributes of that edge, where the names of the edge attributes originate from the edge_attrs list. The names of the vertices will be stored in the vertex attribute given by vertex_name_attr.

The default parameters of this function are suitable for creating unweighted graphs from lists where each item contains the source vertex and the target vertex. If you have a weighted graph, you can use items where the third item contains the weight of the edge by setting edge_attrs to "weight" or ["weight"]. If you have even more edge attributes, add them to the end of each item in the edges list and also specify the corresponding edge attribute names in edge_attrs as a list.

Export edges with attributes to pandas.DataFrame

If you want to use source and target vertex IDs as index, you can do:

>>> from string import ascii_letters
>>> graph = Graph.GRG(25, 0.4)
>>> graph.vs["name"] = ascii_letters[:graph.vcount()]
>>> df = graph.get_edge_dataframe()
>>> df.set_index(['source', 'target'], inplace=True)

The index will be a pandas.MultiIndex. You can use the drop=False option to keep the source and target columns.

If you want to use vertex names in the source and target columns:

>>> df = graph.get_edge_dataframe()
>>> df_vert = graph.get_vertex_dataframe()
>>> df['source'].replace(df_vert['name'], inplace=True)
>>> df['target'].replace(df_vert['name'], inplace=True)
>>> df_vert.set_index('name', inplace=True)  # Optional

Export graph to dictionary of dicts of edge attributes

This function is the reverse of Graph.DictDict.

Example:

>>> g = Graph.Full(3)
>>> g.es['name'] = ['first_edge', 'second', 'third']
>>> g.to_dict_dict()
{0: {1: {'name': 'first_edge'}, 2: {'name': 'second'}}, 1: {2: {'name': 'third'}}}

Export graph as two lists of dictionaries, for vertices and edges.

This function is the reverse of Graph.DictList.

Example:

>>> g = Graph([(0, 1), (1, 2)])
>>> g.vs["name"] = ["apple", "pear", "peach"]
>>> g.es["name"] = ["first_edge", "second"]

>>> g.to_dict_list()
([{"name": "apple"}, {"name": "pear"}, {"name": "peach"}],
 [{"source": 0, "target": 1, "name": "first_edge"},
  {"source" 0, "target": 2, name": "second"}])

>>> g.to_dict_list(use_vids=False)
([{"name": "apple"}, {"name": "pear"}, {"name": "peach"}],
 [{"source": "apple", "target": "pear", "name": "first_edge"},
  {"source" "apple", "target": "peach", name": "second"}])

Export graph to a dictionary of lists (or other sequences).

This function is the reverse of Graph.ListDict.

Example:

>>> g = Graph.Full(3)
>>> g.to_sequence_dict() -> {0: [1, 2], 1: [2]}
>>> g.to_sequence_dict(sequence_constructor=tuple) -> {0: (1, 2), 1: (2,)}
>>> g.vs['name'] = ['apple', 'pear', 'peach']
>>> g.to_sequence_dict(use_vids=False)
{'apple': ['pear', 'peach'], 'pear': ['peach']}

Export graph to a list of edge tuples

This function is the reverse of Graph.TupleList.

Example:

>>> g = Graph.Full(3)
>>> g.vs["name"] = ["apple", "pear", "peach"]
>>> g.es["name"] = ["first_edge", "second", "third"]

>>> # Get name of the edge
>>> g.to_tuple_list(edge_attrs=["name"])
[(0, 1, "first_edge"), (0, 2, "second"), (1, 2, "third")]

>>> # Use vertex names, no edge attributes
>>> g.to_tuple_list(use_vids=False)
[("apple", "pear"), ("apple", "peach"), ("pear", "peach")]

Export vertices with attributes to pandas.DataFrame

If you want to use vertex names as index, you can do:

>>> from string import ascii_letters
>>> graph = Graph.GRG(25, 0.4)
>>> graph.vs["name"] = ascii_letters[:graph.vcount()]
>>> df = graph.get_vertex_dataframe()
>>> df.set_index('name', inplace=True)