Operacions bàsiques de multidigrafs

Importem la biblioteca networkx.

>>> import networkx as nx

Creem un multigraf buit.

>>> g = nx.MultiDiGraph()

Consultem els nodes.

>>> list(g.nodes)
[]

Quants nodes té?

>>> len(g)
0
>>> g.order()
0
>>> g.number_of_nodes()
0

Consultem les arestes.

>>> list(g.edges)
[]

Quantes arestes té?

>>> g.size()
0
>>> g.number_of_edges()
0

Hi afegim un node.

>>> g.add_node(10)
>>> sorted(g.nodes)
[10]
>>> g.order(), g.size()
(1, 0)

Els nodes són un conjunt: només hi apareixen un cop malgrat que els hi afegim més d’un cop.

>>> g.add_node(10)
>>> sorted(g.nodes)
[10]

Hi afegim una aresta.

>>> g.add_edge(1, 2)
0

Consultem tots els nodes.

>>> sorted(g.nodes)
[1, 2, 10]

Si algun dels nodes incidents a una aresta encara no pertany al graf, s’hi afegeix.

Consultem totes les arestes.

>>> sorted(g.edges)
[(1, 2, 0)]

Les arestes són un multiconjunt: hi poden aparèixer repetides

>>> g.add_edge(1, 2)
1
>>> sorted(g.edges)
[(1, 2, 0), (1, 2, 1)]

Hi afegim uns quants nodes més a partir d’un iterable.

>>> g.add_nodes_from( [3, 4, 5, 11] )
>>> sorted(g.nodes)
[1, 2, 3, 4, 5, 10, 11]
>>> g.order(), g.size()
(7, 2)

Hi afegim unes quantes arestes més a partir d’un iterable.

>>> g.add_edges_from( [(2,3), (3,4), (4,5), (5,2), (11,10)] )
[0, 0, 0, 0, 0]
>>> g.size()
7

Visualitzem el graf utilitzant el mòdul matplotlib.pyplot.

>>> import matplotlib.pyplot as plt

>>> pos = nx.nx_agraph.graphviz_layout(g)
>>> eti = {(u, v, k): str(k) for u, v, k in g.edges}
>>> est = ('arc3', 'arc3,rad=0.3', 'arc3,rad=-0.3')
>>> nx.draw_networkx(g, pos, connectionstyle=est)
>>> r = nx.draw_networkx_edge_labels(g, pos, edge_labels=eti, connectionstyle=est)
>>> plt.show()

Consultem si el graf conté un node.

>>> 1 in g
True
>>> 8 in g
False
>>> g.has_node(10)
True

Consultem si el graf conté una aresta.

>>> g.has_edge(1, 2)
True

El graf és dirigit: només conté les arestes que hi hem afegit.

>>> g.has_edge(2, 1)
False
>>> g.has_edge(3, 5)
False

Consuletm el grau d’un node. L’aresta (1, 2) hi és dos cops

>>> g.degree(2)
4
>>> g.in_degree(2)
3
>>> g.out_degree(2)
1

Recorrem els nodes del graf.

El graf és iterable, però desconeixem en quin ordre es recorreran els nodes perquè són un conjunt.

for node in g:
    print(node)

>>> sorted(g)
[1, 2, 3, 4, 5, 10, 11]

També els podem recórrer mitjançant la vista nodes.

for node in g.nodes:
    print(node)

>>> sorted(g.nodes)
[1, 2, 3, 4, 5, 10, 11]

Recorrem les arestes del graf mitjançant la vista edges. Desconeixem en quin ordre es recorreran perquè són un multiconjunt.

for edge in g.edges:
    print(edge)

>>> sorted(g.edges)
[(1, 2, 0), (1, 2, 1), (2, 3, 0), (3, 4, 0), (4, 5, 0), (5, 2, 0), (11, 10, 0)]

Recorrem els successors d’un node.

for node in g.neighbors(2):
    print(node)

>>> sorted(g.neighbors(2))
[3]

for node in g[2]:
    print(node)

>>> sorted(g[2])
[3]

for node in g.successors(2):
    print(node)

>>> sorted(g.successors(2))
[3]

Recorrem els predecessors d’un node (el node 2)

for node in g.predecessors(2):
    print(node)

>>> sorted(g.predecessors(2))
[1, 5]

Recorrem les arestes de les quals un node és cap (el node 2)

for node in g.edges(2):
    print(node)

>>> sorted(g.edges(2))
[(2, 3)]

for node in g.out_edges(2):
    print(node)

>>> sorted(g.out_edges(2))
[(2, 3)]

Recorrem les arestes de les quals un node és cua (el node 2)

for node in g.in_edges(2):
    print(node)

>>> sorted(g.in_edges(2))
[(1, 2), (1, 2), (5, 2)]

Afegim un camí al graf.

>>> nx.add_path(g, [1,2,3,5])

Visualitzem el graf

>>> eti = {(u, v, k): str(k) for u, v, k in g.edges}
>>> nx.draw_networkx(g, pos, connectionstyle=est)
>>> r = nx.draw_networkx_edge_labels(g, pos, edge_labels=eti, connectionstyle=est)
>>> plt.show()

Com es distingeixen les arestes repetides? Les arestes d’un multigraf tenen associada una clau (key).

>>> sorted(g[1])
[2]
>>> sorted(g[1][2])
[0, 1, 2]
>>> sorted(g.edges(1, keys=True))
[(1, 2, 0), (1, 2, 1), (1, 2, 2)]