Python에서 외부 명령 호출

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

문제

Unix 셸이나 Windows 명령 프롬프트에 입력한 것처럼 외부 명령을 호출하려면 어떻게 해야 합니까? Python 스크립트?

도움이 되었습니까?

해결책

를보세요 하위 프로세스 모듈 표준 라이브러리에서:

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

장점 하위 프로세스 대 체계 더 유연하다는 것입니다(stdout, stderr, "실제" 상태 코드, 더 나은 오류 처리 등을 얻을 수 있습니다).

그만큼 공식 문서 추천한다 하위 프로세스 대체 os.system()에 대한 모듈:

그만큼 하위 프로세스 모듈은 새로운 프로세스를 생성하고 그 결과를 검색하기 위한 보다 강력한 기능을 제공합니다.해당 모듈을 사용하는 것이 이 기능을 사용하는 것보다 바람직합니다.os.system()].

"이전 기능을 subprocess 모듈로 교체" 섹션의 하위 프로세스 문서에는 몇 가지 유용한 방법이 있을 수 있습니다.

이전 버전의 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 단, 해당 프로세스에 대한 표준 입력/출력에 액세스하는 데 사용할 수 있는 파일과 같은 객체를 제공한다는 점만 다릅니다.i/o를 약간 다르게 처리하는 3가지 다른 popen 변형이 있습니다.모든 것을 문자열로 전달하면 명령이 셸로 전달됩니다.목록으로 전달하면 어떤 것도 이스케이프 처리하는 것에 대해 걱정할 필요가 없습니다.보다 문서.

  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 함수 대신 하나의 통합 클래스에 모든 옵션을 포함하는 것이 좋습니다.보다 문서.

  4. 그만큼 call 에서 기능 subprocess 기준 치수.이것은 기본적으로 다음과 같습니다. Popen 클래스를 사용하고 동일한 인수를 모두 사용하지만 명령이 완료될 때까지 기다렸다가 반환 코드를 제공합니다.예를 들어:

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

    보다 문서.

  5. Python 3.5 이상을 사용하는 경우 새로운 기능을 사용할 수 있습니다. subprocess.run 함수는 위와 비슷하지만 훨씬 더 유연하며 다음을 반환합니다. CompletedProcess 명령 실행이 완료되면 개체가 생성됩니다.

  6. os 모듈에는 C 프로그램에 있는 모든 fork/exec/spawn 기능도 있지만 직접 사용하는 것은 권장하지 않습니다.

그만큼 subprocess 모듈은 아마도 당신이 사용하는 것일 것입니다.

마지막으로 셸에서 실행할 최종 명령을 문자열로 전달하는 모든 메서드에 대해 이를 이스케이프 처리해야 한다는 점에 유의하세요. 보안에 심각한 영향을 미칩니다 전달한 문자열의 일부를 완전히 신뢰할 수 없는 경우.예를 들어, 사용자가 문자열의 일부/일부를 입력하는 경우입니다.확실하지 않은 경우 상수와 함께 이러한 메서드만 사용하세요.의미에 대한 힌트를 제공하려면 다음 코드를 고려하십시오.

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

그리고 사용자가 전체 파일 시스템을 지울 수 있는 "my mama didnt love me && 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 스크립트 실행 프로세스보다 오래 지속되어야 합니다.

하위 프로세스 모듈 문서의 전형적인 예는 다음과 같습니다.

import subprocess
import sys

# some code here

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

# some more code here

여기서의 아이디어는 longtask.py가 완료될 때까지 'call subprocess' 줄에서 기다리기를 원하지 않는다는 것입니다.그러나 예제에서 '여기에 코드가 더 있습니다'라는 줄 다음에 무슨 일이 일어나는지는 명확하지 않습니다.

제가 타깃으로 삼은 플랫폼은 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

/* UPD 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' 모듈에 대한 관련 문서는 Google에 맡기겠습니다.유사한 작업을 수행하는 함수(exec* 및 generate*)가 많이 있습니다.

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.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 라이브러리입니다.로컬 및 원격 쉘 명령을 실행할 수 있습니다.Fabric은 SSH(보안 셸)에서 명령을 실행하기 위한 간단한 대안입니다.

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

사절

특사는 "인간을 위한 하위 프로세스"로 알려져 있습니다.주변의 편의 포장지로 사용됩니다. 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 (파이썬 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).

표준 라이브러리 포함

사용 하위 프로세스 모듈 (파이썬 3):

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

권장되는 표준 방법입니다.그러나 더 복잡한 작업(파이프, 출력, 입력 등)은 구성하고 작성하는 데 지루할 수 있습니다.

Python 버전에 대한 참고 사항:아직 Python 2를 사용하고 계시다면, 하위 프로세스.호출 비슷한 방식으로 작동합니다.

전문가 팁: shlex.split 명령을 구문 분석하는 데 도움이 될 수 있습니다. 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.

또 다른 인기 있는 도서관은 쉿:

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 권장되는 접근 방식입니다 파이썬 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 괜찮지만 좀 오래된 것 같아요.또한 그다지 안전하지도 않습니다.대신 시도해 보세요. 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() 함수를 사용하는 것입니다.고급 사용 사례의 경우 기본 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 바이트 문자열(또는 인코딩을 지정하는 경우 유니코드 또는 유니코드)일 수 있습니다. universal_newlines=True) 하위 프로세스의 stdin으로 파이프됩니다.

설명서에서는 다음과 같이 설명합니다. timeout= 그리고 check=True 내가 할 수 있는 것보다 더 나은:

timeout 인수는 Popen.communicate()에 전달됩니다.시간 초과가 만료되면 아동 절차가 사망하고 기다릴 것입니다.아동 프로세스가 종료 된 후에 타임 아웃 엑시 페어 예외는 다시 제작됩니다.

확인이 사실이고 프로세스가 0이 아닌 출구 코드로 종료되면 호출 프로세서 예외가 제기됩니다.해당 예외의 속성은 인수, 출구 코드 및 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)

이는 args 목록만 위치적으로 전달되어야 함을 나타냅니다.따라서 나머지 인수를 키워드 인수로 전달하십시오.

포펜

사용시 Popen 대신에?나는 주장만으로 유스 케이스를 찾는 데 어려움을 겪을 것입니다.직접 사용 Popen 그러나 다음을 포함한 해당 방법에 대한 액세스를 제공합니다. poll, 'send_signal', '종료' 및 '대기'.

여기에 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>와 통신할 수 없습니다.터미널에서 둘 다 실행하면 모든 것이 정상입니다.

하나 더:(메모:kwrite는 다른 응용 프로그램과 다르게 동작합니다.Firefox에서 아래를 시도하면 결과가 동일하지 않습니다.)

당신이 시도한다면 os.system("kwrite"), 사용자가 kwrite를 닫을 때까지 프로그램 흐름이 정지됩니다.그것을 극복하기 위해 대신 노력했습니다 os.system(konsole -e kwrite).이번 프로그램은 계속 진행되었지만 kwrite는 콘솔의 하위 프로세스가 되었습니다.

누구나 하위 프로세스가 아닌 kwrite를 실행합니다(예:시스템 모니터에서는 트리의 가장 왼쪽 가장자리에 나타나야 합니다.

os.system 결과를 저장할 수 없으므로 일부 목록이나 다른 항목에 결과를 저장하려는 경우 subprocess.call 공장.

나는 굉장히 좋아한다 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

뻔뻔한 플러그, 나는 이것을 위한 라이브러리를 작성했습니다 :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