blocks|key|1542601|text|典型实施：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1542602|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()|code-block|syntax|javascript|1542603|您可以随意处理管道中的stdout数据。实际上，您只需省略这些参数(stdout=和stderr=)，它就会像os.system()一样工作。|offset|length|style|CODE|1542604|entityMap^0|0|0|B|6|Y|7|16|7|1J|B|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|N|$]]

Typical implementation:
<pre class="lang-py prettyprint-override"><code>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()
</code></pre>
You are free to do what you want with the <code>stdout</code> data in the pipe. In fact, you can simply omit those parameters (<code>stdout=</code> and <code>stderr=</code>) and it'll behave like <code>os.system()</code>.

blocks|key|1542447|text|import+os
os.system("your+command")|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1542448|注意，这是很危险的，因为命令没有被清理。我把你留给谷歌来获取关于os和sys模块的相关文档。有一堆函数(exec*和spawn*)也会做类似的事情。|unstyled|1542449|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>import os
os.system("your command")
</code></pre>

Note that this is dangerous, since the command isn't cleaned. I leave it up to you to google for the relevant documentation on the 'os' and 'sys' modules. There are a bunch of functions (exec* and spawn*) that will do similar things.

blocks|key|1757481|text|我建议使用subprocess模块而不是os.system模块，因为它可以为您进行外壳转义，因此更安全。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1757482|subprocess.call(['ping',+'localhost'])|code-block|syntax|javascript|1757483|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/subprocess.html^0|5|A|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

I'd recommend using the <a href="http://docs.python.org/library/subprocess.html" rel="noreferrer">subprocess</a> module instead of os.system because it does shell escaping for you and is therefore much safer.

<pre><code>subprocess.call(['ping', 'localhost'])
</code></pre>

blocks|key|1757420|text|import+os
cmd+=+'ls+-al'
os.system(cmd)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1757421|如果想要返回命令的结果，可以使用os.popen。但是，从2.6版开始，为了支持subprocess+module，它被弃用了，其他答案已经很好地介绍了这一点。|unstyled|offset|length|style|CODE|1757422|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/os.html#os.popen|1|https://docs.python.org/2/library/subprocess.html#module-subprocess^0|0|G|8|G|8|0|14|H|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@$G|W|H|X|I|J]]|9|@$G|Y|H|Z|1|10]|$G|11|H|12|1|13]]|A|$]]|$1|K|3|-4|5|F|7|14|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]|S|$5|N|O|P|A|$Q|T]]]]

<pre><code>import os
cmd = 'ls -al'
os.system(cmd)
</code></pre>

If you want to return the results of the command, you can use <a href="https://docs.python.org/2/library/os.html#os.popen" rel="noreferrer"><code>os.popen</code></a>. However, this is deprecated since version 2.6 in favor of the <a href="https://docs.python.org/2/library/subprocess.html#module-subprocess" rel="noreferrer">subprocess module</a>, which other answers have covered well.

blocks|key|1542782|text|我总是使用fabric来做这些事情，比如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1542783|from+fabric.operations+import+local
result+=+local('ls',+capture=True)
print+"Content:/n%25s"+%25+(result,+)|code-block|syntax|javascript|1542784|但这似乎是一个很好的工具：sh+(Python+subprocess+interface)。|1542785|看一个例子：|1542786|from+sh+import+vgdisplay
print+vgdisplay()
print+vgdisplay('-v')
print+vgdisplay(v=True)|1542787|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/amoffat/sh^0|5|6|0|0|D|2|D|W|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|M|3|N|5|6|7|18|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

I always use <code>fabric</code> for this things like:

<pre><code>from fabric.operations import local
result = local('ls', capture=True)
print "Content:/n%s" % (result, )
</code></pre>

But this seem to be a good tool: <a href="https://github.com/amoffat/sh" rel="noreferrer"><code>sh</code> (Python subprocess interface)</a>.

Look at an example:

<pre><code>from sh import vgdisplay
print vgdisplay()
print vgdisplay('-v')
print vgdisplay(v=True)
</code></pre>

blocks|key|1542713|text|还要检查"pexpect“Python库。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1542714|它允许交互控制外部程序/命令，甚至是ssh、ftp、telnet等。您只需键入以下内容：|1542715|child+=+pexpect.spawn('ftp+192.168.0.24')

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

child.sendline('anonymous')

child.expect('(?i)password')|code-block|syntax|javascript|1542716|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Check the "pexpect" Python library, too.

It allows for interactive controlling of external programs/commands, even ssh, ftp, telnet, etc. You can just type something like:

<pre><code>child = pexpect.spawn('ftp 192.168.0.24')

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

child.sendline('anonymous')

child.expect('(?i)password')
</code></pre>

blocks|key|1758053|text|更新：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1758054|如果您的代码不需要保持与早期版本的兼容性，subprocess.run是推荐的方法as+of+Python+3.5。它更加一致，并提供了与特使类似的易用性。(管道并不是那么简单。参见this+question+for+how。)|offset|length|style|CODE|1758055|这里有一些来自the+documentation的例子。|1758056|运行进程：|1758057|>>>+subprocess.run(["ls",+"-l"])++#+Doesn't+capture+output
CompletedProcess(args=['ls',+'-l'],+returncode=0)|code-block|syntax|javascript|1758058|运行失败时引发：|1758059|>>>+subprocess.run("exit+1",+shell=True,+check=True)
Traceback+(most+recent+call+last):
++...
subprocess.CalledProcessError:+Command+'exit+1'+returned+non-zero+exit+status+1|1758060|捕获输出：|1758061|>>>+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')|1758062|原始答案：|1758063|我推荐你试试Envoy。它是子进程的包装器，子进程反过来aims+to+replace旧的模块和函数。特使是人类的子进程。|1758064|来自the+README的用法示例|1758065|>>>+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
''|1758066|此外，还可以通过管道传输数据：|1758067|>>>+r+=+envoy.run('uptime+%7C+pbcopy')

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

>>>+r.history
[<Response+'uptime'>]|1758068|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3.6/whatsnew/3.5.html#whatsnew-subprocess|1|https://stackoverflow.com/questions/7389662/link-several-popen-commands-with-pipes|2|https://docs.python.org/3.6/library/subprocess.html#subprocess.run|3|https://github.com/kennethreitz/envoy|4|http://docs.python.org/2/library/subprocess.html|5|https://github.com/kennethreitz/envoy#readme^0|0|L|E|15|G|0|2J|L|1|0|7|H|2|0|0|0|0|0|0|0|0|6|5|3|S|F|4|0|2|A|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1T|8|@$D|1U|E|1V|F|G]]|9|@$D|1W|E|1X|1|1Y]|$D|1Z|E|20|1|21]]|A|$]]|$1|H|3|I|5|6|7|22|8|@]|9|@$D|23|E|24|1|25]]|A|$]]|$1|J|3|K|5|6|7|26|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|27|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|28|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|29|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|2A|8|@]|9|@]|A|$]]|$1|W|3|X|5|N|7|2B|8|@]|9|@]|A|$O|P]]|$1|Y|3|Z|5|6|7|2C|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|2D|8|@]|9|@$D|2E|E|2F|1|2G]|$D|2H|E|2I|1|2J]]|A|$]]|$1|12|3|13|5|6|7|2K|8|@]|9|@$D|2L|E|2M|1|2N]]|A|$]]|$1|14|3|15|5|N|7|2O|8|@]|9|@]|A|$O|P]]|$1|16|3|17|5|6|7|2P|8|@]|9|@]|A|$]]|$1|18|3|19|5|N|7|2Q|8|@]|9|@]|A|$O|P]]|$1|1A|3|-4|5|6|7|2R|8|@]|9|@]|A|$]]]|1B|$1C|$5|1D|1E|1F|A|$1G|1H]]|1I|$5|1D|1E|1F|A|$1G|1J]]|1K|$5|1D|1E|1F|A|$1G|1L]]|1M|$5|1D|1E|1F|A|$1G|1N]]|1O|$5|1D|1E|1F|A|$1G|1P]]|1Q|$5|1D|1E|1F|A|$1G|1R]]]]

<h1>Update:</h1>

<code>subprocess.run</code> is the recommended approach <a href="https://docs.python.org/3.6/whatsnew/3.5.html#whatsnew-subprocess" rel="noreferrer">as of Python 3.5</a> if your code does not need to maintain compatibility with earlier Python versions. It's more consistent and offers similar ease-of-use as Envoy. (Piping isn't as straightforward though. See <a href="https://stackoverflow.com/questions/7389662/link-several-popen-commands-with-pipes">this question for how</a>.)

Here's some examples from <a href="https://docs.python.org/3.6/library/subprocess.html#subprocess.run" rel="noreferrer">the documentation</a>.

Run a process:

<pre><code>&gt;&gt;&gt; subprocess.run(["ls", "-l"]) # Doesn't capture output
CompletedProcess(args=['ls', '-l'], returncode=0)
</code></pre>

Raise on failed run:

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

Capture output:

<pre><code>&gt;&gt;&gt; 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')
</code></pre>

<h1>Original answer:</h1>

I recommend trying <a href="https://github.com/kennethreitz/envoy" rel="noreferrer">Envoy</a>. It's a wrapper for subprocess, which in turn <a href="http://docs.python.org/2/library/subprocess.html" rel="noreferrer">aims to replace</a> the older modules and functions. Envoy is subprocess for humans.

Example usage from <a href="https://github.com/kennethreitz/envoy#readme" rel="noreferrer">the README</a>:

<pre><code>&gt;&gt;&gt; r = envoy.run('git config', data='data to pipe in', timeout=2)

&gt;&gt;&gt; r.status_code
129
&gt;&gt;&gt; r.std_out
'usage: git config [options]'
&gt;&gt;&gt; r.std_err
''
</code></pre>

Pipe stuff around too:

<pre><code>&gt;&gt;&gt; r = envoy.run('uptime | pbcopy')

&gt;&gt;&gt; r.command
'pbcopy'
&gt;&gt;&gt; r.status_code
0

&gt;&gt;&gt; r.history
[&lt;Response 'uptime'&gt;]
</code></pre>

blocks|key|1757917|text|这就是我运行命令的方式。这段代码包含了几乎所有您需要的东西|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1757918|from+subprocess+import+Popen,+PIPE
cmd+=+"ls+-l+~/"
p+=+Popen(cmd+,+shell=True,+stdout=PIPE,+stderr=PIPE)
out,+err+=+p.communicate()
print+"Return+code:+",+p.returncode
print+out.rstrip(),+err.rstrip()|code-block|syntax|javascript|1757919|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is how I run my commands. This code has everything you need pretty much

<pre><code>from subprocess import Popen, PIPE
cmd = "ls -l ~/"
p = Popen(cmd , shell=True, stdout=PIPE, stderr=PIPE)
out, err = p.communicate()
print "Return code: ", p.returncode
print out.rstrip(), err.rstrip()
</code></pre>

blocks|key|1757508|text|os.system还可以，但有点过时了。它也不是很安全。相反，可以尝试使用subprocess。subprocess不直接调用sh，因此比os.system更安全。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1757509|获取更多信息here。|1757510|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/library/subprocess.html^0|0|9|11|A|1C|A|1X|9|0|6|4|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|H|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

<code>os.system</code> is OK, but kind of dated. It's also not very secure. Instead, try <code>subprocess</code>. <code>subprocess</code> does not call sh directly and is therefore more secure than <code>os.system</code>.

Get more information <a href="https://docs.python.org/library/subprocess.html" rel="noreferrer">here</a>.

blocks|key|1543578|text|还有Plumbum|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1543579|>>>+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|code-block|syntax|javascript|1543580|entityMap|0|LINK|mutability|MUTABLE|url|http://plumbum.readthedocs.org/en/latest/^0|2|7|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

There is also <a href="http://plumbum.readthedocs.org/en/latest/">Plumbum</a>

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

blocks|key|1544132|text|它可以很简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1544133|import+os
cmd+=+"your+command"
os.system(cmd)|code-block|syntax|javascript|1544134|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It can be this simple:

<pre><code>import os
cmd = "your command"
os.system(cmd)
</code></pre>

blocks|key|1757580|text|这里还有一个之前没有提到的区别。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1757581|subprocess.Popen将作为子进程执行。在我的例子中，我需要执行需要与另一个程序通信的文件。|offset|length|style|CODE|1757582|我试用子进程，执行成功。然而，无法与进行通信。当我从终端运行两者时，一切都是正常的。|1757583|还有一个：(注意:+kwrite的行为与其他应用程序不同。如果您在Firefox上尝试以下操作，结果将不会相同。)|1757584|如果您尝试使用os.system("kwrite")，程序流会冻结，直到用户关闭kwrite。为了克服这一点，我尝试了os.system(konsole+-e+kwrite)。这个时间程序继续流动，但是kwrite成为了控制台的子进程。|1757585|任何人运行kwrite都不是一个子进程(即，在系统监视器中，它必须出现在树的最左边)。|1757586|entityMap^0|0|0|G|0|0|0|7|J|1N|S|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|12|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|Q|$]]

There is another difference here which is not mentioned previously.

<code>subprocess.Popen</code> executes the &lt;command> as a subprocess. In my case, I need to execute file &lt;a> which needs to communicate with another program, &lt;b>. 

I tried subprocess, and execution was successful. However &lt;b> could not communicate with &lt;a>.
Everything is normal when I run both from the terminal.

One more: 
(NOTE: kwrite behaves different from other applications. If you try the below with Firefox, the results will not be the same.)

If you try <code>os.system("kwrite")</code>, program flow freezes until the user closes kwrite. To overcome that I tried instead <code>os.system(konsole -e kwrite)</code>. This time program continued to flow, but kwrite became the subprocess of the console.

Anyone runs the kwrite not being a subprocess (i.e. in the system monitor it must appear at the leftmost edge of the tree).

blocks|key|1757751|text|os.system不允许您存储结果，因此，如果您希望将结果存储在某个列表或其他内容中，则可以使用subprocess.call。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1757752|entityMap^0|0|9|1C|F|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

<code>os.system</code> does not allow you to store results, so if you want to store results in some list or something, a <code>subprocess.call</code> works.

blocks|key|1758438|text|我倾向于结合使用subprocess和shlex+(用来处理带引号的字符串的转义)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1758439|>>>+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)|code-block|syntax|javascript|1758440|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/subprocess.html|1|https://docs.python.org/2/library/shlex.html^0|8|A|0|J|5|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

I tend to use <a href="https://docs.python.org/2/library/subprocess.html" rel="noreferrer">subprocess</a> together with <a href="https://docs.python.org/2/library/shlex.html" rel="noreferrer">shlex</a> (to handle escaping of quoted strings):

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

blocks|key|1542751|text|如果你不想测试返回值，subprocess.check_call是很方便的。它会在出现任何错误时抛出异常。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1542752|entityMap^0|B|L|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

<code>subprocess.check_call</code> is convenient if you don't want to test return values. It throws an exception on any error.

blocks|key|1758823|text|在Windows中，您可以通过调用subprocess.Popen()、subprocess.Popen().communicate()和subprocess.Popen().wait()来导入subprocess模块并运行外部命令，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1758824|#+Python+script+to+run+a+command+line
import+subprocess

def+execute(cmd):
++++"""
++++++++Purpose++:+To+execute+a+command+and+return+exit+status
++++++++Argument+:+cmd+-+command+to+execute
++++++++Return+++:+exit_code
++++"""
++++process+=+subprocess.Popen(cmd,+shell=True,+stdout=subprocess.PIPE,+stderr=subprocess.PIPE)
++++(result,+error)+=+process.communicate()

++++rc+=+process.wait()

++++if+rc+!=+0:
++++++++print+"Error:+failed+to+execute+command:",+cmd
++++++++print+error
++++return+result
#+def

command+=+"tasklist+%7C+grep+python"
print+"This+process+detail:+\n",+execute(command)|code-block|syntax|javascript|1758825|输出：|1758826|This+process+detail:
python.exe+++++++++++++++++++++604+RDP-Tcp#0++++++++++++++++++4++++++5,660+K|1758827|entityMap^0|H|I|10|W|1X|P|2P|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

In Windows you can just import the <code>subprocess</code> module and run external commands by calling <code>subprocess.Popen()</code>, <code>subprocess.Popen().communicate()</code> and <code>subprocess.Popen().wait()</code> as below:

<pre><code># Python script to run a command line
import subprocess

def execute(cmd):
 """
 Purpose : To execute a command and return exit status
 Argument : cmd - command to execute
 Return : exit_code
 """
 process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 (result, error) = process.communicate()

 rc = process.wait()

 if rc != 0:
 print "Error: failed to execute command:", cmd
 print error
 return result
# def

command = "tasklist | grep python"
print "This process detail: \n", execute(command)
</code></pre>

Output:

<pre><code>This process detail:
python.exe 604 RDP-Tcp#0 4 5,660 K
</code></pre>

blocks|key|1757803|text|您可以使用Popen，然后可以检查过程的状态：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1757804|from+subprocess+import+Popen

proc+=+Popen(['ls',+'-l'])
if+proc.poll()+is+None:
++++proc.kill()|code-block|syntax|javascript|1757805|查看subprocess.Popen。|offset|length|1757806|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/subprocess.html#popen-objects^0|0|0|2|G|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

You can use Popen, and then you can check the procedure's status:

<pre><code>from subprocess import Popen

proc = Popen(['ls', '-l'])
if proc.poll() is None:
 proc.kill()
</code></pre>

Check out <a href="http://docs.python.org/library/subprocess.html#popen-objects" rel="noreferrer">subprocess.Popen</a>.

blocks|key|1543544|text|一种简单的方法是使用os+module|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1543545|import+os
os.system('ls')|code-block|syntax|javascript|1543546|或者，您也可以使用子流程模块：|1543547|import+subprocess
subprocess.check_call('ls')|1543548|如果希望将结果存储在变量中，请尝试：|1543549|import+subprocess
r+=+subprocess.check_output('ls')|1543550|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/os.html^0|A|9|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

A simple way is to use the <a href="https://docs.python.org/2/library/os.html" rel="noreferrer">os module</a>:

<pre><code>import os
os.system('ls')
</code></pre>

Alternatively, you can also use the subprocess module:

<pre><code>import subprocess
subprocess.check_call('ls')
</code></pre>

If you want the result to be stored in a variable try:

<pre><code>import subprocess
r = subprocess.check_output('ls')
</code></pre>

blocks|key|1542960|text|运行任何命令并返回结果的最简单方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1542961|from+commands+import+getstatusoutput

try:
++++return+getstatusoutput("ls+-ltr")
except+Exception,+e:
++++return+None|code-block|syntax|javascript|1542962|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Very simplest way to run any command and get the result back:

<pre><code>from commands import getstatusoutput

try:
 return getstatusoutput("ls -ltr")
except Exception, e:
 return None
</code></pre>

blocks|key|1543681|text|以下是我的两点意见:在我看来，这是处理外部命令时的最佳实践……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1543682|这些是execute方法的返回值...|1543683|pass,+stdout,+stderr+=+execute(["ls","-la"],"/home/user/desktop")|code-block|syntax|javascript|1543684|这是execute方法...|1543685|def+execute(cmdArray,workingDir):

++++stdout+=+''
++++stderr+=+''

++++try:
++++++++try:
++++++++++++process+=+subprocess.Popen(cmdArray,cwd=workingDir,+stdout=subprocess.PIPE,+stderr=subprocess.PIPE,+bufsize=1)
++++++++except+OSError:
++++++++++++return+[False,+'',+'ERROR+:+command('+%2B+'+'.join(cmdArray)+%2B+')+could+not+get+executed!']

++++++++for+line+in+iter(process.stdout.readline,+b''):

++++++++++++try:
++++++++++++++++echoLine+=+line.decode("utf-8")
++++++++++++except:
++++++++++++++++echoLine+=+str(line)

++++++++++++stdout+%2B=+echoLine

++++++++for+line+in+iter(process.stderr.readline,+b''):

++++++++++++try:
++++++++++++++++echoLine+=+line.decode("utf-8")
++++++++++++except:
++++++++++++++++echoLine+=+str(line)

++++++++++++stderr+%2B=+echoLine

++++except+(KeyboardInterrupt,SystemExit)+as+err:
++++++++return+[False,'',str(err)]

++++process.stdout.close()

++++returnCode+=+process.wait()
++++if+returnCode+!=+0+or+stderr+!=+'':
++++++++return+[False,+stdout,+stderr]
++++else:
++++++++return+[True,+stdout,+stderr]|1543686|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here are my two cents: In my view, this is the best practice when dealing with external commands...

These are the return values from the execute method...

<pre><code>pass, stdout, stderr = execute(["ls","-la"],"/home/user/desktop")
</code></pre>

This is the execute method...

<pre><code>def execute(cmdArray,workingDir):

 stdout = ''
 stderr = ''

 try:
 try:
 process = subprocess.Popen(cmdArray,cwd=workingDir, stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=1)
 except OSError:
 return [False, '', 'ERROR : command(' + ' '.join(cmdArray) + ') could not get executed!']

 for line in iter(process.stdout.readline, b''):

 try:
 echoLine = line.decode("utf-8")
 except:
 echoLine = str(line)

 stdout += echoLine

 for line in iter(process.stderr.readline, b''):

 try:
 echoLine = line.decode("utf-8")
 except:
 echoLine = str(line)

 stderr += echoLine

 except (KeyboardInterrupt,SystemExit) as err:
 return [False,'',str(err)]

 process.stdout.close()

 returnCode = process.wait()
 if returnCode != 0 or stderr != '':
 return [False, stdout, stderr]
 else:
 return [True, stdout, stderr]
</code></pre>

blocks|key|1543363|text|为了补充讨论，如果您包括使用Python控制台，则可以从IPython调用外部命令。在IPython提示符下，您可以通过添加前缀'!‘来调用外壳命令。您还可以将Python代码与shell结合起来，并将shell脚本的输出赋给Python变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1543364|例如：|1543365|In+[9]:+mylist+=+!ls

In+[10]:+mylist
Out[10]:
['file1',
+'file2',
+'file3',]|code-block|syntax|javascript|1543366|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/IPython^0|S|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Just to add to the discussion, if you include using a Python console, you can call external commands from <a href="http://en.wikipedia.org/wiki/IPython" rel="noreferrer">IPython</a>. While in the IPython prompt, you can call shell commands by prefixing '!'. You can also combine Python code with the shell, and assign the output of shell scripts to Python variables.

For instance:

<pre><code>In [9]: mylist = !ls

In [10]: mylist
Out[10]:
['file1',
 'file2',
 'file3',]
</code></pre>

blocks|key|1759192|text|我写了一个小的库来帮助解决这个用例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1759193|https://pypi.org/project/citizenshell/|offset|length|1759194|它可以使用以下命令进行安装|1759195|pip+install+citizenshell|code-block|syntax|javascript|1759196|然后按如下方式使用：|1759197|from+citizenshell+import+sh
assert+sh("echo+Hello+World")+==+"Hello+World"|1759198|您可以将标准输出与标准错误分开，并提取退出代码，如下所示：|1759199|result+=+sh(">&2+echo+error+&&+echo+output+&&+exit+13")
assert+result.stdout()+==+["output"]
assert+result.stderr()+==+["error"]
assert+result.exit_code()+==+13|1759200|最酷的是，在开始处理输出之前，您不必等待底层shell退出：|1759201|for+line+in+sh("for+i+in+1+2+3+4;+do+echo+-n+'It+is+';+date+%2B%25H:%25M:%25S;+sleep+1;+done",+wait=False)
++++print+">>>",+line+%2B+"!"|1759202|多亏了wait=False，我将打印可用的行|1759203|>>>+It+is+14:24:52!
>>>+It+is+14:24:53!
>>>+It+is+14:24:54!
>>>+It+is+14:24:55!|1759204|有关更多示例，请访问https://github.com/meuter/citizenshell|1759205|entityMap|0|LINK|mutability|MUTABLE|url|1|https://github.com/meuter/citizenshell^0|0|0|12|0|0|0|0|0|0|0|0|0|0|0|0|A|12|1|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1E|8|@]|9|@$D|1F|E|1G|1|1H]]|A|$]]|$1|F|3|G|5|6|7|1I|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1J|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1K|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1L|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1M|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|1N|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|1O|8|@]|9|@]|A|$]]|$1|W|3|X|5|J|7|1P|8|@]|9|@]|A|$K|L]]|$1|Y|3|Z|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|10|3|11|5|J|7|1R|8|@]|9|@]|A|$K|L]]|$1|12|3|13|5|6|7|1S|8|@]|9|@$D|1T|E|1U|1|1V]]|A|$]]|$1|14|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|C]]|1B|$5|17|18|19|A|$1A|1C]]]]

I wrote a small library to help with this use case:
<a href="https://pypi.org/project/citizenshell/" rel="nofollow noreferrer">https://pypi.org/project/citizenshell/</a>
It can be installed using
<pre><code>pip install citizenshell
</code></pre>
And then used as follows:
<pre><code>from citizenshell import sh
assert sh(&quot;echo Hello World&quot;) == &quot;Hello World&quot;
</code></pre>
You can separate standard output from standard error and extract the exit code as follows:
<pre><code>result = sh(&quot;&gt;&amp;2 echo error &amp;&amp; echo output &amp;&amp; exit 13&quot;)
assert result.stdout() == [&quot;output&quot;]
assert result.stderr() == [&quot;error&quot;]
assert result.exit_code() == 13
</code></pre>
And the cool thing is that you don't have to wait for the underlying shell to exit before starting processing the output:
<pre><code>for line in sh(&quot;for i in 1 2 3 4; do echo -n 'It is '; date +%H:%M:%S; sleep 1; done&quot;, wait=False)
 print &quot;&gt;&gt;&gt;&quot;, line + &quot;!&quot;
</code></pre>
will print the lines as they are available thanks to the wait=False
<pre class="lang-none prettyprint-override"><code>&gt;&gt;&gt; It is 14:24:52!
&gt;&gt;&gt; It is 14:24:53!
&gt;&gt;&gt; It is 14:24:54!
&gt;&gt;&gt; It is 14:24:55!
</code></pre>
More examples can be found at <a href="https://github.com/meuter/citizenshell" rel="nofollow noreferrer">https://github.com/meuter/citizenshell</a>

blocks|key|1758174|text|在Python中有很多不同的方式来运行外部命令，而且它们都有自己的优点和缺点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1758175|我和我的同事一直在编写Python系统管理工具，因此我们需要运行许多外部命令，有时您希望它们阻塞或异步运行、超时、每秒更新等。|1758176|还有不同的方法来处理返回代码和错误，您可能希望解析输出，并提供新的输入(以一种expect风格)。或者，您需要重定向standard+input、standard+output和standard+error以在不同的tty中运行(例如，在使用GNU+Screen时)。|offset|length|1758177|因此，您可能必须为外部命令编写大量的包装器。这是我们编写的一个Python模块，它可以处理几乎任何你想要的东西，如果不能，它非常灵活，所以你可以很容易地扩展它：|1758178|https://github.com/hpcugent/vsc-base/blob/master/lib/vsc/utils/run.py|1758179|它不能独立工作，需要我们的一些其他工具，多年来获得了许多专门的功能，所以它可能不是你的临时替代品，但它可以为你提供大量关于Python运行命令的内部如何工作的信息，以及如何处理某些情况的想法。|1758180|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Expect|1|https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin))|2|https://en.wikipedia.org/wiki/Standard_streams#Standard_output_.28stdout.29|3|https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)|4|https://en.wikipedia.org/wiki/GNU_Screen|5^0|0|0|13|6|0|1M|E|1|21|F|2|2H|E|3|3D|A|4|0|0|0|1X|5|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@$F|17|G|18|1|19]|$F|1A|G|1B|1|1C]|$F|1D|G|1E|1|1F]|$F|1G|G|1H|1|1I]|$F|1J|G|1K|1|1L]]|A|$]]|$1|H|3|I|5|6|7|1M|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1N|8|@]|9|@$F|1O|G|1P|1|1Q]]|A|$]]|$1|L|3|M|5|6|7|1R|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]|V|$5|Q|R|S|A|$T|W]]|X|$5|Q|R|S|A|$T|Y]]|Z|$5|Q|R|S|A|$T|10]]|11|$5|Q|R|S|A|$T|12]]|13|$5|Q|R|S|A|$T|K]]]]

There are a lot of different ways to run external commands in Python,
and all of them have their own plus sides and drawbacks.
My colleagues and me have been writing Python system administration tools, so we need to run a lot of external commands, and sometimes you want them to block or run asynchronously, time-out, update every second, etc.
There are also different ways of handling the return code and errors,
and you might want to parse the output, and provide new input (in an <a href="http://en.wikipedia.org/wiki/Expect" rel="nofollow noreferrer">expect</a> kind of style). Or you will need to redirect <a href="https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)" rel="nofollow noreferrer">standard input</a>, <a href="https://en.wikipedia.org/wiki/Standard_streams#Standard_output_.28stdout.29" rel="nofollow noreferrer">standard output</a>, and <a href="https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)" rel="nofollow noreferrer">standard error</a> to run in a different tty (e.g., when using <a href="https://en.wikipedia.org/wiki/GNU_Screen" rel="nofollow noreferrer">GNU Screen</a>).
So you will probably have to write a lot of wrappers around the external command. So here is a Python module which we have written which can handle
almost anything you would want, and if not, it's very flexible so you can easily extend it:
<a href="https://github.com/hpcugent/vsc-base/blob/master/lib/vsc/utils/run.py" rel="nofollow noreferrer">https://github.com/hpcugent/vsc-base/blob/master/lib/vsc/utils/run.py</a>
It doesn't work stand-alone and requires some of our other tools, and got a lot of specialised functionality over the years, so it might not be a drop-in replacement for you, but it can give you a lot of information on how the internals of Python for running commands work and ideas on how to handle certain situations.

blocks|key|1543469|text|使用subprocess.call|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1543470|from+subprocess+import+call

#+Using+list
call(["echo",+"Hello",+"world"])

#+Single+string+argument+varies+across+platforms+so+better+split+it
call("echo+Hello+world".split("+"))|code-block|syntax|javascript|1543471|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/subprocess.html^0|2|F|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Use <a href="https://docs.python.org/2/library/subprocess.html" rel="noreferrer">subprocess.call</a>:



<pre class="lang-python prettyprint-override"><code>from subprocess import call

# Using list
call(["echo", "Hello", "world"])

# Single string argument varies across platforms so better split it
call("echo Hello world".split(" "))
</code></pre>

blocks|key|1543934|text|使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1543935|import+subprocess

p+=+subprocess.Popen("df+-h",+shell=True,+stdout=subprocess.PIPE,+stderr=subprocess.PIPE).communicate()[0]
print+p.split("\n")|code-block|syntax|javascript|1543936|它提供了很好的输出，更容易使用：|1543937|['Filesystem++++++Size++Used+Avail+Use%25+Mounted+on',
+'/dev/sda6++++++++32G+++21G+++11G++67%25+/',
+'none++++++++++++4.0K+++++0++4.0K+++0%25+/sys/fs/cgroup',
+'udev++++++++++++1.9G++4.0K++1.9G+++1%25+/dev',
+'tmpfs+++++++++++387M++1.4M++386M+++1%25+/run',
+'none++++++++++++5.0M+++++0++5.0M+++0%25+/run/lock',
+'none++++++++++++1.9G+++58M++1.9G+++3%25+/run/shm',
+'none++++++++++++100M+++32K++100M+++1%25+/run/user',
+'/dev/sda5+++++++340G++222G++100G++69%25+/home',
+'']|1543938|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Use:

<pre><code>import subprocess

p = subprocess.Popen("df -h", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()[0]
print p.split("\n")
</code></pre>

It gives nice output which is easier to work with:

<pre><code>['Filesystem Size Used Avail Use% Mounted on',
 '/dev/sda6 32G 21G 11G 67% /',
 'none 4.0K 0 4.0K 0% /sys/fs/cgroup',
 'udev 1.9G 4.0K 1.9G 1% /dev',
 'tmpfs 387M 1.4M 386M 1% /run',
 'none 5.0M 0 5.0M 0% /run/lock',
 'none 1.9G 58M 1.9G 3% /run/shm',
 'none 100M 32K 100M 1% /run/user',
 '/dev/sda5 340G 222G 100G 69% /home',
 '']
</code></pre>

blocks|key|1544081|text|举个例子(在Linux中)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1544082|import+subprocess
subprocess.run('mkdir+test.dir',+shell=True)|code-block|syntax|javascript|1544083|这将在当前目录中创建test.dir。请注意，这也是可行的：|1544084|import+subprocess
subprocess.call('mkdir+test.dir',+shell=True)|1544085|使用os.system的等效代码为：|1544086|import+os
os.system('mkdir+test.dir')|1544087|最佳实践是使用子进程而不是os，其中.run比.call更受青睐。对子进程，您所需要了解的就是here。另外，请注意，所有Python文档都可以从here下载。我下载了打包为.zip的PDF。我之所以提到这一点，是因为tutorial.pdf中的os模块有一个很好的概述(第81页)。此外，它还是Python程序员的权威资源。|offset|length|1544088|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3.5/library/subprocess.html|1|https://docs.python.org/3/download.html^0|0|0|0|0|0|0|1B|4|0|21|4|1|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@]|9|@$Q|19|R|1A|1|1B]|$Q|1C|R|1D|1|1E]]|A|$]]|$1|S|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]]]

As an example (in Linux):

<pre><code>import subprocess
subprocess.run('mkdir test.dir', shell=True)
</code></pre>

This creates test.dir in the current directory.
Note that this also works:

<pre><code>import subprocess
subprocess.call('mkdir test.dir', shell=True)
</code></pre>

The equivalent code using os.system is:

<pre><code>import os
os.system('mkdir test.dir')
</code></pre>

Best practice would be to use subprocess instead of os, with .run favored over .call. 
All you need to know about subprocess is <a href="https://docs.python.org/3.5/library/subprocess.html" rel="noreferrer">here</a>.
Also, note that all Python documentation is available for download from <a href="https://docs.python.org/3/download.html" rel="noreferrer">here</a>. I downloaded the PDF packed as .zip. I mention this because there's a nice overview of the os module in tutorial.pdf (page 81). Besides, it's an authoritative resource for Python coders.

blocks|key|1544367|text|为了在Python 3.5%2B中使用subprocess，我在Linux上使用了以下技巧：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1544368|import+subprocess

#+subprocess.run()+returns+a+completed+process+object+that+can+be+inspected
c+=+subprocess.run(["ls",+"-ltrh"],+stdout=subprocess.PIPE,+stderr=subprocess.PIPE)
print(c.stdout.decode('utf-8'))|code-block|syntax|javascript|1544369|正如在the+documentation中提到的，PIPE值是字节序列，为了正确显示它们，应该考虑解码。对于更高版本的Python，text=True和encoding='utf-8'被添加到subprocess.run()的kwargs中。|1544370|上述代码的输出为：|1544371|total+113M
-rwxr-xr-x++1+farzad+farzad++307+Jan+15++2018+vpnscript
-rwxrwxr-x++1+farzad+farzad++204+Jan+15++2018+ex
drwxrwxr-x++4+farzad+farzad+4.0K+Jan+22++2018+scripts
....+#+Some+other+lines|1544372|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/subprocess.html#subprocess.CompletedProcess|1|https://docs.python.org/3.6/library/subprocess.html#subprocess.run^0|H|A|0|0|P|4|1U|9|24|G|2O|G|3|H|0|2O|G|1|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@$9|1D|A|1E|1|1F]|$9|1G|A|1H|1|1I]]|E|$]]|$1|M|3|N|5|6|7|1J|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]]]

For using <code>subprocess</code> in Python 3.5+, the following did the trick for me on Linux:
<pre><code>import subprocess

# subprocess.run() returns a completed process object that can be inspected
c = subprocess.run([&quot;ls&quot;, &quot;-ltrh&quot;], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
print(c.stdout.decode('utf-8'))
</code></pre>
As mentioned in <a href="https://docs.python.org/3/library/subprocess.html#subprocess.CompletedProcess" rel="nofollow noreferrer">the documentation</a>, <code>PIPE</code> values are byte sequences and for properly showing them decoding should be considered. For later versions of Python, <code>text=True</code> and <code>encoding='utf-8'</code> are added to kwargs of <a href="https://docs.python.org/3.6/library/subprocess.html#subprocess.run" rel="nofollow noreferrer"><code>subprocess.run()</code></a>.
The output of the abovementioned code is:
<pre><code>total 113M
-rwxr-xr-x 1 farzad farzad 307 Jan 15 2018 vpnscript
-rwxrwxr-x 1 farzad farzad 204 Jan 15 2018 ex
drwxrwxr-x 4 farzad farzad 4.0K Jan 22 2018 scripts
.... # Some other lines
</code></pre>

blocks|key|1758373|text|经过一些研究，我有了下面的代码，它对我来说工作得很好。它基本上是实时打印标准输出和标准误差。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1758374|stdout_result+=+1
stderr_result+=+1


def+stdout_thread(pipe):
++++global+stdout_result
++++while+True:
++++++++out+=+pipe.stdout.read(1)
++++++++stdout_result+=+pipe.poll()
++++++++if+out+==+''+and+stdout_result+is+not+None:
++++++++++++break

++++++++if+out+!=+'':
++++++++++++sys.stdout.write(out)
++++++++++++sys.stdout.flush()


def+stderr_thread(pipe):
++++global+stderr_result
++++while+True:
++++++++err+=+pipe.stderr.read(1)
++++++++stderr_result+=+pipe.poll()
++++++++if+err+==+''+and+stderr_result+is+not+None:
++++++++++++break

++++++++if+err+!=+'':
++++++++++++sys.stdout.write(err)
++++++++++++sys.stdout.flush()


def+exec_command(command,+cwd=None):
++++if+cwd+is+not+None:
++++++++print+'['+%2B+'+'.join(command)+%2B+']+in+'+%2B+cwd
++++else:
++++++++print+'['+%2B+'+'.join(command)+%2B+']'

++++p+=+subprocess.Popen(
++++++++command,+stdout=subprocess.PIPE,+stderr=subprocess.PIPE,+cwd=cwd
++++)

++++out_thread+=+threading.Thread(name='stdout_thread',+target=stdout_thread,+args=(p,))
++++err_thread+=+threading.Thread(name='stderr_thread',+target=stderr_thread,+args=(p,))

++++err_thread.start()
++++out_thread.start()

++++out_thread.join()
++++err_thread.join()

++++return+stdout_result+%2B+stderr_result|code-block|syntax|javascript|1758375|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

After some research, I have the following code which works very well for me. It basically prints both standard output and standard error in real time.
<pre><code>stdout_result = 1
stderr_result = 1


def stdout_thread(pipe):
 global stdout_result
 while True:
 out = pipe.stdout.read(1)
 stdout_result = pipe.poll()
 if out == '' and stdout_result is not None:
 break

 if out != '':
 sys.stdout.write(out)
 sys.stdout.flush()


def stderr_thread(pipe):
 global stderr_result
 while True:
 err = pipe.stderr.read(1)
 stderr_result = pipe.poll()
 if err == '' and stderr_result is not None:
 break

 if err != '':
 sys.stdout.write(err)
 sys.stdout.flush()


def exec_command(command, cwd=None):
 if cwd is not None:
 print '[' + ' '.join(command) + '] in ' + cwd
 else:
 print '[' + ' '.join(command) + ']'

 p = subprocess.Popen(
 command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd
 )

 out_thread = threading.Thread(name='stdout_thread', target=stdout_thread, args=(p,))
 err_thread = threading.Thread(name='stderr_thread', target=stderr_thread, args=(p,))

 err_thread.start()
 out_thread.start()

 out_thread.join()
 err_thread.join()

 return stdout_result + stderr_result
</code></pre>

blocks|key|1544166|text|如果需要从Python笔记本(如Jupyter、Zeppelin、Databricks或Google+Cloud+Datalab)调用shell命令，只需使用!前缀。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1544167|例如,|1544168|!ls+-ilF|code-block|syntax|javascript|1544169|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/IPython#Project_Jupyter^0|27|1|G|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

If you need to call a shell command from a Python notebook (like <a href="https://en.wikipedia.org/wiki/IPython#Project_Jupyter" rel="noreferrer">Jupyter</a>, Zeppelin, Databricks, or Google Cloud Datalab) you can just use the <code>!</code> prefix.

For example,

<pre><code>!ls -ilF
</code></pre>

blocks|key|1759376|text|如果您正在编写Python+shell脚本并在系统上安装了IPython，则可以在IPython中使用bang前缀来运行shell命令：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1759377|!ls
filelist+=+!ls|code-block|syntax|javascript|1759378|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/IPython^0|T|7|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

If you're writing a Python shell script and have <a href="http://en.wikipedia.org/wiki/IPython" rel="nofollow noreferrer">IPython</a> installed on your system, you can use the bang prefix to run a shell command inside IPython:

<pre><code>!ls
filelist = !ls
</code></pre>

blocks|key|1543757|text|对于Python+3.5%2B，建议使用run+function+from+the+subprocess+module。这将返回一个CompletedProcess对象，您可以从该对象轻松地获取输出和返回代码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1543758|from+subprocess+import+PIPE,+run

command+=+['echo',+'hello']
result+=+run(command,+stdout=PIPE,+stderr=PIPE,+universal_newlines=True)
print(result.returncode,+result.stdout,+result.stderr)|code-block|syntax|javascript|1543759|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3.5/library/subprocess.html#subprocess.run^0|1S|G|I|13|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

For Python 3.5+ it is recommended that you use the <a href="https://docs.python.org/3.5/library/subprocess.html#subprocess.run" rel="nofollow noreferrer">run function from the subprocess module</a>. This returns a <code>CompletedProcess</code> object, from which you can easily obtain the output as well as return code.

<pre><code>from subprocess import PIPE, run

command = ['echo', 'hello']
result = run(command, stdout=PIPE, stderr=PIPE, universal_newlines=True)
print(result.returncode, result.stdout, result.stderr)
</code></pre>

blocks|key|1758237|text|更新2015:+Python3.5添加了比subprocess.Popen更容易使用的subprocess.run。我建议你这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1758238|>>>+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"],+capture_output=True)
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',+stderr=b'')|code-block|syntax|javascript|1758239|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/subprocess.html#subprocess.run^0|17|E|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Update 2015: Python 3.5 added <a href="https://docs.python.org/3/library/subprocess.html#subprocess.run" rel="nofollow noreferrer">subprocess.run</a> which is much easier to use than subprocess.Popen. I recommend that.
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; subprocess.run([&quot;ls&quot;, &quot;-l&quot;]) # doesn't capture output
CompletedProcess(args=['ls', '-l'], returncode=0)

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

&gt;&gt;&gt; subprocess.run([&quot;ls&quot;, &quot;-l&quot;, &quot;/dev/null&quot;], capture_output=True)
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', stderr=b'')
</code></pre>

blocks|key|1543630|text|使用Linux模块的Popen函数是运行subprocess命令的最简单方法。在这种情况下，Popen.communicate()函数将给出命令输出。例如|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1543631|import+subprocess

..
process+=+subprocess.Popen(..)+++#+Pass+command+and+arguments+to+the+function
stdout,+stderr+=+process.communicate()+++#+Get+command+output+and+error
..|code-block|syntax|javascript|1543632|entityMap^0|A|5|K|A|1A|J|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

Using the <code>Popen</code> function of the <code>subprocess</code> Python module is the simplest way of running Linux commands. In that, the <code>Popen.communicate()</code> function will give your commands output. For example

<pre><code>import subprocess

..
process = subprocess.Popen(..) # Pass command and arguments to the function
stdout, stderr = process.communicate() # Get command output and error
..
</code></pre>

blocks|key|1544513|text|os.popen()是执行命令的最简单、最安全的方法。您可以执行在命令行上运行的任何命令。此外，您还可以使用os.popen().read()捕获命令的输出|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1544514|你可以这样做：|1544515|import+os
output+=+os.popen('Your+Command+Here').read()
print+(output)|code-block|syntax|javascript|1544516|下面是列出当前目录中所有文件的示例：|1544517|import+os
output+=+os.popen('ls').read()
print+(output)
#+Outputs+list+of+files+in+the+directory|1544518|entityMap^0|0|A|1I|H|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

<code>os.popen()</code> is the easiest and the most safest way to execute a command. You can execute any command that you run on the command line. In addition you will also be able to capture the output of the command using <code>os.popen().read()</code>

You can do it like this:

<pre><code>import os
output = os.popen('Your Command Here').read()
print (output)
</code></pre>

An example where you list all the files in the current directory:

<pre><code>import os
output = os.popen('ls').read()
print (output)
# Outputs list of files in the directory
</code></pre>

blocks|key|1543829|text|我推荐下面的方法'run‘，它将帮助我们将standard+output、standard+error和exit状态作为字典来获取；这个方法的调用者可以通过'run’方法读取字典返回的信息，以了解进程的实际状态。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1543830|++def+run+(cmd):
+++++++print+"%2B+DEBUG+exec({0})".format(cmd)
+++++++p+=+subprocess.Popen(cmd,+stdout=subprocess.PIPE,+stderr=subprocess.PIPE,+universal_newlines=True,+shell=True)
+++++++(out,+err)+=+p.communicate()
+++++++ret++++++++=+p.wait()
+++++++out++++++++=+filter(None,+out.split('\n'))
+++++++err++++++++=+filter(None,+err.split('\n'))
+++++++ret++++++++=+True+if+ret+==+0+else+False
+++++++return+dict({'output':+out,+'error':+err,+'status':+ret})
++#end|code-block|syntax|javascript|1543831|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Standard_streams#Standard_output_.28stdout.29|1|https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)^0|L|F|0|11|E|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

I would recommend the following method 'run' and it will help us in getting <a href="https://en.wikipedia.org/wiki/Standard_streams#Standard_output_.28stdout.29" rel="nofollow noreferrer">standard output</a>, <a href="https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)" rel="nofollow noreferrer">standard error</a> and exit status as a dictionary; the caller of this can read the dictionary return by 'run' method to know the actual state of the process.
<pre><code> def run (cmd):
 print &quot;+ DEBUG exec({0})&quot;.format(cmd)
 p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, shell=True)
 (out, err) = p.communicate()
 ret = p.wait()
 out = filter(None, out.split('\n'))
 err = filter(None, err.split('\n'))
 ret = True if ret == 0 else False
 return dict({'output': out, 'error': err, 'status': ret})
 #end
</code></pre>

blocks|key|1543989|text|我已经写了一个包装器来处理错误，重定向输出和其他东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1543990|import+shlex
import+psutil
import+subprocess

def+call_cmd(cmd,+stdout=sys.stdout,+quiet=False,+shell=False,+raise_exceptions=True,+use_shlex=True,+timeout=None):
++++"""Exec+command+by+command+line+like+'ln+-ls+"/var/log"'
++++"""
++++if+not+quiet:
++++++++print("Run+%25s",+str(cmd))
++++if+use_shlex+and+isinstance(cmd,+(str,+unicode)):
++++++++cmd+=+shlex.split(cmd)
++++if+timeout+is+None:
++++++++process+=+subprocess.Popen(cmd,+stdout=stdout,+stderr=sys.stderr,+shell=shell)
++++++++retcode+=+process.wait()
++++else:
++++++++process+=+subprocess.Popen(cmd,+stdout=stdout,+stderr=sys.stderr,+shell=shell)
++++++++p+=+psutil.Process(process.pid)
++++++++finish,+alive+=+psutil.wait_procs([p],+timeout)
++++++++if+len(alive)+>+0:
++++++++++++ps+=+p.children()
++++++++++++ps.insert(0,+p)
++++++++++++print('waiting+for+timeout+again+due+to+child+process+check')
++++++++++++finish,+alive+=+psutil.wait_procs(ps,+0)
++++++++if+len(alive)+>+0:
++++++++++++print('process+{}+will+be+killed'.format([p.pid+for+p+in+alive]))
++++++++++++for+p+in+alive:
++++++++++++++++p.kill()
++++++++++++if+raise_exceptions:
++++++++++++++++print('External+program+timeout+at+{}+{}'.format(timeout,+cmd))
++++++++++++++++raise+CalledProcessTimeout(1,+cmd)
++++++++retcode+=+process.wait()
++++if+retcode+and+raise_exceptions:
++++++++print("External+program+failed+%25s",+str(cmd))
++++++++raise+subprocess.CalledProcessError(retcode,+cmd)|code-block|syntax|javascript|1543991|你可以这样称呼它：|1543992|cmd+=+'ln+-ls+"/var/log"'
stdout+=+'out.txt'
call_cmd(cmd,+stdout)|1543993|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I have written a wrapper to handle errors and redirecting output and other stuff.

<pre><code>import shlex
import psutil
import subprocess

def call_cmd(cmd, stdout=sys.stdout, quiet=False, shell=False, raise_exceptions=True, use_shlex=True, timeout=None):
 """Exec command by command line like 'ln -ls "/var/log"'
 """
 if not quiet:
 print("Run %s", str(cmd))
 if use_shlex and isinstance(cmd, (str, unicode)):
 cmd = shlex.split(cmd)
 if timeout is None:
 process = subprocess.Popen(cmd, stdout=stdout, stderr=sys.stderr, shell=shell)
 retcode = process.wait()
 else:
 process = subprocess.Popen(cmd, stdout=stdout, stderr=sys.stderr, shell=shell)
 p = psutil.Process(process.pid)
 finish, alive = psutil.wait_procs([p], timeout)
 if len(alive) &gt; 0:
 ps = p.children()
 ps.insert(0, p)
 print('waiting for timeout again due to child process check')
 finish, alive = psutil.wait_procs(ps, 0)
 if len(alive) &gt; 0:
 print('process {} will be killed'.format([p.pid for p in alive]))
 for p in alive:
 p.kill()
 if raise_exceptions:
 print('External program timeout at {} {}'.format(timeout, cmd))
 raise CalledProcessTimeout(1, cmd)
 retcode = process.wait()
 if retcode and raise_exceptions:
 print("External program failed %s", str(cmd))
 raise subprocess.CalledProcessError(retcode, cmd)
</code></pre>

You can call it like this:

<pre><code>cmd = 'ln -ls "/var/log"'
stdout = 'out.txt'
call_cmd(cmd, stdout)
</code></pre>

blocks|key|1544422|text|Sultan是一个最新的包，就是为了这个目的。它提供了一些关于管理用户权限和添加有用的错误消息的细节。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1544423|from+sultan.api+import+Sultan

with+Sultan.load(sudo=True,+hostname="myserver.com")+as+sultan:
++sultan.yum("install+-y+tree").run()|code-block|syntax|javascript|1544424|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/aeroxis/sultan^0|0|6|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<a href="https://github.com/aeroxis/sultan" rel="nofollow noreferrer">Sultan</a> is a recent-ish package meant for this purpose. It provides some niceties around managing user privileges and adding helpful error messages.
<pre class="lang-py prettyprint-override"><code>from sultan.api import Sultan

with Sultan.load(sudo=True, hostname=&quot;myserver.com&quot;) as sultan:
 sultan.yum(&quot;install -y tree&quot;).run()
</code></pre>

blocks|key|1544539|text|我将其用于Python+3.6%2B：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1544540|import+subprocess
def+execute(cmd):
++++"""
++++++++Purpose++:+To+execute+a+command+and+return+exit+status
++++++++Argument+:+cmd+-+command+to+execute
++++++++Return+++:+result,+exit_code
++++"""
++++process+=+subprocess.Popen(cmd,+shell=True,+stdout=subprocess.PIPE,+stderr=subprocess.PIPE)
++++(result,+error)+=+process.communicate()
++++rc+=+process.wait()
++++if+rc+!=+0:
++++++++print+("Error:+failed+to+execute+command:+",+cmd)
++++++++print+(error.rstrip().decode("utf-8"))
++++return+result.rstrip().decode("utf-8"),+serror.rstrip().decode("utf-8")
#+def|code-block|syntax|javascript|1544541|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I use this for Python 3.6+:
<pre><code>import subprocess
def execute(cmd):
 &quot;&quot;&quot;
 Purpose : To execute a command and return exit status
 Argument : cmd - command to execute
 Return : result, exit_code
 &quot;&quot;&quot;
 process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 (result, error) = process.communicate()
 rc = process.wait()
 if rc != 0:
 print (&quot;Error: failed to execute command: &quot;, cmd)
 print (error.rstrip().decode(&quot;utf-8&quot;))
 return result.rstrip().decode(&quot;utf-8&quot;), serror.rstrip().decode(&quot;utf-8&quot;)
# def
</code></pre>

How do you call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?

How to execute a program or call a system command?

Windows

Python

Linux

Unix

如何从Python脚本中调用外部命令(就像我在Unix shell或Windows命令提示符下输入的一样)？

问如何执行程序或调用系统命令？
EN

回答 38

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何执行程序或调用系统命令？EN

回答 38

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何执行程序或调用系统命令？
EN