Appel de gnuplot à partir de python

La sous-processus module vous permet d'appeler d'autres programmes:

import subprocess
plot = subprocess.Popen(['gnuplot'], stdin=subprocess.PIPE)
plot.communicate("plot '%s' with lines, '%s' with points;" % (eout,nout))

J'ai essayé de faire quelque chose de similaire, mais en plus, je voulais flux de données à partir de l'intérieur de python et de sortie le graphique fichier comme une variable (donc ni les données ni les graphique sont des fichiers réels). C'est ce que je suis venu avec:

#! /usr/bin/env python

import subprocess
from sys import stdout, stderr
from os import linesep as nl

def gnuplot_ExecuteCommands(commands, data):
    args = ["gnuplot", "-e", (";".join([str(c) for c in commands]))]
    program = subprocess.Popen(\
        args, \
        stdin=subprocess.PIPE, \
        stdout=subprocess.PIPE, \
        stderr=subprocess.PIPE, \
        )
    for line in data:
        program.stdin.write(str(line)+nl)
    return program

def gnuplot_GifTest():
    commands = [\
        "set datafile separator ','",\
        "set terminal gif",\
        "set output",\
        "plot '-' using 1:2 with linespoints, '' using 1:2 with linespoints",\
        ]
    data = [\
        "1,1",\
        "2,2",\
        "3,5",\
        "4,2",\
        "5,1",\
        "e",\
        "1,5",\
        "2,4",\
        "3,1",\
        "4,4",\
        "5,5",\
        "e",\
        ]
    return (commands, data)

if __name__=="__main__":
    (commands, data) = gnuplot_GifTest()
    plotProg = gnuplot_ExecuteCommands(commands, data)
    (out, err) = (plotProg.stdout, plotProg.stderr)
    stdout.write(out.read())

Script vide le graphique sur la sortie standard stdout comme la dernière étape dans principal. L'équivalent de ligne de commande (lorsque le graphe est canalisée vers 'out.gif"):

gnuplot -e "set datafile separator ','; set terminal gif; set output; plot '-' using 1:2 with linespoints, '' using 1:2 with linespoints" > out.gif
1,1
2,2
3,5
4,2
5,1
e
1,5
2,4
3,1
4,4
5,5
e

Je suis un peu en retard, mais depuis qu'il m'a fallu un certain temps pour le faire fonctionner, c'est peut-être la peine de mettre une note. Les programmes de travail avec Python 3.3.2 sur Windows.

Avis que les octets sont utilisés partout, pas des chaînes de caractères (par exemple b"de la parcelle x", et non pas simplement "de la parcelle x"), mais dans ce cas c'est un problème, il suffit de faire quelque chose comme:

"plot x".encode("ascii")

Première solution: utiliser communiquer pour envoyer le tout, et se ferment quand c'est fait. Il ne faut pas oublier pauseou la fenêtre est fermée à la fois. Cependant, il n'est pas un problème si gnuplot est utilisé pour stocker les images dans des fichiers.

from subprocess import *
path = "C:\\app\\gnuplot\\bin\\gnuplot"
p = Popen([path], stdin=PIPE, stdout=PIPE)
p.communicate(b"splot x*y\npause 4\n")

Deuxième solution: envoyer des commandes l'une après l'autre, à l'aide de stdin.écrire(...). Mais, n'oubliez pas de rincer! (c'est ce que je n'ai pas eu droit à la première) Et l'utilisation mettre fin à pour fermer la connexion et gnuplot quand le travail est terminé.

from subprocess import *
path = "C:\\app\\gnuplot\\bin\\gnuplot"
p = Popen([path], stdin=PIPE, stdout=PIPE)
p.stdin.write(b"splot x*y\n")
p.stdin.flush()
...
p.stdin.write(b"plot x,x*x\n")
p.stdin.flush()
...
p.terminate()

Voici un autre exemple qui s'étend sur les réponses précédentes. Cette solution nécessite Gnuplot 5.1car il utilise des blocs de donnée. Pour plus d'informations sur les datablocks, exécuter help datablocks dans gnuplot.
Le problème avec certaines des approches précédentes est que plot '-' instantanément consomme les données qui suit immédiatement la commande plot. Il n'est pas possible de réutiliser les mêmes données dans un complot de la commande. les datablocks peut être utilisé pour pallier ce problème. À l'aide de blocs de donnée on peut imiter plusieurs fichiers de données. Par exemple, vous pouvez tracer un graphique à partir des données de deux fichiers de données, par exemple plot "myData.dat" using 1:2 with linespoints, '' using 1:3 with linespoints, "myData2.dat" using 1:2 with linespoints. Nous avons pu nourrir ces données directement à gnuplot sans la nécessité de créer des fichiers de données réelles.

import sys, subprocess
from os import linesep as nl
from subprocess import Popen, PIPE
def gnuplot(commands, data):                                                    
""" drive gnuplot, expects lists, returns stdout as string """  
script= nl.join(data)+nl.join(commands)+nl
print script
args = ["gnuplot", "-p"]
p = Popen(args, shell=False, stdin=PIPE)                       
return p.communicate(script)[0]  
def buildGraph():
commands = [\
"set datafile separator ','",\
"plot '$data1' using 1:2 with linespoints, '' using 1:3 with linespoints, '$data2' using 1:2 with linespoints",\
]
data = [\
"$data1 << EOD",\
"1,30,12",\
"2,40,15",\
"3,35,20",\
"4,60,21",\
"5,50,30",\
"EOD",\
"$data2 << EOD",\
"1,20",\
"2,40",\
"3,40",\
"4,50",\
"5,60",\
"EOD",\
]
return (commands, data)  
def main(args):
(commands, data) = buildGraph()
print gnuplot(commands, data)
if __name__ == "__main__":
main(sys.argv[1:])

Cette méthode est un peu plus polyvalent que plot '-' comme il est plus facile de réutiliser les mêmes données plusieurs fois, y compris sur la même parcelle de commande: https://stackoverflow.com/a/33064402/895245
Notez que cette approche exige que les données sont envoyées à gnuplot avant la parcelle commandes!

Aussi, je n'ai pas utiliser IOString @ppetraki fait, car apparemment c'est plus lent que d'une simple liste de menuisier: https://waymoot.org/home/python_string/