Exécution de la commande shell et capture de la sortie

Je veux écrire une fonction qui exécutera une commande shell et retournera sa sortie sous forme de chaîne , peu importe, est-ce un message d'erreur ou de réussite. Je veux juste obtenir le même résultat que j'aurais obtenu avec la ligne de commande.

Quel serait un exemple de code qui ferait une telle chose?

Par exemple:

def run_command(cmd):
    # ??????

print run_command('mysqladmin create test -uroot -pmysqladmin12')
# Should output something like:
# mysqladmin: CREATE DATABASE failed; error: 'Can't create database 'test'; database exists'

La réponse à cette question dépend de la version de Python que vous utilisez. L'approche la plus simple consiste à utiliser la subprocess.check_outputfonction:

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

check_outputexécute un seul programme qui ne prend que des arguments en entrée. ¹ Il renvoie le résultat exactement tel qu'imprimé stdout. Si vous devez écrire une entrée dans stdin, passez directement aux sections runou Popen. Si vous souhaitez exécuter des commandes shell complexes, consultez la note shell=Trueà la fin de cette réponse.

La check_outputfonction fonctionne sur presque toutes les versions de Python encore largement utilisées (2.7+). ² Mais pour les versions plus récentes, ce n'est plus l'approche recommandée.

Versions modernes de Python (3.5 ou supérieur): run

Si vous utilisez Python 3.5 ou supérieur et n'avez pas besoin de compatibilité descendante , la nouvelle runfonction est recommandée. Il fournit une API de haut niveau très générale pour le subprocessmodule. Pour capturer la sortie d'un programme, passez l' subprocess.PIPEindicateur à l' stdoutargument mot - clé. Accédez ensuite à l' stdoutattribut de l' CompletedProcessobjet retourné :

>>> 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 bytesobjet, donc si vous voulez une chaîne correcte, vous en aurez besoin decode. En supposant que le processus appelé renvoie une chaîne codée en UTF-8:

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

Tout cela peut être compressé en une seule ligne:

>>> 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 transmettre une entrée aux processus stdin, passez un bytesobjet à l' inputargument 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 des erreurs en passant stderr=subprocess.PIPE(capture à result.stderr) ou stderr=subprocess.STDOUT(capture à result.stdoutavec sortie régulière). Lorsque la sécurité n'est pas un problème, vous pouvez également exécuter des commandes shell plus complexes en passant shell=Truecomme décrit dans les notes ci-dessous.

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

Versions plus anciennes de Python (2.7-3.4): check_output

Si vous utilisez une ancienne version de Python ou si vous avez besoin d'une rétrocompatibilité modeste, vous pouvez probablement utiliser la check_outputfonction décrite brièvement ci-dessus. Il est disponible depuis Python 2.7.

subprocess.check_output(*popenargs, **kwargs)  

Il prend les mêmes arguments que Popen(voir ci-dessous) et renvoie une chaîne contenant la sortie du programme. Le début de cette réponse contient un exemple d'utilisation plus détaillé. En Python 3.5 et supérieur, check_outputéquivaut à exécuter runavec check=Trueet stdout=PIPEet à ne renvoyer que l' stdoutattribut.

Vous pouvez passer stderr=subprocess.STDOUTpour vous assurer que les messages d'erreur sont inclus dans la sortie renvoyée - mais dans certaines versions de Python, le passage stderr=subprocess.PIPEà check_outputpeut provoquer des blocages . Lorsque la sécurité n'est pas un problème, vous pouvez également exécuter des commandes shell plus complexes en passant shell=Truecomme décrit dans les notes ci-dessous.

Si vous avez besoin de diriger stderrou de transmettre des données au processus, vous check_outputne serez pas à la hauteur de la tâche. Voir les Popenexemples ci-dessous dans ce cas.

Applications complexes et versions héritées de Python (2.6 et inférieures): Popen

Si vous avez besoin d'une compatibilité ascendante profonde ou si vous avez besoin de fonctionnalités plus sophistiquées que celles check_outputfournies, vous devrez travailler directement avec des Popenobjets, qui encapsulent l'API de bas niveau pour les sous-processus.

Le Popenconstructeur accepte soit une seule commande sans arguments, soit une liste contenant une commande comme premier élément, suivie d'un nombre quelconque d'arguments, chacun comme un élément distinct dans la liste. shlex.splitpeut aider à analyser les chaînes dans des listes correctement formatées. PopenLes objets acceptent également une multitude d'arguments différents pour la gestion des E / S de processus et la configuration de bas niveau.

Pour envoyer des entrées et capturer des sorties, communicatec'est presque toujours la méthode préférée. Un péché:

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, communicatevous permet également de transmettre des données au 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 réponse de Hall , qui indique que sur certains systèmes, vous devrez peut - être ensemble stdout, stderret stdintous PIPE(ou DEVNULL) pour obtenir communicateau travail du tout.

Dans certains cas rares, vous pouvez avoir besoin d'une capture de sortie complexe en temps réel. La réponse de Vartec suggère une voie à suivre, mais des méthodes autres que celles communicatesujettes à des blocages ne sont pas utilisées avec précaution.

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

Remarques

1. Exécuter des commandes shell: l' shell=Trueargument

Normalement, chaque appel à run, check_outputou le Popenconstructeur exécute un seul programme . Cela signifie pas de tuyaux de style bash fantaisie. Si vous souhaitez exécuter des commandes shell complexes, vous pouvez passer shell=True, que les trois fonctions prennent en charge.

Cependant, cela pose des problèmes de sécurité . Si vous faites autre chose que des scripts légers, vous feriez mieux d'appeler chaque processus séparément et de passer la sortie de chacun comme entrée au suivant, via

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

Ou

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

La tentation de connecter directement les tuyaux est forte; Résiste. Sinon, vous verrez probablement des blocages ou devrez faire des choses comme ça .

2. Considérations Unicode

check_outputrenvoie une chaîne en Python 2, mais un bytesobjet en Python 3. Cela vaut la peine de prendre un moment pour en apprendre unicode si vous ne l'avez pas déjà fait.

C'est beaucoup plus facile, mais ne fonctionne que sur Unix (y compris Cygwin) et Python2.7.

import commands
print commands.getstatusoutput('wc -l file')

Il retourne un tuple avec (return_value, output).

Pour une solution qui fonctionne à la fois en Python2 et Python3, utilisez subprocessplutôt le module:

from subprocess import Popen, PIPE
output = Popen(["date"],stdout=PIPE)
response = output.communicate()
print response

Quelque chose comme ca:

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

Notez que je redirige stderr vers stdout, ce n'est peut-être pas exactement ce que vous voulez, mais je veux aussi des messages d'erreur.

Cette fonction produit ligne par ligne au fur et à mesure (normalement, vous devez attendre la fin du sous-processus pour obtenir la sortie dans son ensemble).

Pour votre cas, l'utilisation serait:

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

La réponse de Vartec ne lit pas toutes les lignes, j'ai donc fait une version qui l'a fait:

def run_command(command):
    p = subprocess.Popen(command,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.STDOUT)
    return iter(p.stdout.readline, b'')

L'utilisation est la même que la réponse acceptée:

command = 'mysqladmin create test -uroot -pmysqladmin12'.split()
for line in run_command(command):
    print(line)

Il s'agit d'une solution délicate mais super simple qui fonctionne dans de nombreuses situations:

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

Un fichier temporaire (ici tmp) est créé avec la sortie de la commande et vous pouvez y lire la sortie souhaitée.

Note supplémentaire dans les commentaires: vous pouvez supprimer le fichier tmp dans le cas d'un travail unique. Si vous devez le faire plusieurs fois, il n'est pas nécessaire de supprimer le tmp.

os.remove('tmp')

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

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

J'espère que ça aide

Remarque: Cette solution est spécifique à Python3 car subprocess.getoutput()elle ne fonctionne pas dans Python2

Vous pouvez utiliser les commandes suivantes pour exécuter n'importe quelle commande shell. Je les ai utilisés sur Ubuntu.

import os
os.popen('your command here').read()

Remarque: Ceci est obsolète depuis python 2.6. Vous devez maintenant utiliser subprocess.Popen. Voici l'exemple

import subprocess

p = subprocess.Popen("Your command", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()[0]
print p.split("\n")

Votre kilométrage peut varier, j'ai tenté de faire tourner @ senderle sur la solution de Vartec dans Windows sur Python 2.6.5, mais je recevais des erreurs et aucune autre solution n'a fonctionné. Mon erreur était: WindowsError: [Error 6] The handle is invalid.

J'ai trouvé que je devais assigner PIPE à chaque poignée pour qu'elle renvoie la sortie que j'attendais - ce qui suit a fonctionné pour moi.

import subprocess

def run_command(cmd):
    """given shell command, returns communication tuple of stdout and stderr"""
    return subprocess.Popen(cmd, 
                            stdout=subprocess.PIPE, 
                            stderr=subprocess.PIPE, 
                            stdin=subprocess.PIPE).communicate()

et appelez comme ceci, ( [0]obtient le premier élément du tuple, stdout):

run_command('tracert 11.1.0.1')[0]

Après avoir appris plus, je crois que j'ai besoin de ces arguments de pipe parce que je travaille sur un système personnalisé qui utilise différentes poignées, j'ai donc dû contrôler directement tous les std.

Pour arrêter les fenêtres contextuelles de la console (avec Windows), procédez comme suit:

def run_command(cmd):
    """given shell command, returns communication tuple of stdout and stderr"""
    # instantiate a startupinfo obj:
    startupinfo = subprocess.STARTUPINFO()
    # set the use show window flag, might make conditional on being in Windows:
    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    # pass as the startupinfo keyword argument:
    return subprocess.Popen(cmd,
                            stdout=subprocess.PIPE, 
                            stderr=subprocess.PIPE, 
                            stdin=subprocess.PIPE, 
                            startupinfo=startupinfo).communicate()

run_command('tracert 11.1.0.1')

J'avais une saveur légèrement différente du même problème avec les exigences suivantes:

1. Capturez et renvoyez les messages STDOUT à mesure qu'ils s'accumulent dans le tampon STDOUT (c'est-à-dire en temps réel).
   • @vartec a résolu ce problème en Python avec son utilisation de générateurs et le
     mot-clé 'yield' ci-dessus
2. Imprimer toutes les lignes STDOUT ( même si le processus se termine avant que le tampon STDOUT puisse être entièrement lu )
3. Ne perdez pas de cycles CPU à interroger le processus à haute fréquence
4. Vérifiez le code retour du sous-processus
5. Imprimez STDERR (distinct de STDOUT) si nous obtenons un code retour d'erreur non nul.

J'ai combiné et peaufiné les réponses précédentes pour arriver aux éléments suivants:

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 serait exécuté de la même manière que les réponses précédentes:

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

La division de la commande initiale pour le subprocesspeut être délicate et lourde.

Utilisez shlex.split()pour vous aider.

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...'

Sans shlex.split()le code se présenterait comme suit

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

Si vous devez exécuter une commande shell sur plusieurs fichiers, cela a fait l'affaire pour moi.

import os
import subprocess

# Define a function for running commands and capturing stdout line by line
# (Modified from Vartec's solution because it wasn't printing all lines)
def runProcess(exe):    
    p = subprocess.Popen(exe, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    return iter(p.stdout.readline, b'')

# Get all filenames in working directory
for filename in os.listdir('./'):
    # This command will be run on each file
    cmd = 'nm ' + filename

    # Run the command and capture the output line by line.
    for line in runProcess(cmd.split()):
        # Eliminate leading and trailing whitespace
        line.strip()
        # Split the output 
        output = line.split()

        # Filter the output and print relevant lines
        if len(output) > 2:
            if ((output[2] == 'set_program_name')):
                print filename
                print line

Edit: Je viens de voir la solution de Max Persson avec la suggestion de JF Sebastian. Avancé et incorporé cela.

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 si vous exécutiez la commande dans bash

Si vous utilisez le subprocessmodule python, vous pouvez gérer le STDOUT, le STDERR et renvoyer le code de commande séparément. Vous pouvez voir un exemple pour l'implémentation complète de l'appelant de commande. Bien sûr, vous pouvez l'étendre try..exceptsi vous le souhaitez.

La fonction ci-dessous renvoie le code STDOUT, STDERR et Return afin que vous puissiez les gérer dans l'autre script.

import subprocess

def command_caller(command=None)
    sp = subprocess.Popen(command, stderr=subprocess.PIPE, stdout=subprocess.PIPE, shell=False)
    out, err = sp.communicate()
    if sp.returncode:
        print(
            "Return code: %(ret_code)s Error message: %(err_msg)s"
            % {"ret_code": sp.returncode, "err_msg": err}
            )
    return sp.returncode, out, err

par exemple, exécuter ('ls -ahl') différencié trois / quatre retours possibles et plateformes OS:

1. aucune sortie, mais exécuté avec succès
2. sortie ligne vide, exécution réussie
3. échec de l'exécution
4. sortir quelque chose, exécuter avec succès

fonction ci-dessous

def execute(cmd, output=True, DEBUG_MODE=False):
"""Executes a bash command.
(cmd, output=True)
output: whether print shell output to screen, only affects screen display, does not affect returned values
return: ...regardless of output=True/False...
        returns shell output as a list with each elment is a line of string (whitespace stripped both sides) from output
        could be 
        [], ie, len()=0 --> no output;    
        [''] --> output empty line;     
        None --> error occured, see below

        if error ocurs, returns None (ie, is None), print out the error message to screen
"""
if not DEBUG_MODE:
    print "Command: " + cmd

    # https://stackoverflow.com/a/40139101/2292993
    def _execute_cmd(cmd):
        if os.name == 'nt' or platform.system() == 'Windows':
            # set stdin, out, err all to PIPE to get results (other than None) after run the Popen() instance
            p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        else:
            # Use bash; the default is sh
            p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, executable="/bin/bash")

        # the Popen() instance starts running once instantiated (??)
        # additionally, communicate(), or poll() and wait process to terminate
        # communicate() accepts optional input as stdin to the pipe (requires setting stdin=subprocess.PIPE above), return out, err as tuple
        # if communicate(), the results are buffered in memory

        # Read stdout from subprocess until the buffer is empty !
        # if error occurs, the stdout is '', which means the below loop is essentially skipped
        # A prefix of 'b' or 'B' is ignored in Python 2; 
        # it indicates that the literal should become a bytes literal in Python 3 
        # (e.g. when code is automatically converted with 2to3).
        # return iter(p.stdout.readline, b'')
        for line in iter(p.stdout.readline, b''):
            # # Windows has \r\n, Unix has \n, Old mac has \r
            # if line not in ['','\n','\r','\r\n']: # Don't print blank lines
                yield line
        while p.poll() is None:                                                                                                                                        
            sleep(.1) #Don't waste CPU-cycles
        # Empty STDERR buffer
        err = p.stderr.read()
        if p.returncode != 0:
            # responsible for logging STDERR 
            print("Error: " + str(err))
            yield None

    out = []
    for line in _execute_cmd(cmd):
        # error did not occur earlier
        if line is not None:
            # trailing comma to avoid a newline (by print itself) being printed
            if output: print line,
            out.append(line.strip())
        else:
            # error occured earlier
            out = None
    return out
else:
    print "Simulation! The command is " + cmd
    print ""

La sortie peut être redirigée vers un fichier texte, puis relue.

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))

vient d'écrire un petit script bash pour ce faire en utilisant curl

https://gist.github.com/harish2704/bfb8abece94893c53ce344548ead8ba5

#!/usr/bin/env bash

# Usage: gdrive_dl.sh <url>

urlBase='https://drive.google.com'
fCookie=tmpcookies

curl="curl -L -b $fCookie -c $fCookie"
confirm(){
    $curl "$1" | grep jfk-button-action | sed -e 's/.*jfk-button-action" href="\(\S*\)".*/\1/' -e 's/\&amp;/\&/g'
}

$curl -O -J "${urlBase}$(confirm $1)"