L'exécution de la commande du shell et de la capture de la sortie

La réponse à cette question dépend de la version de Python que vous utilisez. L'approche la plus simple est d'utiliser le sous-processus.check_output fonction:

>>> subprocess.check_output(['ls', '-l'])
b'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

check_output exécute un programme simple qui ne prend que des arguments d'entrée.¹ Elle renvoie le résultat exactement comme imprimé à stdout. Si vous avez besoin d'écrire d'entrée à stdin, passez à la run ou Popen sections. Si vous voulez exécuter complexe des commandes du shell, voir la note sur shell=True à la fin de cette réponse.

La check_output fonctionne sur presque toutes les versions de Python encore en usage à l' (2.7+).² Mais pour des versions plus récentes, il n'est plus l'approche recommandée.

Moderne versions de Python (version 3.5 ou supérieure): run

Si vous utilisez Python 3.5 ou plus, et n'ont pas besoin de rétro-compatibilité, le nouveau exécuter function est recommandé. Il offre une très général, l'API de haut niveau pour la subprocess module. Pour récupérer la sortie d'un programme, passer le subprocess.PIPE drapeau de la stdout argument mot-clé. Alors accéder à l' stdout attribut de retour de la CompletedProcess objet:

>>> import subprocess
>>> result = subprocess.run(['ls', '-l'], stdout=subprocess.PIPE)
>>> result.stdout
b'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

La valeur de retour est un bytes objet, donc si vous voulez une chaîne correcte, vous aurez besoin de decode il. En supposant que le processus appelé renvoie une codé en UTF-8 chaîne:

>>> result.stdout.decode('utf-8')
'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

Cela peut être compressé à un one-liner:

>>> subprocess.run(['ls', '-l'], stdout=subprocess.PIPE).stdout.decode('utf-8')
'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

Si vous souhaitez passer des commentaires sur le processus de stdin, passer une bytes objet de la input argument mot-clé:

>>> cmd = ['awk', 'length($0) > 5']
>>> input = 'foo\nfoofoo\n'.encode('utf-8')
>>> result = subprocess.run(cmd, stdout=subprocess.PIPE, input=input)
>>> result.stdout.decode('utf-8')
'foofoo\n'

Vous pouvez capturer les erreurs en passant stderr=subprocess.PIPE (capture d' result.stderr) ou stderr=subprocess.STDOUT (capture d' result.stdout avec régulièrement des de sortie). Lorsque la sécurité n'est pas un problème, vous pouvez également exécuter plus complexe des commandes shell en passant shell=True comme décrit dans les notes ci-dessous.

Cela ajoute un peu de complexité, par rapport à l'ancienne façon de faire les choses. Mais je pense que ça vaut le résultat: maintenant, vous pouvez faire presque tout ce que vous devez faire avec le run seule fonction.

Les anciennes versions de Python (2.7-3.4): check_output

Si vous utilisez une ancienne version de Python, ou besoin d'un modeste rétro-compatibilité, vous pouvez probablement utiliser la check_output fonction que brièvement décrit ci-dessus. Il a été disponible depuis le Python 2.7.

subprocess.check_output(*popenargs, **kwargs)  

Il se prend les mêmes arguments que Popen (voir ci-dessous), et renvoie une chaîne contenant le programme de la sortie. Le début de cette réponse a une utilisation plus détaillés exemple. En Python 3.5 et supérieure, check_output est équivalent à l'exécution de run avec check=True et stdout=PIPE, et en retournant simplement le stdout attribut.

Vous pouvez passer stderr=subprocess.STDOUT pour s'assurer que les messages d'erreur sont inclus dans les résultats retournés -- mais dans certaines versions de Python en passant stderr=subprocess.PIPE à check_output peut causer les blocages. Lorsque la sécurité n'est pas un problème, vous pouvez également exécuter plus complexe des commandes shell en passant shell=True comme décrit dans les notes ci-dessous.

Si vous avez besoin d'un tuyau de stderr ou passer des commentaires sur le processus, check_output ne soit pas à la tâche. Voir la Popen exemples ci-dessous, dans ce cas.

Applications complexes & anciennes versions de Python (2.6 et ci-dessous): Popen

Si vous avez besoin profond d'une compatibilité ascendante, ou si vous avez besoin des fonctionnalités plus sophistiquées que check_output offre, vous aurez à travailler directement avec les Popen objets qui encapsulent les API de bas niveau pour les sous-processus.

La Popen constructeur accepte une seule commande sans arguments, ou une liste contenant une commande par son premier élément, suivi d'un nombre quelconque d'arguments, chacun d'eux comme un élément distinct dans la liste. shlex.split peut aider à analyser les chaînes dans le bon format de listes. Popen objets aussi accepter une hôte de différents arguments de processus IO de gestion et de bas niveau de la configuration.

Pour envoyer l'entrée et la sortie de capture, communicate est presque toujours la meilleure méthode. Comme dans:

output = subprocess.Popen(["mycmd", "myarg"], 
                          stdout=subprocess.PIPE).communicate()[0]

Ou

>>> import subprocess
>>> p = subprocess.Popen(['ls', '-a'], stdout=subprocess.PIPE, 
...                                    stderr=subprocess.PIPE)
>>> out, err = p.communicate()
>>> print out
.
..
foo

Si vous définissez stdin=PIPE, communicate vous permet aussi de passer des données dans le processus via stdin:

>>> cmd = ['awk', 'length($0) > 5']
>>> p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
...                           stderr=subprocess.PIPE,
...                           stdin=subprocess.PIPE)
>>> out, err = p.communicate('foo\nfoofoo\n')
>>> print out
foofoo

Note Aaron Hall répondre, ce qui indique que sur certains systèmes, vous devrez peut-être définir stdout, stderr, et stdin tous à PIPE (ou DEVNULL) pour obtenir communicate de travailler à tous.

Dans quelques rares cas, vous pouvez avoir besoin complexes en temps réel de la sortie de la capture. Vartec's réponse suggère une voie à suivre, mais d'autres méthodes que communicate sont sujettes à des blocages si pas utilisés avec soin.

Comme avec toutes les fonctions ci-dessus, lorsque la sécurité n'est pas un problème, vous pouvez exécuter plus complexe des commandes shell en passant shell=True.

Notes

1. L'exécution de commandes shell: le shell=True argument

Normalement, chaque appel à run, check_output, ou le Popen constructeur exécute une seul programme. Cela signifie pas de fantaisie, bash-style tuyaux. Si vous souhaitez exécuter le complexe des commandes du shell, vous pouvez passer shell=True, qui tous les trois fonctions de soutien.

Cependant, cela soulève les problèmes de sécurité. Si vous faites quelque chose de plus que la lumière de script, vous pourriez être mieux appeler chaque processus séparément, et en passant à la sortie de chacun d'eux comme une entrée à l'autre, via

run(cmd, [stdout=etc...], input=other_output)

Ou

Popen(cmd, [stdout=etc...]).communicate(other_output)

La tentation de connecter directement des tuyaux est forte d'y résister. Autrement, vous verrez probablement des blocages ou avez à faire hacky des choses comme cette.

2. Unicode considérations

check_output retourne une chaîne de caractères en Python 2, mais un bytes objet en Python 3. Il vaut la peine de prendre un moment pour apprendre sur unicode si vous ne l'avez pas déjà.

Quelque chose comme ça:

def runProcess(exe):    
    p = subprocess.Popen(exe, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    while(True):
        # returns None while subprocess is running
        retcode = p.poll() 
        line = p.stdout.readline()
        yield line
        if retcode is not None:
            break

Note, que je suis rediriger stderr vers stdout, il pourrait ne pas être exactement ce que vous voulez, mais je veux les messages d'erreur également.

Cette fonction rendements ligne par ligne comme ils viennent (normalement, vous auriez à attendre pour les sous-processus pour terminer à obtenir la sortie dans son ensemble).

Pour votre cas, l'utilisation serait:

for line in runProcess('mysqladmin create test -uroot -pmysqladmin12'.split()):
    print line,

C'est un difficile mais super simple solution qui fonctionne dans de nombreuses situations:

import os
os.system('sample_cmd > tmp')
print open('tmp', 'r').read()

Un fichier temporaire(ici est tmp) est créé avec la sortie de la commande et vous pouvez lire à partir de votre sortie désirée.

Note de vos commentaires:
Vous pouvez supprimer le fichier tmp dans le cas d'un travail à temps. Si vous avez besoin de faire cela plusieurs fois, il n'est pas nécessaire de supprimer la tmp.

os.remove('tmp')

J'ai eu le même problème, mais trouvé un moyen très simple de le faire:

import subprocess
output = subprocess.getoutput("ls -l")
print(output)

Espère que cela aide

Remarque: Cette solution est Python3 spécifiques comme subprocess.getoutput() ne fonctionne pas en Python2

Moderne Python solution (>= 3.1):

import subprocess     
res = subprocess.check_output(lcmd, stderr=subprocess.STDOUT)

J'ai eu un peu différents de goût de le même problème avec les exigences suivantes:

1. De Capture et de retour sur la sortie standard les messages qu'ils s'accumulent dans la sortie standard (STDOUT) tampon (c'est à dire en temps réel).
   • @vartec résolu ce Pythonically avec son utilisation de groupes électrogènes et le "rendement"
     
     mot-clé ci-dessus
2. Imprimer toutes les STDOUT lignes (même si le processus s'arrête avant la sortie standard de la mémoire tampon peut être lu)
3. Ne perdez pas de cycles CPU de l'interrogation du processus à haute fréquence de
4. Vérifier le code de retour de la sous-processus
5. Print STDERR (distincte de STDOUT) si nous obtenons une erreur non nulle code de retour.

J'ai combiné et tordu les réponses précédentes à venir avec les personnes suivantes:

import subprocess
from time import sleep

def run_command(command):
    p = subprocess.Popen(command,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         shell=True)
    # Read stdout from subprocess until the buffer is empty !
    for line in iter(p.stdout.readline, b''):
        if line: # Don't print blank lines
            yield line
    # This ensures the process has completed, AND sets the 'returncode' attr
    while p.poll() is None:                                                                                                                                        
        sleep(.1) #Don't waste CPU-cycles
    # Empty STDERR buffer
    err = p.stderr.read()
    if p.returncode != 0:
       # The run_command() function is responsible for logging STDERR 
       print("Error: " + str(err))

Ce code sera exécuté le même que les réponses précédentes:

for line in run_command(cmd):
    print(line)

Le fractionnement de la commande initiale pour la subprocess peut être difficile et fastidieux.

Utilisation shlex.split() pour vous aider à vous en sortir. 

Exemple de commande

git log -n 5 --since "5 years ago" --until "2 year ago"

Le code

from subprocess import check_output
from shlex import split

res = check_output(split('git log -n 5 --since "5 years ago" --until "2 year ago"'))
print(res)
>>> b'commit 7696ab087a163e084d6870bb4e5e4d4198bdc61a\nAuthor: Artur Barseghyan...'

Selon @senderle, si vous utilisez python3.6 comme moi:

def sh(cmd, input=""):
rst = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, input=input.encode("utf-8"))
assert rst.returncode == 0, rst.stderr.decode("utf-8")
return rst.stdout.decode("utf-8")

sh("ls -a")

Agira exactement comme vous exécutez la commande de bash

La sortie peut être redirigée vers un fichier texte et puis le lire.

import subprocess
import os
import tempfile
def execute_to_file(command):
"""
This function execute the command
and pass its output to a tempfile then read it back
It is usefull for process that deploy child process
"""
temp_file = tempfile.NamedTemporaryFile(delete=False)
temp_file.close()
path = temp_file.name
command = command + " > " + path
proc = subprocess.run(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
if proc.stderr:
# if command failed return
os.unlink(path)
return
with open(path, 'r') as f:
data = f.read()
os.unlink(path)
return data
if __name__ == "__main__":
path = "Somepath"
command = 'ecls.exe /files ' + path
print(execute(command))