Operacions bàsiques de digrafs

Importem la biblioteca NetworkX.

>>> import networkx as nx

Creem un graf buit.

>>> g = nx.DiGraph()

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)

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)]

Les arestes són un conjunt: només hi apareixen un cop malgrat que les hi afegim més d’un cop.

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

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, 1)

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)] )
>>> g.size()
6

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

>>> import matplotlib.pyplot as plt
>>> nx.draw(g, with_labels=True)
>>> plt.show()
../_images/digrafs-1.svg

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 hem afegit i no les simètriques (llevat que les afegim).

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

Consultem el grau d’un node: total, d’entrada i de sortida.

>>> g.degree(2)
3
>>> g.in_degree(2)
2
>>> 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 conjunt.

for edge in g.edges:
    print(edge)

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

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.

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

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

Recorrem les arestes de les quals un node és cap, és a dir, les que parteixen del node.

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, és a dir, les que arriben al node.

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

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

Afegim un camí al graf.

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

Visualitzem el graf

>>> nx.draw(g, with_labels=True)
>>> plt.show()
../_images/digrafs-2.svg