Python での外部コマンドの呼び出し

StackOverflow https://stackoverflow.com/questions/89228

質問

外部コマンドを (Unix シェルまたは Windows コマンド プロンプトで入力したかのように) 内部から呼び出すにはどうすればよいですか? Python 脚本？

役に立ちましたか？

解決

見てください サブプロセスモジュール 標準ライブラリ内:

import subprocess
subprocess.run(["ls", "-l"])

の利点 サブプロセス 対 システム それは、より柔軟であるということです (stdout、stderr、「実際の」ステータス コードを取得できる、エラー処理が改善されるなど)。

の 公式ドキュメント を推奨します サブプロセス モジュールを代替の os.system() に置き換えます。

の サブプロセス モジュールは、新しいプロセスを生成し、その結果を取得するためのより強力な機能を提供します。この関数を使用するよりも、そのモジュールを使用することをお勧めします。os.system()].

」古い関数をサブプロセス モジュールに置き換える」セクションの サブプロセス ドキュメントには役立つレシピが記載されている場合があります。

Python の古いバージョンでは次の呼び出しを使用します。

import subprocess
subprocess.call(["ls", "-l"])

他のヒント

以下に、外部プログラムを呼び出す方法と、それぞれの長所と短所をまとめます。

  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 ただし、そのプロセスの標準入出力にアクセスするために使用できるファイルのようなオブジェクトが提供されます。Popen には他に 3 つの亜種があり、すべて I/O の処理方法が若干異なります。すべてを文字列として渡すと、コマンドがシェルに渡されます。それらをリストとして渡す場合は、何もエスケープすることを心配する必要はありません。見る 文書.

  3. の Popen のクラス subprocess モジュール。これは、次の代替品として意図されています。 os.popen ただし、非常に包括的であるため、若干複雑になるという欠点があります。たとえば、次のように言うでしょう。

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

    の代わりに： 

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

    ただし、4 つの異なる Popen 関数ではなく、すべてのオプションを 1 つの統合クラスに含めることができるのは便利です。見る 文書.

  4. の call からの関数 subprocess モジュール。これは基本的には次のとおりです Popen class を作成し、同じ引数をすべて受け取りますが、コマンドが完了してリターン コードが返されるまで待機するだけです。例えば：

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

    見る 文書.

  5. Python 3.5 以降を使用している場合は、新しい subprocess.run この関数は上記とよく似ていますが、さらに柔軟で、 CompletedProcess コマンドの実行が終了するとオブジェクトが作成されます。

  6. os モジュールには、C プログラムにある fork/exec/spawn 関数もすべてありますが、これらを直接使用することはお勧めしません。

の subprocess module はおそらくあなたが使用するものであるはずです。

最後に、シェルによって実行される最終コマンドを文字列として渡すすべてのメソッドでは、それをエスケープする責任があることに注意してください。 セキュリティに重大な影響があります 渡した文字列の一部が完全に信頼できない場合。たとえば、ユーザーが文字列の一部を入力している場合などです。よくわからない場合は、これらのメソッドを定数とともにのみ使用してください。影響のヒントを得るために、次のコードを考えてみましょう。

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

そして、ユーザーが「ママは私を愛していなかった && rm -rf /」と入力すると、ファイルシステム全体が消去される可能性があると想像してください。

私は通常、次のものを使用します。

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().

呼び出し元のプロセスから子プロセスを切り離す (バックグラウンドで子プロセスを開始する) ためのヒント。

CGI スクリプトから長いタスクを開始するとします。つまり、子プロセスは CGI スクリプト実行プロセスよりも長く存続する必要があります。

subprocess モジュールのドキュメントの古典的な例は次のとおりです。

import subprocess
import sys

# some code here

pid = subprocess.Popen([sys.executable, "longtask.py"]) # call subprocess

# some more code here

ここでの考え方は、longtask.py が完了するまで「call subprocess」行で待機したくないということです。しかし、この例の「some more code here」という行の後に何が起こるかは明らかではありません。

私のターゲット プラットフォームは freebsd でしたが、開発は Windows 上で行われたため、最初に Windows 上で問題に直面しました。

Windows (Win XP) では、longtask.py が作業を完了するまで親プロセスは終了しません。これは CGI スクリプトで必要なものではありません。この問題は Python に固有のものではなく、PHP コミュニティでも問題は同じです。

解決策は DETACHED_PROCESS を渡すことです プロセス作成フラグ Win API の基礎となる CreateProcess 関数に追加します。pywin32 をインストールしている場合は、win32process モジュールからフラグをインポートできます。それ以外の場合は、自分で定義する必要があります。

DETACHED_PROCESS = 0x00000008

pid = subprocess.Popen([sys.executable, "longtask.py"],
                       creationflags=DETACHED_PROCESS).pid

/* 2015.10.27更新 @eryksun は以下のコメントで、意味的に正しいフラグは CREATE_NEW_CONSOLE (0x00000010) */ であると述べています。

freebsd には別の問題があります。親プロセスが終了すると、子プロセスも終了します。そして、それは CGI スクリプトで望むものでもありません。いくつかの実験では、問題は sys.stdout の共有にあるようであることがわかりました。そして、実用的な解決策は次のとおりでした。

pid = subprocess.Popen([sys.executable, "longtask.py"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)

他のプラットフォームでコードをチェックしたことがないので、freebsd での動作の理由がわかりません。知っている人がいたら、あなたのアイデアを共有してください。Python でのバックグラウンド プロセスの開始についてグーグルで検索しても、まだ何も明らかになっていません。

os.system の代わりに subprocess モジュールを使用することをお勧めします。これはシェルエスケープを行うため、はるかに安全であるためです。 http://docs.python.org/library/subprocess.html

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

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

コマンドの結果を返したい場合は、次のように使用できます。 os.popen. 。ただし、これはバージョン 2.6 以降では非推奨になり、 サブプロセスモジュール, 、他の回答でよくカバーされています。

import os
os.system("your command")

コマンドはクリーンアップされていないため、これは危険であることに注意してください。「os」および「sys」モジュールに関する関連ドキュメントをグーグルで検索するのはあなた次第です。同様のことを行う関数 (exec* と spawn*) が多数あります。

Python で外部コマンドを呼び出すことができるさまざまなライブラリが多数あります。各ライブラリについて説明を行い、外部コマンドを呼び出す例を示しました。例として使用したコマンドは次のとおりです ls -l (すべてのファイルをリストします)。ライブラリについてさらに詳しく知りたい場合は、それぞれのドキュメントをリストしてリンクしました。

出典:

これらはすべて次のライブラリです。

これがどのライブラリを使用するかを決定するのに役立つことを願っています:)

サブプロセス

サブプロセスを使用すると、外部コマンドを呼び出し、その入力/出力/エラー パイプ (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

os は「オペレーティング システムに依存する機能」に使用されます。外部コマンドを呼び出すためにも使用できます。 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

鉛直

plumbum は、「スクリプトのような」Python プログラム用のライブラリです。次のように関数のようなプログラムを呼び出すことができます。 sh. 。Plumbum は、シェルなしでパイプラインを実行する場合に便利です。

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

期待する

pexpect を使用すると、子アプリケーションを生成し、それらを制御し、出力内のパターンを見つけることができます。これは、Unix 上で tty を必要とするコマンドのサブプロセスに代わるより良い方法です。

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

ファブリック

Fabric は Python 2.5 および 2.7 ライブラリです。これにより、ローカルおよびリモートのシェル コマンドを実行できるようになります。ファブリックは、セキュア シェル (SSH) でコマンドを実行するためのシンプルな代替手段です。

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

使者

envoy は「人間用のサブプロセス」として知られています。これは、便利なラッパーとして使用されます。 subprocess モジュール。

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

コマンド

commands のラッパー関数が含まれています os.popen, ですが、Python 3 以降は削除されました。 subprocess より良い代替手段です。

編集は J.F.セバスチャンのコメント。

いつも使っています fabric これについては次のようなものです。

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

しかし、これは良いツールのようです: sh (Python サブプロセス インターフェイス).

例を見てみましょう:

from sh import vgdisplay
print vgdisplay()
print vgdisplay('-v')
print vgdisplay(v=True)

「pexpect」Python ライブラリも確認してください。

これにより、ssh、ftp、telnet などの外部プログラム/コマンドの対話型制御が可能になります。次のように入力するだけです:

child = pexpect.spawn('ftp 192.168.0.24')

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

child.sendline('anonymous')

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

呼び出しているコマンドからの出力が必要な場合は、使用できます サブプロセス.check_output (Python 2.7 以降)。

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

また、 シェル パラメータ。

シェルの場合 True, を指定すると、指定されたコマンドがシェルを通じて実行されます。これは、ほとんどのシステム シェルに対して提供される強化された制御フローを主に目的として Python を使用しており、シェル パイプ、ファイル名ワイルドカード、環境変数の展開、ユーザー ホームへの ~ の展開などの他のシェル機能に便利にアクセスしたい場合に便利です。ディレクトリ。ただし、Python 自体が多くのシェルに似た機能 (特に、 glob, fnmatch, os.walk(), os.path.expandvars(), os.path.expanduser(), 、 そして shutil).

標準ライブラリあり

使用 サブプロセスモジュール (Python 3):

import subprocess
subprocess.run(['ls', '-l'])

これは推奨される標準的な方法です。ただし、より複雑なタスク (パイプ、出力、入力など) は、構築したり記述したりするのが面倒な場合があります。

Python のバージョンに関する注意:まだ Python 2 を使用している場合は、 サブプロセスの呼び出し 同様の方法で動作します。

プロのヒント: シュレックス.スプリット コマンドを解析するのに役立ちます run, call, 、その他 subprocess 関数をリスト形式で提供したくない場合 (または提供できない場合):

import shlex
import subprocess
subprocess.run(shlex.split('ls -l'))

外部依存関係がある場合

外部依存関係を気にしない場合は、次を使用します 鉛直:

from plumbum.cmd import ifconfig
print(ifconfig['wlan0']())

それがベストだ subprocess ラッパー。クロスプラットフォームです。Windows と Unix 系システムの両方で動作します。インストール方法 pip install plumbum.

もう 1 つの人気のあるライブラリは、 しー:

from sh import ifconfig
print(ifconfig('wlan0'))

しかし、 sh Windows のサポートが終了したため、以前ほど素晴らしくなくなりました。インストール方法 pip install sh.

これがコマンドの実行方法です。このコードには必要なものがほぼすべて含まれています

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()

アップデート：

subprocess.run 推奨されるアプローチです Python 3.5以降 コードが以前の Python バージョンとの互換性を維持する必要がない場合。より一貫性があり、Envoy と同様の使いやすさを提供します。（ただし、配管はそれほど単純ではありません。見る この質問はどうやって.)

以下にいくつかの例を示します ドキュメント.

プロセスを実行します。

>>> 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')

元の答え:

試してみることをお勧めします 特使. 。これはサブプロセスのラッパーであり、 置き換えることを目的としています 古いモジュールと関数。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'>]

結果を出力しない場合:

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

結果の出力:

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

https://docs.python.org/2/library/subprocess.html

...または非常に単純なコマンドの場合:

import os
os.system('cat testfile')

もあります プラムバム

>>> 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 それはOKですが、ちょっと時代遅れです。また、あまり安全ではありません。代わりに試してみてください subprocess. subprocess sh を直接呼び出さないため、より安全です。 os.system.

さらに詳しい情報を得る ここ.

Python での外部コマンドの呼び出し

シンプルです、使ってください subprocess.run, を返します。 CompletedProcess 物体：

>>> 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)

なぜ？

Python 3.5 以降、ドキュメントでは次のように推奨されています。 サブプロセス.run:

サブプロセスを呼び出すための推奨されるアプローチは、処理できるすべてのユースケースに対して run() 関数を使用することです。より高度な使用例では、基礎となる Popen インターフェイスを直接使用できます。

以下は最も単純な使用法の例です - 要求どおりに動作します。

>>> 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 物体。代わりに引き上げられる可能性があります TimeoutExpired (もしあなたがそれを与えたら 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''

(バージョン情報が 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 バイト文字列 (または、エンコーディングを指定する場合は Unicode) にすることができます。 universal_newlines=True) サブプロセスの標準入力にパイプされます。

ドキュメントでは次のように説明されています timeout= そして check=True 私よりも上手に：

タイムアウト引数は Popen.communicate() に渡されます。タイムアウトの有効期限が切れた場合、子どものプロセスが殺され、待機されます。TimeOutExpiredの例外は、子プロセスが終了した後に再作成されます。

チェックが真であり、プロセスがゼロ以外の出口コードで終了する場合、呼び出されたプロセッソロール例外が発生します。その例外の属性は、引数、出口コード、およびそれらがキャプチャされた場合は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 ただし、次のようなメソッドにアクセスできるようになります。 poll, 、「send_signal」、「terminate」、および「wait」。

こちらが Popen で与えられた署名 起源. 。これは情報を最も正確にカプセル化したものだと思います ( 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（） - のような動作を使用して子どもプログラムを実行します。Windowsでは、クラスはWindows CreateProcess（）関数を使用します。Popenへの議論は次のとおりです。

残りのドキュメントを理解する Popen 読者の演習として残しておきます。

使用：

import os

cmd = 'ls -al'

os.system(cmd)

os - このモジュールは、オペレーティング システムに依存する機能を使用するポータブルな方法を提供します。

さらに詳しく os 機能、 ここ はドキュメントです。

これは次のように簡単です。

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

OSモジュールを使用する

import os
os.system("your command")

例えば

import os
os.system("ifconfig")

subprocess.check_call 戻り値をテストしたくない場合に便利です。エラーが発生すると例外がスローされます。

私がよく使うのは サブプロセス 一緒に シュレックス (引用符で囲まれた文字列のエスケープを処理するため):

>>> 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.Popen <command> をサブプロセスとして実行します。私の場合、別のプログラム <b> と通信する必要があるファイル <a> を実行する必要があります。

サブプロセスを実行してみたところ、正常に実行されました。しかし<b>は<a>と通信できませんでした。ターミナルから両方を実行すると、すべてが正常です。

もう 1 つ:（注記：kwrite は他のアプリケーションとは異なる動作をします。Firefox で以下を試しても、結果は同じではありません。)

試してみると os.system("kwrite"), 、ユーザーが kwrite を閉じるまで、プログラム フローはフリーズします。それを克服するために、代わりに試してみました os.system(konsole -e kwrite). 。今回もプログラムは流れ続けましたが、kwrite はコンソールのサブプロセスになりました。

サブプロセスではなく誰でも kwrite を実行します (つまり、システム モニターでは、ツリーの左端に表示される必要があります)。

os.system 結果を保存することはできないため、結果をリストなどに保存したい場合は、 subprocess.call 動作します。

かなり好きです シェルコマンド そのシンプルさのために。これはサブプロセス モジュールの上に構築されます。

ドキュメントの例は次のとおりです。

>>> 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

恥知らずなプラグ、私はこれ用のライブラリを書きました:Phttps://github.com/houqp/shell.py

現時点では基本的に Popen と Shlex のラッパーです。また、パイプコマンドもサポートしているため、Python でコマンドを簡単に連鎖させることができます。したがって、次のようなことができます。

ex('echo hello shell.py') | "awk '{print $2}'"

Linux では、独立して実行される (Python スクリプトの終了後も実行され続ける) 外部コマンドを呼び出したい場合は、単純なキューを次のように使用できます。 タスクスプーラ または で 指示

タスクスプーラーを使用した例:

import os
os.system('ts <your-command>')

タスクスプーラーに関する注意事項 (ts):

  1. 次のようにして、実行する同時プロセス (「スロット」) の数を設定できます。

    ts -S <number-of-slots>

  2. インストール中 ts 管理者権限は必要ありません。簡単な方法でソースからダウンロードしてコンパイルできます。 make, 、パスに追加すれば完了です。

Popen を使用すると、プロシージャのステータスを確認できます。

from subprocess import Popen

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

チェックアウト サブプロセス.Popen.

ライセンス： CC-BY-SA と 帰属
所属していません StackOverflow
scroll top