python - example - Almacena la salida de subprocess.Popen call en una cadena

subprocess.check_output example python

Question

Estoy intentando hacer una llamada al sistema en Python y almacenar la salida en una cadena que puedo manipular en el programa de Python.

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

He intentado algunas cosas incluyendo algunas de las sugerencias aquí:

Recuperando la salida de subprocess.call ()

pero sin suerte.

Answer 1

Escribí una pequeña función basada en las otras respuestas aquí:

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

Uso:

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

Answer 2

Esto fue perfecto para mí. Obtendrá el código de retorno, stdout y stderr en una tupla.

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

Por ejemplo:

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

Answer 3

Esto funciona perfectamente para mi:

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

Answer 4

Esto me funcionó para redireccionar stdout (stderr puede manejarse de manera similar):

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

Si no funciona para usted, especifique exactamente el problema que tiene.

Answer 5

Suponiendo que pwd es solo un ejemplo, así es como puedes hacerlo:

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

Consulte la documentación del subproceso para ver otro ejemplo y más información.

Answer 6

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]

En el constructor de Popen, si el shell es True , debe pasar el comando como una cadena en lugar de una secuencia. De lo contrario, simplemente divide el comando en una lista:

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

Si necesita leer también el error estándar, en la inicialización de Popen, puede establecer stderr en subprocess.PIPE o subprocess.STDOUT :

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

Answer 7

En Python 2.7 o Python 3

En lugar de hacer un objeto Popen directamente, puede usar la función subprocess.check_output() para almacenar la salida de un comando en una cadena:

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

En Python 2.4-2.6

Utilice el método de communicate .

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

out es lo que quieres.

Nota importante sobre las otras respuestas.

Tenga en cuenta cómo pasé en el comando. El "ntpq -p" trae otro tema. Ya que Popen no invoca el shell, debería usar una lista del comando y las opciones— ["ntpq", "-p"] .

Answer 8

para Python 2.7+ la respuesta idiomática es usar subprocess.check_output()

También debe tener en cuenta el manejo de los argumentos al invocar un subproceso, ya que puede ser un poco confuso ...

Si args es solo un comando único sin argumentos propios (o si tiene shell=True set), puede ser una cadena. De lo contrario debe ser una lista.

por ejemplo ... para invocar el comando ls , esto está bien:

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

asi es esto:

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

sin embargo, si desea pasar algunos argumentos al comando de shell, no puede hacer esto:

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

en su lugar, debe pasarlo como una lista:

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

La función shlex.split() veces puede ser útil para dividir una cadena en una sintaxis similar a una shell antes de crear un subproceso ... como esto:

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

Answer 9

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

En este caso solo tendrá un elemento en la lista.