क्या subprocess.call का एक शांत संस्करण है?

Question

क्या subprocess.call का एक संस्करण है जो मानक आउटपुट के बिना प्रिंट किए बिना आदेश चला सकता है, या इसके मानक आउट संदेशों को अवरोधित करने का एक तरीका है?

Answer 1

हां। अपने stdout को /dev/null पर रीडायरेक्ट करें।

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

Answer 2

अक्सर उस तरह का बकवास stderr पर होता है, तो आप उसे भी चुप कर सकते हैं। यहाँ मेरी उदाहरण है:

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

नोट:subprocess.DEVNULL अजगर 3.3 के बाद से उपलब्ध है। आप अजगर 2 पर अभी भी कर रहे हैं:

import os 

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

Answer 3

subprocess.call भी stdin/stdout/stderr पुनर्निर्देशन स्वीकार करते हैं:

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

Answer 4

यह एक नुस्खा है मैं एक बहुत का उपयोग करें: subprocess फोन और आउटपुट एकत्रित करते हैं, और जब आदेश आउटपुट को त्यागने में सफल होता है, लेकिन जब यह आउटपुट प्रिंट करने में विफल रहता है।

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

मैं ऐसे मामलों में subprocess.check_output का उपयोग करता हूं और वापसी मूल्य छोड़ देता हूं। आप चेक कोड के स्थान पर check_output का उपयोग क्यों कर रहे हैं, यह बताते हुए आप अपना कोड टिप्पणी कर सकते हैं। विफलता होने पर check_output भी अच्छा होता है और आप त्रुटि आउटपुट में रूचि रखते हैं। नीचे उदाहरण कोड। आउटपुट केवल तभी देखा जाता है जब आप प्रिंट लाइन को असम्बद्ध करते हैं। यदि आदेश विफल रहता है, तो एक अपवाद फेंक दिया जाता है।

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