library - cómo dibujar gráficos dirigidos usando networkx en python?

python graph library

Question

Tengo algunos nodos provenientes de un script que quiero asignar a un gráfico. En el siguiente, quiero usar Arrow para ir de A a D y probablemente también tenga el borde coloreado (rojo o algo así). Esto es básicamente, como un camino de A a D cuando todos los otros nodos están presentes. Puedes imaginar cada nodo como ciudades y viajar de A a D requiere instrucciones (con puntas de flecha). Este código a continuación construye el gráfico

import networkx as nx
import numpy as np
import matplotlib.pyplot as plt
G = nx.Graph()
G.add_edges_from(
[(''A'', ''B''), (''A'', ''C''), (''D'', ''B''), (''E'', ''C''), (''E'', ''F''),
(''B'', ''H''), (''B'', ''G''), (''B'', ''F''), (''C'', ''G'')])
val_map = {''A'': 1.0,
''D'': 0.5714285714285714,
''H'': 0.0}
values = [val_map.get(node, 0.25) for node in G.nodes()]
nx.draw(G, cmap = plt.get_cmap(''jet''), node_color = values)
plt.show()

pero quiero algo como se muestra en la imagen.

Puntas de flecha de la primera imagen y los bordes en rojo sobre la segunda imagen .. Gracias

Answer 1

Ejemplo completamente desarrollado con flechas solo para los bordes rojos:

import networkx as nx
import matplotlib.pyplot as plt
G = nx.DiGraph()
G.add_edges_from(
[(''A'', ''B''), (''A'', ''C''), (''D'', ''B''), (''E'', ''C''), (''E'', ''F''),
(''B'', ''H''), (''B'', ''G''), (''B'', ''F''), (''C'', ''G'')])
val_map = {''A'': 1.0,
''D'': 0.5714285714285714,
''H'': 0.0}
values = [val_map.get(node, 0.25) for node in G.nodes()]
# Specify the edges you want here
red_edges = [(''A'', ''C''), (''E'', ''C'')]
edge_colours = [''black'' if not edge in red_edges else ''red''
for edge in G.edges()]
black_edges = [edge for edge in G.edges() if edge not in red_edges]
# Need to create a layout when doing
# separate calls to draw nodes and edges
pos = nx.spring_layout(G)
nx.draw_networkx_nodes(G, pos, cmap=plt.get_cmap(''jet''),
node_color = values, node_size = 500)
nx.draw_networkx_labels(G, pos)
nx.draw_networkx_edges(G, pos, edgelist=red_edges, edge_color=''r'', arrows=True)
nx.draw_networkx_edges(G, pos, edgelist=black_edges, arrows=False)
plt.show()

Answer 2

En lugar de nx.draw regular, puede usar:

nx.draw_networkx(G[, pos, arrows, with_labels])

Por ejemplo:

nx.draw_networkx(G, arrows=True, **options)

Puede agregar opciones inicializando esa ** variable como esta:

options = {
''node_color'': ''blue'',
''node_size'': 100,
''width'': 3,
''arrowstyle'': ''-|>'',
''arrowsize'': 12,
}

También algunas funciones admiten el directed=True parameter En este caso, este estado es el predeterminado:

G = nx.DiGraph(directed=True)

La referencia de networkx se encuentra here .

Answer 3

Necesita usar un gráfico dirigido en lugar de un gráfico, es decir,

G = nx.DiGraph()

Luego, cree una lista de los colores de los bordes que desea usar y nx.draw a nx.draw (como se muestra en @Marius).

Al juntar todo esto, obtengo la imagen a continuación. Todavía no es exactamente la otra imagen que muestra (no sé de dónde vienen sus pesos de borde), ¡pero mucho más cerca! Si quieres tener más control de cómo se ve tu gráfico de salida (por ejemplo, obtener puntas de flecha que parecen flechas), verificaría NetworkX con Graphviz .

Answer 4

Solo puse esto por completo. Aprendí mucho de marius y mdml. Aquí están los pesos de borde. Perdón por las flechas. Parece que no soy el único que dice que no se puede evitar. No pude renderizar esto con el cuaderno ipython. Tuve que ir directamente desde Python, que era el problema para poner mis pesos de ventaja antes.

import networkx as nx
import numpy as np
import matplotlib.pyplot as plt
import pylab
G = nx.DiGraph()
G.add_edges_from([(''A'', ''B''),(''C'',''D''),(''G'',''D'')], weight=1)
G.add_edges_from([(''D'',''A''),(''D'',''E''),(''B'',''D''),(''D'',''E'')], weight=2)
G.add_edges_from([(''B'',''C''),(''E'',''F'')], weight=3)
G.add_edges_from([(''C'',''F'')], weight=4)
val_map = {''A'': 1.0,
''D'': 0.5714285714285714,
''H'': 0.0}
values = [val_map.get(node, 0.45) for node in G.nodes()]
edge_labels=dict([((u,v,),d[''weight''])
for u,v,d in G.edges(data=True)])
red_edges = [(''C'',''D''),(''D'',''A'')]
edge_colors = [''black'' if not edge in red_edges else ''red'' for edge in G.edges()]
pos=nx.spring_layout(G)
nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels)
nx.draw(G,pos, node_color = values, node_size=1500,edge_color=edge_colors,edge_cmap=plt.cm.Reds)
pylab.show()

Answer 5

import networkx as nx
import matplotlib.pyplot as plt
g = nx.DiGraph()
g.add_nodes_from([1,2,3,4,5])
g.add_edge(1,2)
g.add_edge(4,2)
g.add_edge(3,5)
g.add_edge(2,3)
g.add_edge(5,4)
nx.draw(g,with_labels=True)
plt.draw()
plt.show()

Esto es simplemente simple como dibujar un gráfico dirigido usando python 3.x usando networkx. simplemente representación simple y puede ser modificado y coloreado, etc. Vea el gráfico generado here .

Nota: es solo una representación simple. Los bordes ponderados podrían agregarse como

g.add_edges_from([(1,2),(2,5)], weight=2)

y por lo tanto tramados de nuevo.