Python Language
सबप्रोसेस लाइब्रेरी

वाक्य - विन्यास

• subprocess.call (args, *, stdin = none, stdout = कोई नहीं, stderr = कोई नहीं, शेल = गलत, टाइमआउट = कोई नहीं)
• subprocess.Popen (args, bufsize = -1, निष्पादन योग्य = कोई नहीं, stdin = कोई नहीं, stdout = कोई नहीं, stderr = कोई नहीं, preexec_fn = कोई नहीं, close_fds = true, shell / False, cwd = कोई नहीं, env = कोई नहीं, Universal_newlines = गलत , स्टार्टअपइनफो = कोई नहीं, क्रिएफ़्लिफ़ैग्स = 0, रिस्टोर_साइनल्स = ट्रू, start_new_session = गलत, पास_फंड = ())

पैरामीटर

बाहरी कमानों को कॉल करना

सबसे सरल उपयोग मामला subprocess.call फ़ंक्शन का उपयोग कर रहा है। यह एक सूची को पहले तर्क के रूप में स्वीकार करता है। सूची में पहला आइटम वह बाहरी अनुप्रयोग होना चाहिए जिसे आप कॉल करना चाहते हैं। सूची में अन्य आइटम तर्क हैं जो उस एप्लिकेशन को पास किए जाएंगे।

subprocess.call([r'C:\path\to\app.exe', 'arg1', '--flag', 'arg'])

शेल कमांड के लिए, shell=True सेट करें shell=True और कमांड को सूची के बजाय स्ट्रिंग के रूप में प्रदान करें।

subprocess.call('echo "Hello, world"', shell=True)

ध्यान दें कि ऊपर दिए गए दो कमांड उपप्रकार की केवल exit status को लौटाते हैं। इसके अलावा, shell=True का उपयोग करते समय ध्यान दें shell=True क्योंकि यह सुरक्षा मुद्दे प्रदान करता है ( यहां देखें)।

यदि आप सबप्रोसेस का मानक आउटपुट प्राप्त करने में सक्षम होना चाहते हैं, तो subprocess.call साथ subprocess.check_output को subprocess.check_output । और अधिक उन्नत उपयोग के लिए, का उल्लेख इस ।

पोपेन के साथ अधिक लचीलापन

का उपयोग करते हुए subprocess.Popen से शुरू की प्रक्रियाओं पर दे अधिक कुशल नियंत्रण के subprocess.call ।

एक उपप्रकार का शुभारंभ

process = subprocess.Popen([r'C:\path\to\app.exe', 'arg1', '--flag', 'arg'])

Popen लिए हस्ताक्षर call फ़ंक्शन के समान है; हालांकि, call को पूरा करने के लिए Popen की प्रतीक्षा करने के बजाय Popen तुरंत वापस आ जाएगा।

एक उपप्रकार पर प्रतीक्षा करने के लिए पूरा करें

process = subprocess.Popen([r'C:\path\to\app.exe', 'arg1', '--flag', 'arg'])
process.wait()

सबप्रोसेस से आउटपुट पढ़ना

process = subprocess.Popen([r'C:\path\to\app.exe'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)

# This will block until process completes
stdout, stderr = process.communicate()
print stdout
print stderr

सबप्रोसेस चलाने के लिए इंटरएक्टिव एक्सेस

जब तक उपप्रकार पूरा नहीं होता तब भी आप stdin और stdout पर पढ़ और लिख सकते हैं। यह तब उपयोगी हो सकता है जब किसी अन्य प्रोग्राम में कार्यक्षमता को स्वचालित किया जाए।

एक उपप्रकार के लिए लेखन

process = subprocess.Popen([r'C:\path\to\app.exe'], stdout = subprocess.PIPE, stdin = subprocess.PIPE)


process.stdin.write('line of input\n') # Write input

line  = process.stdout.readline() # Read a line from stdout

# Do logic on line read.

हालाँकि, यदि आपको डायनामिक इंटरैक्शन के बजाय केवल इनपुट और आउटपुट के एक सेट की आवश्यकता है, तो आपको सीधे stdin और stdout तक पहुंचने के बजाय communicate() उपयोग करना चाहिए।

सबप्रोसेस से एक स्ट्रीम पढ़ना

यदि आप लाइन द्वारा सबप्रोसेस लाइन का आउटपुट देखना चाहते हैं, तो आप निम्न स्निपेट का उपयोग कर सकते हैं:

process = subprocess.Popen(<your_command>, stdout=subprocess.PIPE)
while process.poll() is None:
    output_line = process.stdout.readline()

यदि मामले में सबकमांड आउटपुट में ईओएल चरित्र नहीं है, तो उपरोक्त स्निपेट काम नहीं करता है। आप निम्नानुसार वर्ण द्वारा आउटपुट वर्ण पढ़ सकते हैं:

process = subprocess.Popen(<your_command>, stdout=subprocess.PIPE)
while process.poll() is None:
    output_line = process.stdout.read(1)

1 करने के लिए तर्क के रूप में निर्दिष्ट read विधि समय में 1 चरित्र को पढ़ने के लिए पढ़ने के लिए बताता है। आप एक अलग संख्या का उपयोग करके अपने इच्छित कई वर्णों को पढ़ना निर्दिष्ट कर सकते हैं। ईओएफ के सामने आने तक नकारात्मक संख्या या 0 को एक स्ट्रिंग के रूप में read लिए पढ़ना बताता है ( यहाँ देखें )।

उपर्युक्त दोनों स्निपेट्स में, सबप्रोसेस खत्म होने तक process.poll() None । यह लूप से बाहर निकलने के लिए उपयोग किया जाता है, क्योंकि पढ़ने के लिए अधिक आउटपुट नहीं है।

वही प्रक्रिया stderr के stderr पर लागू की जा सकती है।

कमांड लिस्ट तर्क कैसे बनाएं

उपप्रक्रम विधि जो कमांड चलाने की अनुमति देती है उसे सूची के रूप में कमांड की आवश्यकता होती है (कम से कम shell_mode=True का उपयोग करके)।

सूची बनाने के नियम हमेशा पालन करने के लिए सीधे नहीं होते हैं, खासकर जटिल आदेशों के साथ। सौभाग्य से, एक बहुत ही उपयोगी उपकरण है जो ऐसा करने की अनुमति देता है: shlex । कमांड के रूप में उपयोग की जाने वाली सूची बनाने का सबसे आसान तरीका निम्नलिखित है:

import shlex
cmd_to_subprocess = shlex.split(command_used_in_the_shell)

एक सरल उदाहरण:

import shlex
shlex.split('ls --color -l -t -r')

out: ['ls', '--color', '-l', '-t', '-r']