Comment faire pour exécuter plusieurs commandes de façon synchrone à partir d'un sous-processus.Popen commande?

Si vous voulez exécuter plusieurs commandes l'une après l'autre dans le même session/shell, vous devez lancer un interpréteur de commandes et de le nourrir avec toutes les commandes, un à la fois, suivie par une nouvelle ligne, et fermer le tuyau à la fin. Il a de sens que si certaines commandes ne sont pas de vrais processus, mais des commandes shell qui pourrait par exemple changer le shell de l'environnement.

Exemple à l'aide de Python 2.7 sous Windows:

encoding = 'latin1'
p = subprocess.Popen('cmd.exe', stdin=subprocess.PIPE,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
for cmd in cmds:
    p.stdin.write(cmd + "\n")
p.stdin.close()
print p.stdout.read()

Pour avoir ce code s'exécuter sous Linux, vous devez remplacer cmd.exe avec /bin/bash et probablement changer l'encodage utf8.

Pour Python 3, vous devez encoder les commandes et probablement décoder leur sortie, et à utiliser des parenthèses avec imprimer.

Attention: ceci ne peut fonctionner que pour peu de sortie. S'il y avait suffisamment de puissance pour remplir le canal de la mémoire tampon avant de fermer le stdin de la pipe, ce code de blocage. D'une façon plus robuste serait d'avoir un deuxième thread pour lire la sortie des commandes pour éviter ce problème.

OriginalL'auteur Serge Ballesta

Ceci est similaire à la réponse posté par Serge Ballesta, mais pas tout à fait. Utiliser pour son exécution asynchrone, où vous n'avez pas de soins sur les résultats. Utiliser le mien pour le traitement et le résultat de la cueillette. Comme sa réponse, je suis en montrant les Fenêtres solution ici - lancer un bash processus dans Linux plutôt que cmd sous Windows.

from subprocess import Popen, PIPE
process = Popen( "cmd.exe", shell=False, universal_newlines=True,
                  stdin=PIPE, stdout=PIPE, stderr=PIPE )                             
out, err = process.communicate( commands ) 

Les DÉTAILS d'UTILISATION: La commands argument étant passé ici à la process.communicate méthode est un retour à la ligne délimitée chaîne. Si, par exemple vous venez de lire un lot contenu du fichier dans une chaîne, vous pouvez exécuter de cette façon parce qu'il aurait déjà les retours à la ligne. Important: votre chaîne doit se terminer par un saut de ligne "\n". Si il ne fait pas, que la finale de la commande n'a pas été exécutée. Tout comme si vous avez tapé dans votre invite de commande mais n'a pas frappé le enter à la fin. Vous verrez toutefois un mystérieux More? ligne à la fin de la sortie standard (stdout) est retourné. (c'est la cause, si vous rencontrez ce).

process.communicate s'exécute de façon synchrone par définition, et renvoie le stdout et stderr messages (si vous les a dirigés vers subprocess.PIPE dans votre Popen constructeur).

Lorsque vous créez un cmd.exe processus de cette façon, et de passer une chaîne de caractères, le résultat sera exactement comme si vous étiez à ouvrir une fenêtre d'invite de commandes et les commandes écrites. Et je veux dire que littéralement. Si vous testez, vous verrez que la sortie standard (stdout) qui est retourné contient vos commandes. (Il n'a PAS d'importance si vous incluez un @echo off comme si l'exécution d'un fichier de commandes).

Conseils pour ceux qui se soucient de "nettoyer" stdout résultats:

• @echo off ne sera pas supprimer vos commandes d'apparaître dans cette chaîne de retour, mais il n'supprimer les retours à la ligne, qui trouvent leur voie dans autrement. (universal_newlines=True bandes d'un autre ensemble de celles-ci)

• Y compris un @ symbole du préfixe de vos commandes leur permet de toujours exécuter. Dans un "normal" traitement par lots qui de la, ligne par ligne, de façon à "cacher" vos commandes. Dans ce contexte, il y a fort à un simple marqueur par lequel vous pouvez trouver la sortie standard les lignes que vous souhaitez supprimer. (si l'on a été si incliné)

• L'cmd.exe "en-tête" apparaîtra dans votre sortie (qui dit que la version de Windows etc.). Depuis, vous voudrez probablement commencer votre jeu de commandes avec @echo off, découper l'extra retours à la ligne, qui est aussi un excellent moyen de trouver l'endroit où les lignes d'en-tête s'est arrêté et vos commandes/résultats ont commencé.

Enfin, pour répondre aux préoccupations au sujet de "grande" sortie de remplissage des tuyaux et de vous causer des problèmes - d'abord je pense que vous avez besoin d'une ÉNORME quantité de données de revenir, pour que ce soit un problème - plus que la plupart des gens se rencontrer dans leurs cas d'utilisation. Deuxièmement, si c'est vraiment une préoccupation, il suffit d'ouvrir un fichier pour l'écriture et le passer descripteur de fichier (la référence à l'objet de fichier) sur la sortie standard stdout/err au lieu de PIPE. Ensuite, faire ce que vous voulez avec le fichier que vous avez créé.

OriginalL'auteur BuvinJ

Ici est une fonction (à exécuter) que j'utilise. Je dirais que vous pouvez utiliser pour votre problème. Et il est flexible.

# processJobsInAList.py
# 2016-09-27   7:00:00 AM   Central Daylight Time 

import win32process, win32event

def CreateMyProcess2(cmd):
    ''' create process width no window that runs a command with arguments
    and returns the process handle'''
    si   = win32process.STARTUPINFO()
    info = win32process.CreateProcess(
        None,      # AppName
        cmd,       # Command line
        None,      # Process Security
        None,      # Thread Security
        0,         # inherit Handles?
        win32process.NORMAL_PRIORITY_CLASS,
        None,      # New environment
        None,      # Current directory
        si)        # startup info
    # info is tuple (hProcess, hThread, processId, threadId)
    return info[0]

if __name__ == '__main__' :
    ''' create/run a process for each list element in "cmds"
    output may be out of order because processes run concurrently '''

    cmds=["echo my","echo heart","echo belongs","echo to","echo daddy"]
    handles    = []
    for i in range(len(cmds)):
        cmd    = 'cmd /c ' + cmds[i]
        handle = CreateMyProcess2(cmd)
        handles.append(handle)

    rc = win32event.WaitForMultipleObjects( handles, 1, -1)  # 1 wait for all, -1 wait infinite
    print 'return code ',rc

de sortie:

cœur

mon

appartient

pour

papa

code de retour 0

Mise à JOUR: Si vous souhaitez exécuter le même processus, qui va sérialiser les choses pour vous:

1) Supprimer la ligne: les poignées.append(poignée)

2) le remplacement de la variable "gérer" à la place de la liste des "poignées" sur "l'Attente" de la ligne

3) le remplacement de WaitForSingleObject en place de WaitForMultipleObjects

OriginalL'auteur Marichyasana