Comment utiliser subprocess.Popen pour connecter plusieurs processus par des tuyaux?

import subprocess

some_string = b'input_data'

sort_out = open('outfile.txt', 'wb', 0)
sort_in = subprocess.Popen('sort', stdin=subprocess.PIPE, stdout=sort_out).stdin
subprocess.Popen(['awk', '-f', 'script.awk'], stdout=sort_in, 
                 stdin=subprocess.PIPE).communicate(some_string)

Pour émuler un oléoduc de shell:

from subprocess import check_call

check_call('echo "input data" | a | b > outfile.txt', shell=True)

sans invoquer le shell (voir 17.1.4.2. Remplacement du pipeline shell):

#!/usr/bin/env python
from subprocess import Popen, PIPE

a = Popen(["a"], stdin=PIPE, stdout=PIPE)
with a.stdin:
    with a.stdout, open("outfile.txt", "wb") as outfile:
        b = Popen(["b"], stdin=a.stdout, stdout=outfile)
    a.stdin.write(b"input data")
statuses = [a.wait(), b.wait()] # both a.stdin/stdout are closed already

plumbum fournit du sucre de syntaxe:

#!/usr/bin/env python
from plumbum.cmd import a, b # magic

(a << "input data" | b > "outfile.txt")()

analogique:

#!/bin/sh
echo "input data" | awk -f script.awk | sort > outfile.txt

est:

#!/usr/bin/env python
from plumbum.cmd import awk, sort

(awk["-f", "script.awk"] << "input data" | sort > "outfile.txt")()

http://www.python.org/doc/2.5.2/lib/node535.html couvrait assez bien cette question. Y a-t-il quelque chose que vous n'avez pas compris?

votre programme serait assez similaire, mais le second Popen aurait stdout= à un fichier, vous n'avez pas besoin de la sortie de son .communicate().

inspiré de la réponse de @Cristian. J'ai rencontré le même problème, mais avec une commande Différente. Donc je mets mon exemple testé, qui je crois pourrait être utile:

grep_proc = subprocess.Popen(["grep", "rabbitmq"],
                             stdin=subprocess.PIPE, 
                             stdout=subprocess.PIPE)
subprocess.Popen(["ps", "aux"], stdout=grep_proc.stdin)
out, err = grep_proc.communicate()

ceci est testé.

Ce qui a été fait

• déclaré paresseux grep exécution avec stdin de pipe. Cette commande sera exécutée au ps exécution de la commande quand le tuyau sera rempli avec le stdout de ps.
• appelé la commande principale ps avec stdout dirigé vers le canal utilisé par le grep la commande.
• Grep communiqué pour sortir stdout du tuyau.

j'aime cette façon parce qu'il est naturel de tuyau de conception délicatement enveloppé avec subprocess interfaces.

EDIT:pipes est disponible sur Windows mais, surtout, ne semble pas réellement sur Windows. Voir les commentaires ci-dessous.

la bibliothèque standard de Python inclut maintenant pipes module pour gérer cela:

https://docs.python.org/2/library/pipes.html, https://docs.python.org/3.4/library/pipes.html

Je ne sais pas combien de temps ce module a été autour, mais cette approche apparaît à être nettement plus simple que de coucher avec subprocess.

les réponses précédentes ont omis un point important. Remplacement d'oléoduc de shell est fondamentalement correcte, comme le souligne geocar. C'est presque suffisant pour exécuter communicate sur le dernier élément de la pipe.

le problème restant est de passer le données d'entrée au pipeline. Avec plusieurs sous-processus, un simple communicate(input_data) sur le dernier élément ne fonctionne pas - il se bloque toujours. Vous devez créer un pipeline et d'un enfant manuellement comme ceci:

import os
import subprocess

input = """\
input data
more input
""" * 10

rd, wr = os.pipe()
if os.fork() != 0: # parent
    os.close(wr)
else:              # child
    os.close(rd)
    os.write(wr, input)
    os.close(wr)
    exit()

p_awk = subprocess.Popen(["awk", "{ print ; }"],
                         stdin=rd,
                         stdout=subprocess.PIPE)
p_sort = subprocess.Popen(["sort"], 
                          stdin=p_awk.stdout,
                          stdout=subprocess.PIPE)
p_awk.stdout.close()
out, err = p_sort.communicate()
print (out.rstrip())

maintenant l'enfant fournit L'entrée par la pipe, et le parent appelle communicate (), ce qui fonctionne comme prévu. Avec cette approche, vous pouvez créer de longs pipelines arbitraires sans avoir recours à la "délégation d'une partie du travail au shell". Malheureusement, le documentation des sous-processus n'en parle pas.

il y a des moyens d'obtenir le même effet sans pipes:

from tempfile import TemporaryFile
tf = TemporaryFile()
tf.write(input)
tf.seek(0, 0)

maintenant utilisez stdin=tfp_awk. C'est un question de goût ce que vous préférez.

ce qui précède n'est toujours pas 100% équivalent à bash pipelines parce que la manipulation du signal est différente. Vous pouvez voir si vous ajoutez un autre tuyau élément qui tronque la sortie de sort, e.g. head -n 10. Avec le code ci-dessus, sort affichera un message d'erreur" broken pipe " à stderr. Vous ne verrez pas ce message lorsque vous exécutez le même pipeline dans le shell. (C'est la seule différence, le résultat stdout est la même). Raison semble que python Popen configure SIG_IGNSIGPIPE, alors que la coque laisse au SIG_DFL et