Exécuter des commandes Séquentiellement en Python?

Question

Je souhaite exécuter des commandes multiples dans une rangée:

i.e.. (Juste pour illustrer mes besoins):

cmd (la coque)

puis

cd dir

et

ls

et lire le résultat du subprocess.

Une idée avec le module <=>?

Mise à jour:

<=> et sont juste un <=> exemple. J'ai besoin d'exécuter des commandes complexes (suivant un ordre particulier, sans pipelining). En fait, je voudrais une coquille subprocess et la possibilité de lancer de nombreuses commandes sur elle.

Answer 1

Il est un moyen facile d'exécuter une séquence de commandes.

Utilisez les éléments suivants dans subprocess.Popen

"command1; command2; command3"

Ou, si vous êtes coincé avec des fenêtres, vous avez plusieurs choix.

• Créer un fichier ".bat" temporaire et fournir ce à <=>

• Créer une séquence de commandes avec "\ n" séparateurs dans une seule chaîne longue.

Utilisez "" "s, comme celui-ci.

"""
command1
command2
command3
"""

Ou, si vous devez faire les choses au coup par coup, vous devez faire quelque chose comme ça.

class Command( object ):
    def __init__( self, text ):
        self.text = text
    def execute( self ):
        self.proc= subprocess.Popen( ... self.text ... )
        self.proc.wait()

class CommandSequence( Command ):
    def __init__( self, *steps ):
        self.steps = steps
    def execute( self ):
        for s in self.steps:
            s.execute()

Cela vous permettra de construire une séquence de commandes.

Answer 2

Pour ce faire, vous devez:

• fournir l'argument dans l'appel shell=True subprocess.Popen et
• séparer les commandes avec:
  • ; si on travaille sous une coque * nix (bash, cendres, sh, ksh, csh, tcsh, zsh etc)
  • & en cas d'exécution sous le Windows cmd.exe

Answer 3

'bar' Trouver dans tous les fichiers dont le nom contient 'foo':

from subprocess import Popen, PIPE
find_process = Popen(['find', '-iname', '*foo*'], stdout=PIPE)
grep_process = Popen(['xargs', 'grep', 'bar'], stdin=find_process.stdout, stdout=PIPE)
out, err = grep_process.communicate()

'out' et 'err' sont des objets de chaîne contenant la sortie standard et, éventuellement, la sortie d'erreur.

Answer 4

Oui, la fonction prend en charge un argument subprocess.Popen() de mot-clé cwd, avec lequel vous pouvez définir le répertoire dans lequel il exécute le processus.

Je suppose que la première étape, la coquille, n'est pas nécessaire, si vous voulez simplement courir ls, il n'y a pas besoin de tourner à travers un shell.

Bien sûr, vous pouvez aussi passer tout le répertoire désiré comme argument à cd.

Mise à jour: il pourrait être intéressant de noter que pour les coques typiques, est mis en œuvre dans <=> la coque elle-même, il n'est pas une commande externe sur le disque. En effet, il doit changer le répertoire courant du processus, ce qui doit être fait à l'intérieur du processus. Étant donné que les commandes fonctionnent comme enfant traité, donné naissance par la coquille, ils ne peuvent pas le faire.

Answer 5

ci-dessous script python avoir 3 fonction ce que vous excute juste Je suis allé:

import sys
import subprocess

def cd(self,line):
    proc1 = subprocess.Popen(['cd'],stdin=subprocess.PIPE)
    proc1.communicate()

def ls(self,line):
    proc2 = subprocess.Popen(['ls','-l'],stdin=subprocess.PIPE)
    proc2.communicate()

def dir(silf,line):
    proc3 = subprocess.Popen(['cd',args],stdin=subprocess.PIPE)
    proc3.communicate(sys.argv[1])