Czy istnieje cicha wersja podprocesu?

Question

Czy istnieje wersja subprocess.call, która może uruchomić polecenie bez drukowania na standardowe wyjście, lub sposób blokowania jego standardowych wiadomości wyjściowych?

Answer 1

Tak. Przekieruj jego stdout do /dev/null.

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

Answer 2

Często ten rodzaj pogawędki jest na stderr, więc możesz też chcieć to uciszyć. Oto mój przykład:

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

Uwaga:subprocess.DEVNULL jest dostępny od Pythona 3.3. Jeśli nadal na Pythonie 2:

import os 

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

Answer 3

subprocess.call przyjąć również przekierowań stdin/stdout/stderr:

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

Answer 4

Jest to przepis używam dużo: Call subprocess i zebrać dane wyjściowe, a gdy polecenie powiedzie się odrzucić dane wyjściowe, ale gdy się nie powiedzie wydrukuj dane wyjściowe.

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

Używam podprocesów.check_output w takich przypadkach i upuść wartość zwracaną. Możesz dodać komentarz do swojego kodu stwierdzającego, dlaczego używasz check_output zamiast check_call. check_output jest również ładniejszy, gdy wystąpi awaria i jesteś zainteresowany wyjściem błędu. Przykładowy kod poniżej. Dane wyjściowe są widoczne tylko po odkomentowaniu linii drukowania. Jeśli polecenie nie powiedzie się, zostanie zgłoszony wyjątek.

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