Speichern Sie die Ausgabe des Unterprozesses. Öffnen Sie den Aufruf in einer Zeichenfolge

Ich versuche, einen Systemaufruf in Python durchzuführen und die Ausgabe in einer Zeichenfolge zu speichern, die ich im Python-Programm bearbeiten kann.

#!/usr/bin/python
import subprocess
p2 = subprocess.Popen("ntpq -p")

Ich habe ein paar Dinge ausprobiert, einschließlich einiger Vorschläge hier:

Abrufen der Ausgabe von subprocess.call ()

aber ohne Glück.

In Python 2.7 oder Python 3

Anstatt ein PopenObjekt direkt zu erstellen, können Sie die subprocess.check_output()Funktion verwenden , um die Ausgabe eines Befehls in einer Zeichenfolge zu speichern:

from subprocess import check_output
out = check_output(["ntpq", "-p"])

In Python 2.4-2.6

Verwenden Sie die communicateMethode.

import subprocess
p = subprocess.Popen(["ntpq", "-p"], stdout=subprocess.PIPE)
out, err = p.communicate()

out ist was du willst.

Wichtiger Hinweis zu den anderen Antworten

Beachten Sie, wie ich den Befehl übergeben habe. Das "ntpq -p"Beispiel bringt eine andere Sache auf. Da Popendie Shell nicht aufgerufen wird, würden Sie eine Liste der Befehle und Optionen verwenden ["ntpq", "-p"].

Dies funktionierte bei mir für die Umleitung von stdout (stderr kann ähnlich behandelt werden):

from subprocess import Popen, PIPE
pipe = Popen(path, stdout=PIPE)
text = pipe.communicate()[0]

Wenn es bei Ihnen nicht funktioniert, geben Sie bitte genau das Problem an, das Sie haben.

Angenommen, dies pwdist nur ein Beispiel, so können Sie es tun:

import subprocess

p = subprocess.Popen("pwd", stdout=subprocess.PIPE)
result = p.communicate()[0]
print result

Ein weiteres Beispiel und weitere Informationen finden Sie in der Dokumentation zum Unterprozess .

subprocess.Popen: http://docs.python.org/2/library/subprocess.html#subprocess.Popen

import subprocess

command = "ntpq -p"  # the shell command
process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=None, shell=True)

#Launch the shell command:
output = process.communicate()

print output[0]

Im Popen Konstruktor, wenn Shell ist wahr , sollten Sie den Befehl als String und nicht als Folge passieren. Andernfalls teilen Sie den Befehl einfach in eine Liste auf:

command = ["ntpq", "-p"]  # the shell command
process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=None)

Wenn Sie auch den Standardfehler in die Popen-Initialisierung einlesen müssen, können Sie stderr auf subprocess.PIPE oder subprocess.STDOUT setzen :

import subprocess

command = "ntpq -p"  # the shell command
process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)

#Launch the shell command:
output, error = process.communicate()

Für Python 2.7+ lautet die idiomatische Antwort: subprocess.check_output()

Sie sollten auch die Behandlung von Argumenten beim Aufrufen eines Unterprozesses beachten, da dies etwas verwirrend sein kann.

Wenn args nur ein einzelner Befehl ohne eigene Argumente ist (oder Sie festgelegt haben shell=True), kann es sich um eine Zeichenfolge handeln. Ansonsten muss es eine Liste sein.

Zum Beispiel ... um den lsBefehl aufzurufen , ist dies in Ordnung:

from subprocess import check_call
check_call('ls')

also das ist:

from subprocess import check_call
check_call(['ls',])

Wenn Sie jedoch einige Argumente an den Shell-Befehl übergeben möchten, können Sie dies nicht tun:

from subprocess import check_call
check_call('ls -al')

Stattdessen müssen Sie es als Liste übergeben:

from subprocess import check_call
check_call(['ls', '-al'])

Die shlex.split()Funktion kann manchmal nützlich sein, um einen String in eine Shell-ähnliche Syntax aufzuteilen, bevor Unterprozesse erstellt werden ... wie folgt:

from subprocess import check_call
import shlex
check_call(shlex.split('ls -al'))

Das funktioniert perfekt für mich:

import subprocess
try:
    #prints results and merges stdout and std
    result = subprocess.check_output("echo %USERNAME%", stderr=subprocess.STDOUT, shell=True)
    print result
    #causes error and merges stdout and stderr
    result = subprocess.check_output("copy testfds", stderr=subprocess.STDOUT, shell=True)
except subprocess.CalledProcessError, ex: # error code <> 0 
    print "--------error------"
    print ex.cmd
    print ex.message
    print ex.returncode
    print ex.output # contains stdout and stderr together 

Das war perfekt für mich. Sie erhalten den Rückkehrcode stdout und stderr in einem Tupel.

from subprocess import Popen, PIPE

def console(cmd):
    p = Popen(cmd, shell=True, stdout=PIPE)
    out, err = p.communicate()
    return (p.returncode, out, err)

Beispielsweise:

result = console('ls -l')
print 'returncode: %s' % result[0]
print 'output: %s' % result[1]
print 'error: %s' % result[2]

Die akzeptierte Antwort ist immer noch gut, nur ein paar Anmerkungen zu neueren Funktionen. Da Python 3.6, können Sie kodieren , direkt in Griff check_output, siehe Dokumentation . Dies gibt jetzt ein String-Objekt zurück:

import subprocess 
out = subprocess.check_output(["ls", "-l"], encoding="utf-8")

In Python 3.7 capture_outputwurde subprocess.run () ein Parameter hinzugefügt, der einen Teil der Popen / PIPE-Behandlung für uns übernimmt. Weitere Informationen finden Sie in den Python-Dokumenten :

import subprocess 
p2 = subprocess.run(["ls", "-l"], capture_output=True, encoding="utf-8")
p2.stdout

 import os   
 list = os.popen('pwd').read()

In diesem Fall haben Sie nur ein Element in der Liste.

Ich habe eine kleine Funktion geschrieben, die auf den anderen Antworten hier basiert:

def pexec(*args):
    return subprocess.Popen(args, stdout=subprocess.PIPE).communicate()[0].rstrip()

Verwendungszweck:

changeset = pexec('hg','id','--id')
branch = pexec('hg','id','--branch')
revnum = pexec('hg','id','--num')
print('%s : %s (%s)' % (revnum, changeset, branch))

In Python 3.7 wurde ein neues Schlüsselwortargument capture_outputfür eingeführt subprocess.run. Kurz und einfach aktivieren:

import subprocess

p = subprocess.run("echo 'hello world!'", capture_output=True, shell=True, encoding="utf8")
assert p.stdout == 'hello world!\n'

import subprocess
output = str(subprocess.Popen("ntpq -p",shell = True,stdout = subprocess.PIPE, 
stderr = subprocess.STDOUT).communicate()[0])

Dies ist eine einzeilige Lösung

Im Folgenden werden stdout und stderr des Prozesses in einer einzelnen Variablen erfasst. Es ist Python 2 und 3 kompatibel:

from subprocess import check_output, CalledProcessError, STDOUT

command = ["ls", "-l"]
try:
    output = check_output(command, stderr=STDOUT).decode()
    success = True 
except CalledProcessError as e:
    output = e.output.decode()
    success = False

Wenn Ihr Befehl eher eine Zeichenfolge als ein Array ist, stellen Sie Folgendes voran:

import shlex
command = shlex.split(command)

Für Python 3.5 habe ich eine Funktion basierend auf der vorherigen Antwort eingerichtet. Protokoll kann entfernt werden, fand es schön zu haben

import shlex
from subprocess import check_output, CalledProcessError, STDOUT


def cmdline(command):
    log("cmdline:{}".format(command))
    cmdArr = shlex.split(command)
    try:
        output = check_output(cmdArr,  stderr=STDOUT).decode()
        log("Success:{}".format(output))
    except (CalledProcessError) as e:
        output = e.output.decode()
        log("Fail:{}".format(output))
    except (Exception) as e:
        output = str(e);
        log("Fail:{}".format(e))
    return str(output)


def log(msg):
    msg = str(msg)
    d_date = datetime.datetime.now()
    now = str(d_date.strftime("%Y-%m-%d %H:%M:%S"))
    print(now + " " + msg)
    if ("LOG_FILE" in globals()):
        with open(LOG_FILE, "a") as myfile:
            myfile.write(now + " " + msg + "\n")

Verwenden Sie die ckeck_outputMethode vonsubprocess

import subprocess
address = 192.168.x.x
res = subprocess.check_output(['ping', address, '-c', '3'])

Zum Schluss analysieren Sie die Zeichenfolge

for line in res.splitlines():

Hoffe es hilft, fröhliche Codierung