[python] 파이썬에서 외부 명령 호출하기



14 Answers

다음은 외부 프로그램을 호출하는 방법과 각 프로그램의 장단점을 요약 한 것입니다.

  1. os.system("some_command with args") 은 명령과 인수를 시스템 쉘에 전달합니다. 이 방법으로 한 번에 여러 명령을 실행하고 파이프와 입출력 방향 재 지정을 설정할 수 있기 때문에 이점이 좋습니다. 예 :

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

    그러나 이것은 편리하지만 공백과 같은 셸 문자의 이스케이프 처리는 수동으로 처리해야합니다. 반면에 이것은 실제 외부 프로그램이 아닌 셸 명령 인 명령을 실행할 수도 있습니다. 설명서를 참조하십시오.

  2. stream = os.popen("some_command with args")os.system 과 같은 일을 할 것입니다. 단, 프로세스와 관련된 표준 입력 / 출력에 액세스 할 수있는 파일과 유사한 객체를 제공합니다. 모든 3 가지 I / O를 약간 다르게 처리하는 popen의 다른 변종이 있습니다. 모든 것을 문자열로 전달하면 명령이 셸로 전달됩니다. 목록으로 전달하면 아무 것도 피할 걱정할 필요가 없습니다. 설명서를 참조하십시오.

  3. subprocess 모듈의 Popen 클래스입니다. 이것은 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. subprocess 모듈의 call 함수. 이것은 기본적으로 Popen 클래스와 같으며 모든 동일한 인수를 사용하지만 명령이 완료 될 때까지 대기하고 리턴 코드를 제공합니다. 예 :

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

    설명서를 참조하십시오.

  5. 파이썬 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 /"라고 입력했다고 상상해보십시오.

Question

파이썬 스크립트 내에서 외부 명령 (예 : 유닉스 쉘 또는 Windows 명령 프롬프트에서 입력 한 것처럼)을 호출하려면 어떻게해야합니까?




이것이 제가 명령을 실행하는 방법입니다. 이 코드에는 필요한 모든 것이 있습니다.

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



"pexpect"Python 라이브러리도 확인하십시오.

ssh, ftp, telnet 등 외부 프로그램 / 명령을 대화식으로 제어 할 수 있습니다. 다음과 같이 입력하면됩니다.

child = pexpect.spawn('ftp 192.168.0.24')

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

child.sendline('anonymous')

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



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

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

산출:

This process detail:
python.exe                     604 RDP-Tcp#0                  4      5,660 K



os.system 은 괜찮지 만 날짜는 종류가 다릅니다. 그것은 또한 안전하지 않습니다. 대신 subprocess 사용해보십시오. subprocess 는 sh를 직접 호출하지 않으므로 os.system 보다 안전 os.system .

여기에서 자세한 정보를 얻으십시오.




subprocess.check_call 은 반환 값을 테스트하지 않으려는 경우에 편리합니다. 오류가 발생하면 예외가 발생합니다.




Popen을 사용할 수 있으며 프로 시저의 상태를 확인할 수 있습니다.

from subprocess import Popen

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

subprocess.Popen 확인하십시오. subprocess.Popen .




호출 프로세스에서 자식 프로세스 분리 (백그라운드에서 자식 프로세스 시작)에 대한 힌트.

자식 프로세스가 CGI 스크립트 실행 프로세스보다 오래 살아야한다는 CGI 스크립트에서 긴 작업을 시작한다고 가정하십시오.

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

import subprocess
import sys

# some code here

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

# some more code here

여기에있는 아이디어는 longtask.py가 끝날 때까지 'call subprocess'라인에서 기다리고 싶지 않다는 것입니다. 그러나 예제에서 "여기에 더 많은 코드가 있습니다"라는 줄 뒤에 어떤 일이 발생하는지는 명확하지 않습니다.

내 타겟 플랫폼은 무료 였지만 개발은 창문에 있었기 때문에 창문에 먼저 문제가 발생했습니다.

윈도우에서 (win xp), longtask.py가 작업을 마칠 때까지 부모 프로세스는 끝나지 않을 것이다. CGI 스크립트에서 원하는 것이 아닙니다. 문제는 파이썬에만 국한되지 않습니다. 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에서의 행동의 이유를 모른다. 누구라도 알고 있다면 아이디어를 공유하십시오. 파이썬에서 배경 프로세스를 시작한다고해서 아직 밝혀지지 않았다.




파이썬에서 외부 명령 호출하기

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부터, 문서에서는 subprocess.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):

popenargskwargspopenargs 생성자에게 주어집니다. input 은 하위 프로세스의 표준 입력으로 파이프되는 바이트 문자열 (또는 인코딩을 지정하는 경우 유니 코드 또는 universal_newlines=True )이 될 수 있습니다.

설명서는 timeout=check=True 보다 더 잘 설명합니다.

timeout 인수는 Popen.communicate ()에 전달됩니다. 시간 초과가 만료되면 하위 프로세스가 종료되고 대기합니다. 자식 프로세스가 종료 된 후 TimeoutExpired 예외가 다시 발생합니다.

check가 true이고 프로세스가 0이 아닌 종료 코드로 종료되면 CalledProcessError 예외가 발생합니다. 해당 예외의 속성에는 인수, 종료 코드 및 캡처 된 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 을 사용할 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.popen 을 사용할 수 있습니다. 그러나이 버전은 하위 프로세스 모듈 을 위해 버전 2.6부터 사용되지 않으며, 다른 답변은 잘 설명되어 있습니다.




최신 정보:

코드가 이전 Python 버전과의 호환성을 유지할 필요가없는 경우 subprocess.runPython 3.5 에서 권장되는 방법입니다. 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')

원문 답변 :

나는 https://github.com/kennethreitz/envoy 것이 좋습니다. 이것은 하위 프로세스의 래퍼이며, 이전 모듈과 함수 를 대체 하는 것을 목표로 합니다. 특사는 인간을위한 하위 프로세스입니다.

readme의 사용 예 :

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



필요한 것은 호출중인 명령의 출력입니다.
subprocess.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'

또한 shell 매개 변수에 유의하십시오.

shell이 True 이면 지정된 명령이 쉘을 통해 실행됩니다. 이것은 대부분의 시스템 셸에서 제공하는 확장 된 제어 흐름을 위해 주로 파이썬을 사용하고 있으며 셸 파이프, 파일 이름 와일드 카드, 환경 변수 확장 및 ~을 사용자의 집으로 확장하는 것과 같은 다른 셸 기능에 편리하게 액세스하려는 경우 유용 할 수 있습니다 예배 규칙서. 그러나 Python 자체는 많은 셸과 유사한 기능 (특히 glob , fnmatch , os.walk() , os.path.expandvars() , os.path.expanduser()shutil )의 구현을 제공합니다.




os.system 은 결과를 저장하는 것을 허용하지 않기 때문에 결과를 일부 목록이나 무언가에 저장하려는 경우 subprocess.call 작동합니다.




또한 Plumbum

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



openstack 중성자에서 네트워크 ID를 가져 오려면 다음을 수행하십시오.

#!/usr/bin/python
import os
netid= "nova net-list | awk '/ External / { print $2 }'"
temp=os.popen(netid).read()  /* here temp also contains new line (\n) */
networkId=temp.rstrip()
print(networkId)

노바 네트리스트의 출력

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

인쇄 출력 (networkId)

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


Related