Pergunta

Eu comecei em um projeto gráfico Tomcat registros usando gnuplot-py , especificamente correlacionando pedidos particulares com alocação de memória e coleta de lixo. O que é sabedoria coletiva em gnuplot-py vs Matplotlib para Python gráficos. Há melhor graficamente bibliotecas lá fora, eu não tenha ouvido falar?

As minhas considerações gerais são:

  • Enquanto gnuplot tem grandes quantidades de documentação, gnuplot-py não. Como é bom comunidade documentação para Matplotlib?
  • Existem coisas que gnuplot pode fazer, mas gnuplot-py não pode?
  • O Matplotlib tem melhor suporte Python?
  • Existem são grande show parando erros em ambos? Aborrecimentos?
  • Atualmente gnuplot é graficamente 100.000 's de pontos, eu estou pensando em escalar esta até milhões. Devo esperar problemas? Como bem Matplotlib lidar com isso?
  • Facilidade de uso, tempo de resposta para gnuplot vs Matplotlib?
  • Como seria fácil para o código gnuplot-py existente porta para Matplotlib?

Como você abordaria esta tarefa?

Foi útil?

Solução

  • Você pode verificar de matplotlib si mesmo. Acho que é bastante abrangente.
  • Eu tenho muito pouca experiência com gnuplot-py, então eu não posso dizer se ele pode fazer tudo gnuplot pode.
  • Matplotlib é escrito e desenhado especificamente para Python, por isso se encaixa muito bem com linguagens Python e tal.
  • Matplotlib é um projeto maduro. NASA usa-lo para algumas coisas.
  • Eu plotados dezenas de milhões de pontos em Matplotlib, e ele ainda estava linda e respondeu rapidamente.
  • Para além da maneira orientada a objetos de usar Matplotlib é a interface Pylab, o que torna plotagem tão fácil como no MATLAB -. Isto é, muito fácil
  • Como para portar a partir gnuplot-py para matplotlib, eu não tenho idéia.

Outras dicas

Matplotlib = facilidade de uso, Gnuplot = (um pouco melhor) desempenho

Eu sei que este post é antigo e respondeu, mas eu estava passando e queria colocar meus dois centavos. Aqui é a minha conclusão: se você tiver uma não tão grande conjunto de dados, você deve usar Matplotlib. É mais fácil e fica melhor. No entanto, se você realmente desempenho necessidade, você poderia usar Gnuplot. Eu adicionei alguns códigos para testá-lo em sua máquina e veja por si mesmo se ele faz a diferença real (isto não é um benchmark de desempenho real, mas deve dar uma primeira idéia).

O gráfico seguinte representa o tempo necessário (em segundos) para:

  • Traçar uma dispersão aleatória gráfico
  • Salvar o gráfico para um arquivo PNG

Gnuplot VS Matplotlib

Configuração:

  • gnuplot: 5.2.2
  • gnuplot-py: 1.8
  • matplotlib: 2.1.2

Lembro-me da diferença de desempenho ser muito maior quando executado em um computador mais antigo com versões mais antigas das bibliotecas (~ 30 segundos de diferença para um grande gráfico de dispersão).

Além disso, como mencionada nos comentários, você pode obter qualidade equivalente de parcelas. Mas você vai ter de colocar mais suor em que fazê-lo com Gnuplot.

Aqui está o código para gerar o gráfico se você quiser experimentá-lo em sua máquina : 

# -*- coding: utf-8 -*-

from timeit import default_timer as timer
import matplotlib.pyplot as plt
import Gnuplot, Gnuplot.funcutils
import numpy as np
import sys
import os

def mPlotAndSave(x, y):
    plt.scatter(x, y)
    plt.savefig('mtmp.png')
    plt.clf()

def gPlotAndSave(data, g):
    g("set output 'gtmp.png'")
    g.plot(data)
    g("clear")

def cleanup():
    try:
        os.remove('gtmp.png')
    except OSError:
        pass
    try:
        os.remove('mtmp.png')
    except OSError:
        pass

begin = 2
end = 500000
step = 10000
numberOfPoints = range(begin, end, step)
n = len(numberOfPoints)
gnuplotTime = []
matplotlibTime = []
progressBarWidth = 30

# Init Gnuplot
g = Gnuplot.Gnuplot()
g("set terminal png size 640,480")

# Init matplotlib to avoid a peak in the beginning
plt.clf()

for idx, val in enumerate(numberOfPoints):
    # Print a nice progress bar (crucial)
    sys.stdout.write('\r')
    progress = (idx+1)*progressBarWidth/n
    bar = "▕" + "▇"*progress + "▁"*(progressBarWidth-progress) + "▏" + str(idx) + "/" + str(n-1)
    sys.stdout.write(bar)
    sys.stdout.flush()

    # Generate random data
    x = np.random.randint(sys.maxint, size=val)  
    y = np.random.randint(sys.maxint, size=val)
    gdata = zip(x,y)

    # Generate string call to a matplotlib plot and save, call it and save execution time
    start = timer()
    mPlotAndSave(x, y)
    end = timer()
    matplotlibTime.append(end - start)

    # Generate string call to a gnuplot plot and save, call it and save execution time
    start = timer()
    gPlotAndSave(gdata, g)
    end = timer()
    gnuplotTime.append(end - start)

    # Clean up the files
    cleanup()

del g
sys.stdout.write('\n')
plt.plot(numberOfPoints, gnuplotTime, label="gnuplot")
plt.plot(numberOfPoints, matplotlibTime, label="matplotlib")
plt.legend(loc='upper right')
plt.xlabel('Number of points in the scatter graph')
plt.ylabel('Execution time (s)')
plt.savefig('execution.png')
plt.show()

matplotlib tem belos boa documentação, e parece ser bastante estável. As parcelas que produz são bonitas - "qualidade publicação" com certeza. Devido a documentação boa ea quantidade de exemplo de código disponível on-line, é fácil de aprender e usar, e eu não acho que você vai ter muita dificuldade para traduzir o código gnuplot a ele. Afinal, matplotlib está sendo usado por cientistas para dados de plotagem e preparar relatórios -. Por isso inclui tudo o que necessita

Uma vantagem marcada de matplotlib é que você pode integrá-lo com Python GUIs ( wxPython e PyQt , pelo menos) e criar aplicativos GUI com parcelas agradáveis.

Depois de usar o Gnuplot (com o meu próprio invólucro Python) por um longo tempo (e não gostando muito a saída 80-olhando), eu só comecei a ter um olhar para matplotlib. Devo dizer que eu gosto muito, a saída parece realmente bom e os documentos são de alta qualidade e extenso (embora isso também vale para o Gnuplot). As idades Uma coisa que eu gasto procurando na documentação matplotlib é como escrever para um arquivo de imagem em vez de para a tela! Felizmente esta página explica isso muito bem: http: // www .dalkescientific.com / escritos / diário / arquivo / 2005/04/23 / matplotlib_without_gui.html

Eu já joguei com ambos, e eu como Matplotlib muito melhor em termos de integração Python, opções e qualidade de gráficos / parcelas.

O Gnuplot pode fazer Gnuplot-Py pode fazer também. Porque Gnuplot pode ser conduzido por tubo (pgnuplot). Gnuplot-Py é apenas uma fina camada para ele. Então você não precisa se preocupar com isso.

Por que eu prefiro gnuplot talvez o formato muitos saída (PDF, PS e látex), que é muito útil em papéis, e mais de estilo científica aparência de saída padrão:)

Sobre o desempenho e traçando um grande número de pontos:. Eu comparei isso por um gráfico de dispersão de 500.000 pontos carregados de um arquivo de texto e salvos em um png, usando gnuplot * e matplotlib 

500.000 points scatterplot
gnuplot:      5.171 s
matplotlib: 230.693 s

Eu corri apenas uma vez e os resultados não parecem idênticos, mas eu acho que a idéia é clara:. Vitórias gnuplot com desempenho

* Eu costumava gnuplot diretamente desde o gnuplotpy demonstração não funciona out-of-the-box para mim. Matplotlib ganha na integração Python.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top