Python equivalente a D3.js

110

Alguém pode recomendar uma biblioteca Python que pode fazer visualização gráfica interativa ?

Eu quero especificamente algo como d3.js, mas para pythone idealmente seria 3D também.

Eu olhei para:

  • NetworkX - ele só faz Matplotlibplotagens e parecem ser 2D. Não vi nenhum tipo de interatividade, como aquela que d3.jsdá, como puxar nós ao redor.
  • ferramenta de gráfico - faz apenas plotagens 2D e tem gráficos interativos muito lentos .
Eiyrioü von Kauyf
fonte
1
Você gostaria de gerar um gráfico em networkx e, em seguida, manipular em d3.js, se estiver procurando por uma versão baseada em navegador.
kreativitea
@kreativitea ok .... como eu faria isso oo idealmente: Graph Data (via API Calls em Python) -> Python (Machine Learning Stuffs) -> Django / Something + D3.js (visualização) -> Imagens bonitas e website :)
Eiyrioü von Kauyf
Acho que você pode implementar vega lite em python. Verifique isso e plotmente, é claro.
Noel Harris

Respostas:

74

Você pode usar d3py um módulo python que gera páginas xml incorporando o script d3.js. Por exemplo :

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()
Vincent Agnus
fonte
Funcionou para mim, mas tive que editar uma das linhas para with d3py.NetworkXFigure(G, width=500, height=500, host="localhost") as p:. Eu verifiquei o commit mais recente do d3py no github (SHA: 4e92a90f4003370bc086e0f57b19fca1bd4e8fba)
xb.
7
Infelizmente, o d3py não está mais sendo desenvolvido ativamente - Vincent é o equivalente moderno (uma interface Python para Vega / d3.js), mas a resposta da psychemedia abaixo (exportar networkx para json e renderizar em d3.js) pode ser a mais limpa.
A.Wan
2
Experimente altair-viz.github.io - o sucessor de d3py e vincent. Consulte também stackoverflow.com/a/49695472/179014 .
asmaier
43

Plotly suporta gráficos 2D e 3D interativos. Os gráficos são renderizados com D3.js e podem ser criados com uma API Python , matplotlib , ggplot para Python , Seaborn , prettyplotlib e pandas . Você pode aplicar zoom, panorâmica, ativar e desativar os traços e ver os dados ao pairar. Os gráficos podem ser incorporados em HTML, aplicativos, painéis e Notebooks IPython. Abaixo está um gráfico de temperatura mostrando a interatividade. Veja a galeria de tutoriais do IPython Notebooks para mais exemplos.

insira a descrição da imagem aqui



Os documentos fornecem exemplos de tipos de plotagem e fragmentos de código suportados.



insira a descrição da imagem aqui

Especificamente para sua pergunta, você também pode fazer plotagens interativas do NetworkX.

insira a descrição da imagem aqui

Para plotagem 3D com Python, você pode fazer plotagens 3D de dispersão, linha e superfície que são igualmente interativas. Os gráficos são renderizados com WebGL. Por exemplo, veja um gráfico 3D das taxas de swap do Reino Unido.



insira a descrição da imagem aqui

Divulgação: estou na equipe do Plotly.

Mateo Sanchez
fonte
9
Claramente, a questão visa grafos no sentido de nós conectados por arestas. Esta resposta inclui desnecessariamente outros recursos de visualização do plotly.
Lutz Büch
@ mateo-sanchez é muito lamentável que Plotly tenha decidido encerrar todas as assinaturas acadêmicas e individuais para se concentrar em clientes corporativos
Andreuccio
20

Você já olhou vincent? Vincent pega objetos de dados Python e os converte para a gramática de visualização Vega. Vega é uma ferramenta de visualização de alto nível construída sobre o D3. Em comparação com o D3py, o repo vincent foi atualizado mais recentemente. Embora os exemplos sejam todos estáticos D3.

mais informações:


Os gráficos podem ser visualizados no Ipython, basta adicionar este código

vincent.core.initialize_notebook()

Ou a saída para JSON onde você pode visualizar o gráfico de saída JSON no editor online Vega ( http://trifacta.github.io/vega/editor/ ) ou visualizá-los em seu servidor Python localmente. Mais informações sobre visualização podem ser encontradas no link pypi acima.

Não sei quando, mas o pacote Pandas deve ter integração D3 em algum ponto. http://pandas.pydata.org/developers.html

Bokeh é uma biblioteca de visualização Python que suporta visualização interativa. Seu back-end de saída principal é HTML5 Canvas e usa o modelo cliente / servidor.

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

sk8asd123
fonte
2
Vincent está de saída - parece que há algumas substituições, mas não tenho certeza de quão estreitamente vinculadas ao ipython elas estarão ..
naught101
19

Uma receita que usei (descrita aqui: Co-Director Network Data Files em GEXF e JSON da OpenCorporates Data via Scraperwiki e networkx ) funciona da seguinte maneira:

  • gerar uma representação de rede usando networkx
  • exportar a rede como um arquivo JSON
  • importar que JSON para a d3.js . ( networkx pode exportar as representações de árvore e gráfico / rede que d3.js pode importar).

O exportador JSON networkx assume a forma:

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

Como alternativa, você pode exportar a rede como um arquivo GEXF XML e, em seguida, importar esta representação para a biblioteca de visualização 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)
psychemedia
fonte
16

Outra opção é o bokeh, que acabou de ser lançado na versão 0.3.

MrDrFenner
fonte
7

Para aqueles que recomendaram o pyd3 , ele não está mais em desenvolvimento ativo e indica o vincent . vincent também não está mais em desenvolvimento ativo e recomenda o uso do altair .

Portanto, se você quiser um d3 pythônico, use altair.

Wes
fonte
5

Confira python-nvd3 . É um wrapper python para nvd3. Parece mais legal do que d3.py e também tem mais opções de gráfico.

rico
fonte
4

Eu sugeriria o uso de mpld3, que combina visualizações de javascript D3js com matplotlib de python.

A instalação e o uso são muito simples e tem alguns plugins legais e recursos interativos.

http://mpld3.github.io/

RAM
fonte
3

Plotly pode fazer coisas legais para vocêinsira a descrição da imagem aqui

https://plot.ly/

Produz gráficos altamente interativos que podem ser facilmente incorporados nas páginas HTML de seu servidor ou site privado usando sua API off-line.

Atualização: Tenho certeza sobre seus recursos de plotagem 3D, para gráficos 2D é incrível Obrigado

Jax
fonte
2
Observe que esta é a visualização do gráfico ... A questão solicita a visualização do gráfico . (Eu aprecio que essas frases sejam comumente confundidas!)
j6m8
2

Você também pode optar por serializar seus dados e, em seguida, visualizá-los em D3.js, como feito aqui: Use Python e Pandas para criar um diagrama de rede direcionado à força D3 (ele vem com um notebook jupyter também!)

Aqui está a essência. Você serializa seus dados de gráfico neste 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()

Em seguida, você carrega os dados com d3.js:

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

Para a rotina drawGraph, indico o link, entretanto.

Lutz Büch
fonte
Eu editei agora, mas não incluí a rotina drawGraph que chama drawLinks e drawNodes. Seria muito complicado e os elementos só fazem sentido no contexto de todo o arquivo html.
Lutz Büch
1

Existe uma porta interessante de NetworkX para Javascript que pode fazer o que você quiser. Veja http://felix-kling.de/JSNetworkX/

Aric
fonte
isso pode funcionar .... você pode me indicar a documentação, por favor? Como eu produziria um gráfico de python nesta biblioteca javascript ...? Eu quero gerá-lo em python primeiro ... ou como eu iria carregá-lo?
Eiyrioü von Kauyf
Na verdade, nunca usei JSNetworkX, então não tenho certeza de como funciona.
Aric
@ EiyrioüvonKauyf: A entrada é a mesma que em Python, por exemplo, uma lista de listas ou um dicionário de dictos. Você pode construir o gráfico em Python, convertê-lo em uma lista de listas e convertê-lo em JSON.
Felix Kling
Sim, definitivamente fácil. Os exemplos aqui são simples e bonitos: felix-kling.de/JSNetworkX/examples
Aric
1

Vejo:

Existe uma boa biblioteca de gráficos 3D interativos por aí?

A resposta aceita sugere o seguinte programa, que aparentemente tem ligações python: http://ubietylab.net/ubigraph/

Editar

Não tenho certeza sobre a interatividade do NetworkX, mas você pode definitivamente fazer gráficos 3D. Há pelo menos um exemplo na galeria:

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

E outro exemplo nos 'exemplos'. Este, no entanto, requer que você tenha Mayavi.

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

zimbro-
fonte
0

Eu tenho um bom exemplo de geração automática de diagramas de rede D3.js usando Python aqui: http://brandonrose.org/ner2sna

O legal é que você acaba com HTML e JS gerados automaticamente e pode incorporar o gráfico D3 interativo em um notebook com um IFrame

Brandomr
fonte
0

A biblioteca d3graphconstruirá um gráfico d3 direcionado à força a partir do python. Você pode "interromper" a rede com base no peso da borda e passar o mouse sobre os nós para obter mais informações. Clique duas vezes em um nó para focalizar o nó e suas arestas conectadas.

pip install d3graph

Exemplo:

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)

Exemplos de d3graph

Um exemplo interativo do caso titânico pode ser encontrado aqui: https://erdogant.github.io/docs/d3graph/titanic_example/index.html https://erdogant.github.io/hnet/pages/html/Use%20Cases .html

erdogante
fonte