Diferències entre multigrafs i multidigrafs

• Comparació línia a línia dels exemples sobre multigrafs (a l’esquerra) i multidigrafs (a la dreta).

• Les línies destacades són les úniques que canvien.

• Els canvis es concentren en el tractament de les arestes (has_edge(), edges()) i en la distició entre els veïns predecessors i successors (predecessors(), successors(), in_edges(), out_edges(), in_degree(), out_degree()).

>>> import networkx as nx					>>> import networkx as nx

>>> g = nx.MultiGraph()					       	>>> g = nx.MultiDiGraph()

>>> list(g.nodes)						>>> list(g.nodes)
[]								[]

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

>>> list(g.edges)						>>> list(g.edges)
[]								[]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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