¿Hay una versión silenciosa de subprocess.call?

Question

¿Existe una variante de subprocess.call que pueda ejecutar el comando sin imprimir a la salida estándar, o una forma de bloquear su salida estándar?

Answer 1

Sí. Redirigir su stdout al /dev/null.

process = subprocess.call(["my", "command"], stdout=open(os.devnull, 'wb')) 

Answer 2

A menudo ese tipo de chatter está en stderr, por lo que también querrá silenciarlo. Aquí está mi ejemplo:

from subprocess import call, DEVNULL 
return_code = call(args, stderr=DEVNULL, stdout=DEVNULL) 

Nota:subprocess.DEVNULL está disponible desde Python 3.3. Si usted todavía está en Python 2:

import os 

with open(os.devnull, 'w') as shutup: 
    return_code = call(args, stdout=shutup, stderr=shutup) 

Answer 3

subprocess.call aceptan también redirecciones de la entrada estándar/stdout/stderr:

process = subprocess.call(["my", "command"], stdout=open(os.devnull, 'wb')) 

Answer 4

Esta es una receta que utilizo mucho: llamar subprocess y recoger la salida, y cuando el comando logra descartar la salida, pero cuando falla imprime la salida.

import subprocess as sp 
import sys 

if "print" in __builtins__.__dict__: 
    prn = __builtins__.__dict__["print"] 
else: 
    def prn(*args, **kwargs): 
     """ 
     prn(value, ..., sep=' ', end='\\n', file=sys.stdout) 
     Works just like the print function in Python 3.x but can be used in 2.x. 

     Prints the values to a stream, or to sys.stdout by default. 
     Optional keyword arguments: 
     file: a file-like object (stream); defaults to the current sys.stdout. 
     sep: string inserted between values, default a space. 
     end: string appended after the last value, default a newline. 
     """ 
     sep = kwargs.get("sep", ' ') 
     end = kwargs.get("end", '\n') 
     file = kwargs.get("file", sys.stdout) 

     s = sep.join(str(x) for x in args) + end 
     file.write(s) 


def rc_run_cmd_basic(lst_cmd, verbose=False, silent=False): 
    if silent and verbose: 
     raise ValueError("cannot specify both verbose and silent as true") 

    p = sp.Popen(lst_cmd, stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE) 
    tup_output = p.communicate() 

    s_cmd = ' '.join(lst_cmd) 
    if verbose: 
     prn() 
     prn("command: '%s'\n" % s_cmd) 

     if 0 != p.returncode: 
      prn() 
      prn("Command failed with code %d:" % p.returncode) 
     else: 
      prn("Command succeeded! code %d" % p.returncode) 
    if verbose: 
     prn("Output for: " + s_cmd) 
     prn(tup_output[0]) 
     prn() 
    if not silent and 0 != p.returncode: 
     prn("Error output for: " + s_cmd) 
     prn(tup_output[1]) 
     prn() 

    return p.returncode 

Answer 5

Utilizo subprocess.check_output en tales casos y elimino el valor de retorno. Es posible que desee agregar un comentario a su código que indique por qué está utilizando check_output en lugar de check_call. check_output también es más agradable cuando ocurre una falla y le interesa el resultado del error. Ejemplo de código a continuación. La salida se ve solo cuando descomenta la línea de impresión. Si el comando falla, se lanza una excepción.

import subprocess 
ret = subprocess.check_output(["cat", "/tmp/1"]) 
#print ret