Equivalente in Python di D3.js

Qualcuno può consigliare una libreria Python in grado di visualizzare grafici interattivi ?

Voglio specificamente qualcosa come d3.js ma per pythone idealmente sarebbe anche 3D.

Ho guardato:

• NetworkX - fa solo Matplotlibgrafici e quelli sembrano essere 2D. Non ho visto alcun tipo di interattività, come quella che d3.jsdà, come tirare i nodi in giro.
• graph-tool : esegue solo grafici 2D e ha grafici interattivi molto lenti .

Potresti usare d3py un modulo python che genera pagine xml incorporando lo script d3.js. Per esempio :

import d3py
import networkx as nx

import logging
logging.basicConfig(level=logging.DEBUG)

G = nx.Graph()
G.add_edge(1,2)
G.add_edge(1,3)
G.add_edge(3,2)
G.add_edge(3,4)
G.add_edge(4,2)

# use 'with' if you are writing a script and want to serve this up forever
with d3py.NetworkXFigure(G, width=500, height=500) as p:
    p += d3py.ForceLayout()
    p.show()

Plotly supporta la rappresentazione grafica 2D e 3D interattiva. I grafici sono renderizzati con D3.js e possono essere creati con un'API Python , matplotlib , ggplot per Python , Seaborn , prettyplotlib e panda . Puoi eseguire lo zoom, la panoramica, attivare e disattivare le tracce e visualizzare i dati al passaggio del mouse. I grafici possono essere incorporati in HTML, app, dashboard e notebook IPython. Di seguito è riportato un grafico della temperatura che mostra l'interattività. Vedi la galleria di tutorial di IPython Notebooks per ulteriori esempi.

La documentazione fornisce esempi di tipi di trama supportati e frammenti di codice.

In particolare per la tua domanda, puoi anche creare trame interattive da NetworkX.



Per la stampa 3D con Python, puoi creare grafici a dispersione 3D, linee e superfici che sono similmente interattivi. I grafici vengono renderizzati con WebGL. Ad esempio, guarda un grafico 3D dei tassi di swap nel Regno Unito.

Divulgazione: faccio parte del team di Plotly.

Hai guardato Vincent? Vincent prende gli oggetti dati Python e li converte nella grammatica di visualizzazione Vega. Vega è uno strumento di visualizzazione di livello superiore costruito su D3. Rispetto a D3py, il repository vincent è stato aggiornato più di recente. Sebbene gli esempi siano tutti statici D3.

Ulteriori informazioni:

• https://github.com/wrobstory/vincent

• https://pypi.python.org/pypi/vincent/0.1.6

I grafici possono essere visualizzati in Ipython, basta aggiungere questo codice

vincent.core.initialize_notebook()

Oppure output in JSON dove puoi visualizzare il grafico dell'output JSON nell'editor online di Vega ( http://trifacta.github.io/vega/editor/ ) o visualizzarli sul tuo server Python localmente. Maggiori informazioni sulla visualizzazione possono essere trovate nel collegamento pypi sopra.

Non sono sicuro di quando, ma il pacchetto Pandas dovrebbe avere l'integrazione D3 ad un certo punto. http://pandas.pydata.org/developers.html

Bokeh è una libreria di visualizzazione Python che supporta la visualizzazione interattiva. Il suo backend di output principale è HTML5 Canvas e utilizza il modello client / server.

esempi: http://continuumio.github.io/bokehjs/

Una ricetta che ho usato (descritta qui: Co-Director Network Data Files in GEXF e JSON da OpenCorporates Data tramite Scraperwiki e networkx ) funziona come segue:

• generare una rappresentazione di rete utilizzando networkx
• esportare la rete come file JSON
• importare che JSON in a d3.js . ( networkx può esportare sia l'albero che le rappresentazioni grafico / rete che d3.js può importare).

L' esportatore JSON di networkx assume la forma:

from networkx.readwrite import json_graph
import json
print json.dumps(json_graph.node_link_data(G))

In alternativa è possibile esportare la rete come file XML GEXF e quindi importare questa rappresentazione nella libreria di visualizzazione Javascript sigma.js .

from xml.etree.cElementTree import tostring
writer=gf.GEXFWriter(encoding='utf-8',prettyprint=True,version='1.1draft')
writer.add_graph(G)
print tostring(writer.xml)

Un'altra opzione è il bokeh che è appena passato alla versione 0.3.

Per coloro che hanno consigliato pyd3 , non è più in fase di sviluppo attivo e ti indica Vincent . Vincent inoltre non è più in fase di sviluppo attivo e consiglia di utilizzare l' altair .

Quindi, se vuoi un d3 pitonico, usa l'altair.

Prova https://altair-viz.github.io/ , il successore di d3py e vincent. Guarda anche

• https://altair-viz.github.io/gallery/index.html
• https://speakerdeck.com/jakevdp/bespoke-visualizations-with-a-declarative-twist

Dai un'occhiata a python-nvd3 . È un wrapper Python per nvd3. Sembra più interessante di d3.py e ha anche più opzioni per i grafici.

Suggerirei di utilizzare mpld3 che combina visualizzazioni javascript D3js con matplotlib di python.

L'installazione e l'utilizzo è davvero semplice e ha alcuni plugin interessanti e materiali interattivi.

http://mpld3.github.io/

Plotly può fare cose interessanti per te

https://plot.ly/

Produce grafici altamente interattivi che possono essere facilmente incorporati nelle pagine HTML per il tuo server privato o sito web utilizzando la sua API offline.

Aggiornamento: sono sicuro delle sue capacità di tracciamento 3D, per i grafici 2D è fantastico Grazie

Puoi anche scegliere di serializzare i tuoi dati e quindi visualizzarli in D3.js, come fatto qui: Usa Python e Panda per creare un diagramma di rete D3 Force Directed (viene fornito anche con un taccuino jupyter !)

Ecco il succo. Serializzi i dati del grafico in questo formato:

import json
json_data = {
  "nodes":[
    {"name":"Myriel","group":1},
    {"name":"Napoleon","group":1},
    {"name":"Mlle.Baptistine","group":1},
    {"name":"Mme.Magloire","group":1},
    {"name":"CountessdeLo","group":1},
  ],
  "links":[
    {"source":1,"target":0,"value":1},
    {"source":2,"target":0,"value":8},
    {"source":3,"target":0,"value":10},
    {"source":3,"target":2,"value":6},
    {"source":4,"target":0,"value":1},
    {"source":5,"target":0,"value":1},
  ]
}
filename_out = 'graph_data.json'
json_out = open(filename_out,'w')
json_out.write(json_data)
json_out.close()

Quindi carichi i dati con d3.js:

d3.json("pcap_export.json", drawGraph);

Per la routine drawGraphvi rimando comunque al link.

C'è un interessante port da NetworkX a Javascript che potrebbe fare quello che vuoi. Vedi http://felix-kling.de/JSNetworkX/

Vedere:

Esiste una buona libreria di grafici 3D interattivi?

La risposta accettata suggerisce il seguente programma, che a quanto pare ha collegamenti Python: http://ubietylab.net/ubigraph/

modificare

Non sono sicuro dell'interattività di NetworkX, ma puoi sicuramente creare grafici 3D. C'è almeno un esempio nella galleria:

http://networkx.lanl.gov/examples/drawing/edge_colormap.html

E un altro esempio negli "esempi". Questo, tuttavia, richiede che tu abbia Mayavi.

http://networkx.lanl.gov/examples/3d_drawing/mayavi2_spring.html

Ho un buon esempio di generazione automatica di diagrammi di rete D3.js utilizzando Python qui: http://brandonrose.org/ner2sna

La cosa interessante è che ti ritroverai con HTML e JS generati automaticamente e puoi incorporare il grafico D3 interattivo in un taccuino con un IFrame

La libreria d3graphcostruirà un grafo d3 diretto dalla forza dall'interno di python. Puoi "interrompere" la rete in base al peso del bordo e passare il mouse sui nodi per ulteriori informazioni. Fare doppio clic su un nodo si concentrerà sul nodo e sui suoi bordi collegati.

pip install d3graph

Esempio:

source = ['node A','node F','node B','node B','node B','node A','node C','node Z']
target = ['node F','node B','node J','node F','node F','node M','node M','node A']
weight = [5.56, 0.5, 0.64, 0.23, 0.9,3.28,0.5,0.45]

# Import library
from d3graph import d3graph, vec2adjmat

# Convert to adjacency matrix
adjmat = vec2adjmat(source, target, weight=weight)
print(adjmat)
# target  node A  node B  node F  node J  node M  node C  node Z
# source                                                        
# node A    0.00     0.0    5.56    0.00    3.28     0.0     0.0
# node B    0.00     0.0    1.13    0.64    0.00     0.0     0.0
# node F    0.00     0.5    0.00    0.00    0.00     0.0     0.0
# node J    0.00     0.0    0.00    0.00    0.00     0.0     0.0
# node M    0.00     0.0    0.00    0.00    0.00     0.0     0.0
# node C    0.00     0.0    0.00    0.00    0.50     0.0     0.0
# node Z    0.45     0.0    0.00    0.00    0.00     0.0     0.0

# Example A: simple interactive network
out = d3graph(adjmat)

# Example B: Color nodes
out = d3graph(adjmat, node_color=adjmat.columns.values)

# Example C: include node size
node_size = [10,20,10,10,15,10,5]
out = d3graph(adjmat, node_color=adjmat.columns.values, node_size=node_size)

# Example D: include node-edge-size
out = d3graph(adjmat, node_color=adjmat.columns.values, node_size=node_size, node_size_edge=node_size[::-1], cmap='Set2')

# Example E: include node-edge color
out = d3graph(adjmat, node_color=adjmat.columns.values, node_size=node_size, node_size_edge=node_size[::-1], node_color_edge='#00FFFF')

# Example F: Change colormap
out = d3graph(adjmat, node_color=adjmat.columns.values, node_size=node_size, node_size_edge=node_size[::-1], node_color_edge='#00FFFF', cmap='Set2')

# Example H: Include directed links. Arrows are set from source -> target
out = d3graph(adjmat, node_color=adjmat.columns.values, node_size=node_size, node_size_edge=node_size[::-1], node_color_edge='#00FFFF', cmap='Set2', directed=True)

Un esempio interattivo dal caso titanico può essere trovato qui: https://erdogant.github.io/docs/d3graph/titanic_example/index.html https://erdogant.github.io/hnet/pages/html/Use%20Cases .html