python - पायथन में बाहरी कमांड को कॉल करना




shell command (20)

पायथन में बाहरी कमांड को कॉल करना

सरल, subprocess.run उपयोग करें, जो एक CompletedProcess subprocess.run ऑब्जेक्ट देता है:

>>> import subprocess
>>> completed_process = subprocess.run('python --version')
Python 3.6.1 :: Anaconda 4.4.0 (64-bit)
>>> completed_process
CompletedProcess(args='python --version', returncode=0)

क्यूं कर?

पायथन 3.5 के रूप में, प्रलेखन subprocess.run की सिफारिश करता है:

Subprocesses का आह्वान करने के लिए अनुशंसित दृष्टिकोण सभी उपयोग मामलों के लिए रन () फ़ंक्शन का उपयोग करना है जो इसे संभाल सकता है। अधिक उन्नत उपयोग मामलों के लिए, अंतर्निहित पॉपन इंटरफ़ेस का उपयोग सीधे किया जा सकता है।

यहां सबसे आसान संभव उपयोग का एक उदाहरण दिया गया है - और यह ठीक वैसे ही किया गया है:

>>> import subprocess
>>> completed_process = subprocess.run('python --version')
Python 3.6.1 :: Anaconda 4.4.0 (64-bit)
>>> completed_process
CompletedProcess(args='python --version', returncode=0)

run सफलतापूर्वक समाप्त करने के लिए आदेश के लिए इंतजार कर रहा है, फिर एक CompletedProcess ऑब्जेक्ट देता है। इसके बजाय यह timeout= CalledProcessError बढ़ा सकता है (यदि आप इसे timeout= तर्क देते हैं) या CalledProcessError (यदि यह विफल हो जाता है और आप check=True पास करते हैं)।

जैसा कि आप उपरोक्त उदाहरण से अनुमान लगा सकते हैं, stdout और stderr दोनों डिफ़ॉल्ट रूप से अपने स्वयं के stdout और stderr पर पाइप हो जाते हैं।

हम लौटे ऑब्जेक्ट का निरीक्षण कर सकते हैं और दिए गए आदेश को देख सकते हैं और रिटर्नकोड:

>>> completed_process.args
'python --version'
>>> completed_process.returncode
0

आउटपुट कैप्चरिंग

यदि आप आउटपुट कैप्चर करना चाहते हैं, तो आप subprocess.PIPE को उचित stderr या stdout पास कर सकते हैं:

>>> cp = subprocess.run('python --version', 
                        stderr=subprocess.PIPE, 
                        stdout=subprocess.PIPE)
>>> cp.stderr
b'Python 3.6.1 :: Anaconda 4.4.0 (64-bit)\r\n'
>>> cp.stdout
b''

(मुझे यह दिलचस्प और थोड़ा सा counterintuitive लगता है कि संस्करण जानकारी stdout के बजाय stderr में डाल दिया जाता है।)

एक कमांड सूची पास करें

प्रोग्रामिंग रूप से निर्मित एक स्ट्रिंग प्रदान करने के लिए कोई आसानी से कमांड स्ट्रिंग (जैसे प्रश्न सुझाता है) प्रदान करने से मैन्युअल रूप से स्थानांतरित हो सकता है। प्रोग्रामिंग के तारों का निर्माण न करें। यह एक संभावित सुरक्षा मुद्दा है। यह मानना ​​बेहतर है कि आप इनपुट पर भरोसा नहीं करते हैं।

>>> import textwrap
>>> args = ['python', textwrap.__file__]
>>> cp = subprocess.run(args, stdout=subprocess.PIPE)
>>> cp.stdout
b'Hello there.\r\n  This is indented.\r\n'

नोट, केवल args को स्थिति में पारित किया जाना चाहिए।

पूर्ण हस्ताक्षर

यहां स्रोत में वास्तविक हस्ताक्षर है और जैसा कि help(run) द्वारा दिखाया गया है:

def run(*popenargs, input=None, timeout=None, check=False, **kwargs):

popenargs और kwargs Popen कन्स्ट्रक्टर को दिया जाता है। input बाइट्स की एक स्ट्रिंग हो सकती है (या यूनिकोड, यदि एन्कोडिंग या universal_newlines=True निर्दिष्ट करें) जो सबप्रोसेस के स्टडीन को पाइप किया जाएगा।

दस्तावेज timeout= और check=True बेहतर है कि मैं कर सकता है:

टाइमआउट तर्क Popen.communicate () को पास किया जाता है। यदि टाइमआउट समाप्त हो जाता है, तो बच्चे की प्रक्रिया मारे जायेगी और इसके लिए इंतजार किया जाएगा। बाल प्रक्रिया समाप्त होने के बाद टाइमआउट एक्स्पेरड अपवाद फिर से उठाया जाएगा।

यदि चेक सही है, और प्रक्रिया गैर-शून्य निकास कोड से निकलती है, तो कॉलडप्रोसेसर अपवाद उठाया जाएगा। उस अपवाद के गुणों पर तर्क, निकास कोड, और stdout और stderr पकड़ लिया गया है अगर वे कब्जा कर लिया गया था।

और check=True लिए यह उदाहरण एक से बेहतर है जिसके साथ मैं आ सकता हूं:

>>> subprocess.run("exit 1", shell=True, check=True)
Traceback (most recent call last):
  ...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1

विस्तारित हस्ताक्षर

दस्तावेज़ीकरण में दिए गए अनुसार विस्तृत विस्तार यहां दिया गया है:

subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, 
shell=False, cwd=None, timeout=None, check=False, encoding=None, 
errors=None)

ध्यान दें कि यह इंगित करता है कि केवल तर्क सूची को स्थिति में पारित किया जाना चाहिए। तो शेष तर्कों को कीवर्ड तर्क के रूप में पास करें।

popen

इसके बजाए Popen उपयोग कब करें?मैं अकेले तर्कों के आधार पर उपयोग-केस खोजने के लिए संघर्ष करूंगा। Popenहालांकि, इसका प्रत्यक्ष उपयोग आपको poll'send_signal', 'terminate', और 'प्रतीक्षा' सहित , इसके तरीकों तक पहुंच प्रदान करेगा ।

स्रोतPopen में दिए गए हस्ताक्षर यहां दिए गए हैं । मुझे लगता है कि यह जानकारी का सबसे सटीक encapsulation है (के विपरीत ):help(Popen)

def __init__(self, args, bufsize=-1, executable=None,
             stdin=None, stdout=None, stderr=None,
             preexec_fn=None, close_fds=_PLATFORM_DEFAULT_CLOSE_FDS,
             shell=False, cwd=None, env=None, universal_newlines=False,
             startupinfo=None, creationflags=0,
             restore_signals=True, start_new_session=False,
             pass_fds=(), *, encoding=None, errors=None):

लेकिन अधिक सूचनात्मक है प्रलेखन :Popen

subprocess.Popen(args, bufsize=-1, executable=None, stdin=None,
                 stdout=None, stderr=None, preexec_fn=None, close_fds=True,
                 shell=False, cwd=None, env=None, universal_newlines=False,
                 startupinfo=None, creationflags=0, restore_signals=True,
                 start_new_session=False, pass_fds=(), *, encoding=None, errors=None)

एक नई प्रक्रिया में एक बाल कार्यक्रम निष्पादित करें। POSIX पर, कक्षा os.execvp () - बच्चे प्रोग्राम को निष्पादित करने के लिए व्यवहार की तरह उपयोग करती है। विंडोज़ पर, कक्षा विंडोज CreateProcess () फ़ंक्शन का उपयोग करती है। इस प्रकार Popen के लिए तर्क हैं।

शेष दस्तावेज को समझना Popenपाठक के लिए एक अभ्यास के रूप में छोड़ा जाएगा।

https://code.i-harness.com

मैं एक पाइथन स्क्रिप्ट के भीतर से बाहरी आदेश (जैसे कि मैं इसे यूनिक्स शैल या विंडोज कमांड प्रॉम्प्ट पर टाइप कर सकता हूं) कैसे कॉल कर सकता हूं?


अद्यतन करें:

subprocess.run पाइथन 3.5 के रूप में अनुशंसित दृष्टिकोण है यदि आपके कोड को पहले पायथन संस्करणों के साथ संगतता बनाए रखने की आवश्यकता नहीं है। यह अधिक सुसंगत है और दूत के रूप में उपयोग के समान उपयोग प्रदान करता है। (पिपिंग हालांकि सीधा नहीं है। इस सवाल को कैसे देखें।)

दस्तावेज़ों से कुछ उदाहरण यहां दिए गए हैं।

एक प्रक्रिया चलाएं:

>>> subprocess.run(["ls", "-l"])  # doesn't capture output
CompletedProcess(args=['ls', '-l'], returncode=0)

असफल रन पर उठाएं:

>>> subprocess.run("exit 1", shell=True, check=True)
Traceback (most recent call last):
  ...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1

कैप्चर आउटपुट:

>>> subprocess.run(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE)
CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,
stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\n')

मूल उत्तर:

मैं https://github.com/kennethreitz/envoy की कोशिश करने की सलाह देते हैं। यह उपप्रोसेसर के लिए एक रैपर है, जो बदले में पुराने मॉड्यूल और कार्यों को प्रतिस्थापित करना है । दूत मनुष्यों के लिए उपप्रोसेसर है।

रीडेमे से उदाहरण उपयोग:

>>> r = envoy.run('git config', data='data to pipe in', timeout=2)

>>> r.status_code
129
>>> r.std_out
'usage: git config [options]'
>>> r.std_err
''

पाइप सामान भी चारों ओर:

>>> r = envoy.run('uptime | pbcopy')

>>> r.command
'pbcopy'
>>> r.status_code
0

>>> r.history
[<Response 'uptime'>]

"Pexpect" पायथन पुस्तकालय भी देखें।

यह बाहरी कार्यक्रमों / आदेशों, यहां तक ​​कि एसएसएच, एफटीपी, टेलनेट इत्यादि के इंटरैक्टिव नियंत्रण की अनुमति देता है। आप बस कुछ टाइप कर सकते हैं:

child = pexpect.spawn('ftp 192.168.0.24')

child.expect('(?i)name .*: ')

child.sendline('anonymous')

child.expect('(?i)password')

अगर आपको कॉल करने वाले कमांड से आउटपुट की आवश्यकता है, तो आप subprocess.check_output (पायथन 2.7+) का उपयोग कर सकते हैं।

>>> subprocess.check_output(["ls", "-l", "/dev/null"])
'crw-rw-rw- 1 root root 1, 3 Oct 18  2007 /dev/null\n'

shell पैरामीटर भी ध्यान दें।

यदि खोल True , निर्दिष्ट आदेश खोल के माध्यम से निष्पादित किया जाएगा। यह उपयोगी हो सकता है यदि आप मुख्य रूप से उन्नत नियंत्रण प्रवाह के लिए पाइथन का उपयोग कर रहे हैं जो इसे अधिकांश सिस्टम शैल पर प्रदान करता है और फिर भी शैल पाइप, फ़ाइल नाम वाइल्डकार्ड, पर्यावरण परिवर्तनीय विस्तार, और उपयोगकर्ता के घर में विस्तार के लिए अन्य शैल सुविधाओं तक सुविधाजनक पहुंच चाहते हैं निर्देशिका। हालांकि, ध्यान दें कि पायथन स्वयं कई शैल-जैसी सुविधाओं (विशेष रूप से, glob , fnmatch , os.walk() , os.path.expandvars() , os.path.expanduser() , और shutil ) के shutil


उपयोग:

import os

cmd = 'ls -al'

os.system(cmd)

ओएस - यह मॉड्यूल ऑपरेटिंग सिस्टम-निर्भर कार्यक्षमता का उपयोग करने का एक पोर्टेबल तरीका प्रदान करता है।

अधिक os कार्यों के लिए, here प्रलेखन है।


कई अलग-अलग पुस्तकालय हैं जो आपको बाहरी आदेशों को पायथन के साथ कॉल करने की अनुमति देते हैं। प्रत्येक लाइब्रेरी के लिए मैंने एक विवरण दिया है और बाहरी कमांड को कॉल करने का एक उदाहरण दिखाया है। उदाहरण के रूप में उपयोग किया गया आदेश ls -l (सभी फ़ाइलों को सूचीबद्ध करें)। यदि आप किसी भी पुस्तकालयों के बारे में और जानना चाहते हैं जो मैंने सूचीबद्ध किया है और उनमें से प्रत्येक के लिए प्रलेखन को लिंक किया है।

सूत्रों का कहना है:

ये सभी पुस्तकालय हैं:

उम्मीद है कि इससे आपको निर्णय लेने में मदद मिलेगी कि किस लाइब्रेरी का उपयोग करना है :)

उपप्रक्रिया

Subprocess आपको बाहरी आदेशों को कॉल करने और उन्हें अपने इनपुट / आउटपुट / त्रुटि पाइप (stdin, stdout, और stderr) से कनेक्ट करने की अनुमति देता है। सबप्रोसेस कमांड चलाने के लिए डिफ़ॉल्ट विकल्प है, लेकिन कभी-कभी अन्य मॉड्यूल बेहतर होते हैं।

subprocess.run(["ls", "-l"]) # Run command
subprocess.run(["ls", "-l"], stdout=subprocess.PIPE) # This will run the command and return any output
subprocess.run(shlex.split("ls -l")) # You can also use the shlex library to split the command

ओएस

ओएस का उपयोग "ऑपरेटिंग सिस्टम निर्भर कार्यक्षमता" के लिए किया जाता है। इसका उपयोग os.system और os.popen साथ बाहरी कमांड को कॉल करने के लिए भी किया जा सकता है (नोट: एक subprocess.popen भी है)। os हमेशा खोल चलाएंगे और उन लोगों के लिए एक साधारण विकल्प है जिन्हें subprocess.run का उपयोग करने की आवश्यकता नहीं है, या नहीं जानते हैं।

os.system("ls -l") # run command
os.popen("ls -l").read() # This will run the command and return any output

sh एक सबप्रोसेस इंटरफेस है जो आपको प्रोग्राम्स को कॉल करने देता है जैसे कि वे कार्य थे। यह उपयोगी है अगर आप कई बार कमांड चलाने के लिए चाहते हैं।

sh.ls("-l") # Run command normally
ls_cmd = sh.Command("ls") # Save command as a variable
ls_cmd() # Run command as if it were a function

सीसा

प्लंबम "स्क्रिप्ट-जैसे" पायथन प्रोग्राम के लिए एक लाइब्रेरी है। आप प्रोग्राम जैसे कार्यक्रमों को sh रूप में कॉल कर सकते हैं। यदि आप खोल के बिना पाइपलाइन चलाने के लिए प्लंबम उपयोगी है।

ls_cmd = plumbum.local("ls -l") # get command
ls_cmd() # run command

pexpect

pexpect आपको बच्चों के अनुप्रयोगों को जन्म देने, उन्हें नियंत्रित करने और उनके आउटपुट में पैटर्न खोजने देता है। यह उन आदेशों के लिए उपप्रोसेसर का बेहतर विकल्प है जो यूनिक्स पर एक टीटी की अपेक्षा करते हैं।

pexpect.run("ls -l") # Run command as normal
child = pexpect.spawn('scp foo [email protected]:.') # Spawns child application
child.expect('Password:') # When this is the output
child.sendline('mypassword')

कपड़ा

कपड़े एक पाइथन 2.5 और 2.7 पुस्तकालय है। यह आपको स्थानीय और रिमोट खोल कमांड निष्पादित करने की अनुमति देता है। एक सुरक्षित खोल (एसएसएच) में आदेश चलाने के लिए फैब्रिक सरल विकल्प है

fabric.operations.local('ls -l') # Run command as normal
fabric.operations.local('ls -l', capture = True) # Run command and receive output

दूत

दूत को "मनुष्यों के लिए उपप्रजाय" के रूप में जाना जाता है। यह subprocess मॉड्यूल के आसपास एक सुविधा wrapper के रूप में प्रयोग किया जाता है।

r = envoy.run("ls -l") # Run command
r.std_out # get output

आदेशों

commands में os.popen लिए रैपर फ़ंक्शन शामिल हैं, लेकिन इसे पायथन 3 से हटा दिया गया है क्योंकि os.popen एक बेहतर विकल्प है।

संपादन जेएफ सेबेस्टियन की टिप्पणी पर आधारित था।


परिणाम के आउटपुट के बिना:

import os
os.system("your command here")

परिणाम के आउटपुट के साथ:

import commands
commands.getoutput("your command here")
or
commands.getstatusoutput("your command here")

बाहरी कार्यक्रमों और प्रत्येक के फायदे और नुकसान कहने के तरीकों का सारांश यहां दिया गया है:

  1. os.system("some_command with args") आपके सिस्टम के खोल में कमांड और तर्क पास करता है। यह अच्छा है क्योंकि आप वास्तव में इस तरह से एक से अधिक कमांड चला सकते हैं और पाइप और इनपुट / आउटपुट रीडायरेक्शन सेट कर सकते हैं। उदाहरण के लिए:

    os.system("some_command < input_file | another_command > output_file")  
    

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

  2. stream = os.popen("some_command with args") के समान ही काम os.system सिवाय इसके कि यह आपको एक फ़ाइल जैसी ऑब्जेक्ट देता है जिसका उपयोग आप उस प्रक्रिया के लिए मानक इनपुट / आउटपुट तक पहुंचने के लिए कर सकते हैं। पॉपन के 3 अन्य प्रकार हैं जो सभी I / o को थोड़ा अलग तरीके से संभालते हैं। यदि आप सब कुछ एक स्ट्रिंग के रूप में पास करते हैं, तो आपका आदेश खोल को पास कर दिया जाता है; यदि आप उन्हें एक सूची के रूप में पास करते हैं तो आपको कुछ भी बचने की चिंता करने की आवश्यकता नहीं है। दस्तावेज देखें।

  3. Popen मॉड्यूल की Popen कक्षा। यह os.popen प्रतिस्थापन के रूप में है, लेकिन इतना व्यापक होने के कारण थोड़ा और जटिल होने का नकारात्मक पक्ष है। उदाहरण के लिए, आप कहेंगे:

    print subprocess.Popen("echo Hello World", shell=True, stdout=subprocess.PIPE).stdout.read()
    

    के बजाय:

    print os.popen("echo Hello World").read()
    

    लेकिन 4 अलग-अलग पॉपन कार्यों के बजाय एक एकीकृत वर्ग में सभी विकल्पों को रखना अच्छा लगता है। दस्तावेज देखें।

  4. subprocess मॉड्यूल से call फ़ंक्शन। यह मूल रूप से Popen क्लास की तरह है और सभी समान तर्क लेता है, लेकिन यह आदेश पूरा होने तक बस प्रतीक्षा करता है और आपको रिटर्न कोड देता है। उदाहरण के लिए:

    return_code = subprocess.call("echo Hello World", shell=True)  
    

    दस्तावेज देखें।

  5. यदि आप पाइथन 3.5 या बाद में हैं, तो आप नए subprocess.run फ़ंक्शन का उपयोग कर सकते हैं, जो उपर्युक्त की तरह बहुत अधिक है लेकिन यहां तक ​​कि अधिक लचीला है और कमांड निष्पादित करने पर CompletedProcess ऑब्जेक्ट देता है।

  6. ओएस मॉड्यूल में आपके पास एक सी प्रोग्राम में सभी कांटा / निष्पादन / स्पॉन फ़ंक्शन भी होते हैं, लेकिन मैं उन्हें सीधे उपयोग करने की अनुशंसा नहीं करता हूं।

subprocess मॉड्यूल शायद आपके द्वारा उपयोग किए जाने वाले हो।

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

print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read()

और कल्पना करें कि उपयोगकर्ता प्रवेश करता है "मेरी माँ ने मुझे प्यार नहीं किया और & rm -rf /"।


मैं os.system के बजाय उपप्रोसेसर मॉड्यूल का उपयोग करने की अनुशंसा करता हूं क्योंकि यह आपके लिए खोलने से खोलता है और इसलिए यह अधिक सुरक्षित है: http://docs.python.org/library/subprocess.html

subprocess.call(['ping', 'localhost'])

मैं आमतौर पर उपयोग करता हूं:

import subprocess

p = subprocess.Popen('ls', shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
for line in p.stdout.readlines():
    print line,
retval = p.wait()

आप पाइप में stdout डेटा के साथ जो चाहते हैं उसे करने के लिए स्वतंत्र हैं। वास्तव में, आप बस उन पैरामीटर ( stdout= और stderr= ) को छोड़ सकते हैं और यह os.system() तरह व्यवहार os.system()


यह आसान हो सकता है:

import os
cmd = "your command"
os.system(cmd)

Plumbum भी है

>>> from plumbum import local
>>> ls = local["ls"]
>>> ls
LocalCommand(<LocalPath /bin/ls>)
>>> ls()
u'build.py\ndist\ndocs\nLICENSE\nplumbum\nREADME.rst\nsetup.py\ntests\ntodo.txt\n'
>>> notepad = local["c:\\windows\\notepad.exe"]
>>> notepad()                                   # Notepad window pops up
u''                                             # Notepad window is closed by user, command returns

os.system ठीक है, लेकिन दिनांकित है। यह भी बहुत सुरक्षित नहीं है। इसके बजाय, subprocess कोशिश करें। subprocess सीधे sh कॉल नहीं करता है और इसलिए os.system से अधिक सुरक्षित है।

here अधिक जानकारी प्राप्त here


os.systemआपको परिणामों को स्टोर करने की अनुमति नहीं देता है, इसलिए यदि आप कुछ सूची या कुछ subprocess.callकामों में परिणाम स्टोर करना चाहते हैं ।


आप पॉपन का उपयोग कर सकते हैं, और फिर आप प्रक्रिया की स्थिति की जांच कर सकते हैं:

from subprocess import Popen

proc = Popen(['ls', '-l'])
if proc.poll() is None:
    proc.kill()

की जाँच करें subprocess.Popen


यहां एक और अंतर है जिसका पहले उल्लेख नहीं किया गया है।

subprocess.Popenएक कमप्रोसेस के रूप में <command> निष्पादित करता है। मेरे मामले में, मुझे फ़ाइल <a> को निष्पादित करने की आवश्यकता है जिसे किसी अन्य प्रोग्राम के साथ संवाद करने की आवश्यकता है, <b>।

मैंने उपप्रजाय की कोशिश की, और निष्पादन सफल रहा। हालांकि <b> <a> के साथ संवाद नहीं कर सका। जब मैं टर्मिनल से दोनों चलाता हूं तो सबकुछ सामान्य होता है।

एक और: (नोट: kwrite अन्य अनुप्रयोगों से अलग व्यवहार करता है। यदि आप नीचे फ़ायरफ़ॉक्स के साथ प्रयास करते हैं, तो परिणाम समान नहीं होंगे।)

यदि आप कोशिश करते हैं os.system("kwrite"), तो प्रोग्राम प्रवाह तब तक जम जाता है जब तक कि उपयोगकर्ता kwrite को बंद नहीं करता। उस पर काबू पाने के लिए मैंने कोशिश की os.system(konsole -e kwrite)। इस बार कार्यक्रम जारी रहा, लेकिन kwrite कंसोल की उपप्रोसेसर बन गया।

कोई भी kwrite एक subprocess नहीं है (यानी सिस्टम मॉनीटर में यह पेड़ के बाएं किनारे पर दिखाई देना चाहिए)।


मैं इसकी सादगी के लिए shell_command तरह काफी पसंद करता shell_command । यह उपप्रोसेसर मॉड्यूल के शीर्ष पर बनाया गया है।

दस्तावेज़ों का एक उदाहरण यहां दिया गया है:

>>> from shell_command import shell_call
>>> shell_call("ls *.py")
setup.py  shell_command.py  test_shell_command.py
0
>>> shell_call("ls -l *.py")
-rw-r--r-- 1 ncoghlan ncoghlan  391 2011-12-11 12:07 setup.py
-rw-r--r-- 1 ncoghlan ncoghlan 7855 2011-12-11 16:16 shell_command.py
-rwxr-xr-x 1 ncoghlan ncoghlan 8463 2011-12-11 16:17 test_shell_command.py
0

मैं का उपयोग करते हैं उपप्रक्रिया के साथ एक साथ shlex (उद्धृत तार के भागने को संभालने के लिए):

>>> import subprocess, shlex
>>> command = 'ls -l "/your/path/with spaces/"'
>>> call_params = shlex.split(command)
>>> print call_params
["ls", "-l", "/your/path/with spaces/"]
>>> subprocess.call(call_params)

विंडोज़ में आप बस subprocessमॉड्यूल आयात कर सकते हैं और कॉल करके बाहरी कमांड चला सकते हैं subprocess.Popen(), subprocess.Popen().communicate()और subprocess.Popen().wait()नीचे दिए गए हैं:

+--------------------------------------+------------+------+
| ID                                   | Label      | CIDR |
+--------------------------------------+------------+------+
| 431c9014-5b5d-4b51-a357-66020ffbb123 | test1      | None |
| 27a74fcd-37c0-4789-9414-9531b7e3f126 | External   | None |
| 5a2712e9-70dc-4b0e-9281-17e02f4684c9 | management | None |
| 7aa697f5-0e60-4c15-b4cc-9cb659698512 | Internal   | None |
+--------------------------------------+------------+------+

आउटपुट:

27a74fcd-37c0-4789-9414-9531b7e3f126

import os
cmd = 'ls -al'
os.system(cmd)

यदि आप कमांड के परिणाम वापस करना चाहते हैं, तो आप os.popen उपयोग कर सकते हैं। हालांकि, यह subprocess मॉड्यूल के पक्ष में संस्करण 2.6 के बाद से बहिष्कृत है, जो अन्य उत्तरों अच्छी तरह से कवर किया गया है।





external