Der Aufruf eines externen Kommandos in Python

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

Frage

Wie kann ich einen externen Befehl aufrufen (als ob ich es an der Unix-Shell eingegeben würde oder Windows-Eingabeaufforderung) aus einem Python Skript?

War es hilfreich?

Lösung

Sehen Sie sich die Subprozess Modul in der Standardbibliothek: 

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

Der Vorteil von subprocess vs. System ist, dass es flexibler ist (Sie können die stdout bekommen können, stderr, die "echte" Statuscode, eine bessere Fehlerbehandlung, etc ...).

Die rel="noreferrer"> empfiehlt die subprocess Modul über die alternative os.system ():

  

Die subprocess Modul bietet leistungsstärkere Anlagen für neue Prozesse Laichen und ihre Ergebnisse abrufen; dieses Modul verwendet, ist vorzuziehen, um diese Funktion zu verwenden [ os.system() ].

Die „ Ersatz älterer Funktionen mit der Subprozess Modul “Abschnitt in der subprocess Dokumentation kann einige hilfreiche Rezepte haben.

ältere Versionen von Python Verwendung Aufruf: 

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

Andere Tipps

Hier ist eine Zusammenfassung der Möglichkeiten, externe Programme aufzurufen und die Vor- und Nachteile der einzelnen:

  1. os.system("some_command with args") gibt den Befehl und Argumente Shell Ihr System. Das ist schön, weil man tatsächlich mehrere Befehle auf einmal auf diese Weise und richtete Rohre und Ein- / Ausgabe-Umleitung ausführen kann. Zum Beispiel: 

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

    Doch während dies bequem ist, müssen Sie manuell die entweichenden von Shell-Zeichen wie Leerzeichen behandeln usw. Auf der anderen Seite, auf diese Weise können Sie auch Befehle ausführen, die einfach Shell-Befehle sind und nicht wirklich externe Programme. Siehe die Dokumentation .

  2. stream = os.popen("some_command with args") wird das gleiche wie os.system außer tun, es gibt Ihnen ein dateiähnliche Objekt, das Sie Standard-Ein- / Ausgang für diesen Prozess zugreifen können. Es gibt drei andere Varianten von popen, die alle die i / o etwas anders handhaben. Wenn Sie alles als String übergeben, dann wird Ihr Befehl an die Shell übergeben; wenn man sie als eine Liste übergeben, dann brauchen Sie sich nicht um Flucht nichts zu kümmern. Siehe die Dokumentation .

  3. Die Popen Klasse des subprocess Modul. Dies wird als Ersatz für os.popen gedacht, hat aber den Nachteil leicht durch mehr kompliziert ist so umfassend zu sein. Zum Beispiel, würden Sie sagen: 

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

    statt: 

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

    , aber es ist schön, alle Optionen gibt es in einer einheitlichen Klasse anstelle von 4 verschiedenen popen Funktionen. Siehe die Dokumentation .

  4. Die call Funktion aus dem subprocess Modul. Dies ist im Grunde genau wie die Popen Klasse und nimmt alle die gleichen Argumente, aber es wartet einfach, bis der Befehl abgeschlossen ist und gibt Ihnen den Return-Code. Zum Beispiel: 

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

    Siehe die Dokumentation .

  5. Wenn Sie auf Python 3.5 oder höher, können Sie die neuen subprocess.run -Funktion, die eine Menge, wie die oben, aber noch flexibler ist und gibt ein CompletedProcess Objekt, wenn der Befehl ausgeführt wird beendet.

  6. Das os-Modul hat auch alle die fork / exec / Laich Funktionen, die Sie in einem C-Programm haben würden, aber ich empfehle sie nicht direkt verwendet wird.

Das subprocess Modul sollte wohl sein, was Sie verwenden.

Schließlich bitte beachten Sie, dass für alle Verfahren, bei denen Sie den letzten Befehl übergeben von dem Shell als String ausgeführt werden, und Sie sind verantwortlich für die es zu entkommen. Es gibt ernsthafte Auswirkungen auf die Sicherheit , wenn ein Teil der Zeichenfolge, die Sie nicht vollständig vertraut werden passieren. Wenn beispielsweise ein Benutzer some / jeden Teil der Zeichenfolge eintritt. Wenn Sie unsicher sind, nur diese Methoden mit Konstanten verwenden. Um Ihnen einen Hinweis auf die Auswirkungen berücksichtigen diesen Code: 

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

und sich vorstellen, dass der Benutzer etwas eingibt „meine Mama didnt mich lieben && rm -rf /“, die das gesamte Dateisystem löschen könnte.

ich in der Regel verwenden: 

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

Sie sind frei zu tun, was Sie mit den stdout Daten im Rohr soll. In der Tat, können Sie einfach die Parameter (stdout= und stderr=) auslassen und es wird wie os.system() verhalten.

Einige Hinweise auf Abnehmen des Kind-Prozess vom rufenden ein (Start der Kind-Prozess im Hintergrund).

Angenommen, Sie eine lange Aufgabe aus einem CGI-Skript gestartet werden sollen, dass das Kind Prozess länger leben soll als der CGI-Skript-Ausführungsprozess.

Das klassische Beispiel von den Subprozess Modul docs ist: 

import subprocess
import sys

# some code here

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

# some more code here

Die Idee dabei ist, dass Sie in der Leitung warten wollen ‚nennen subprocess‘ nicht, bis die longtask.py beendet ist. Aber es ist nicht klar, was nach der Zeile geschieht ‚einig mehr Code hier‘ aus dem Beispiel.

Meine Zielplattform war freebsd, aber die Entwicklung war auf Fenster, so stand ich das Problem auf Windows zuerst.

Unter Windows (Win XP), wird der übergeordnete Prozess nicht beenden, bis die longtask.py seine Arbeit beendet hat. Es ist nicht das, was Sie in CGI-Skript soll. Das Problem ist nicht spezifisch für Python, in PHP-Community die Probleme sind die gleichen.

Die Lösung ist DETACHED_PROCESS Prozesserzeugungstrap Flag auf die zugrunde liegende Funktion Create in win API. Wenn Sie installiert haben, passieren pywin32 Sie das Kennzeichen aus dem win32process Modul importieren, ansonsten sollte man es selbst definieren: 

DETACHED_PROCESS = 0x00000008

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

/ * UPD 2015.10.27 @eryksun in einem Kommentar unter Notizen, dass der semantisch korrekte Flag CREATE_NEW_CONSOLE (0x00000010) * /

Seit Version haben wir ein weiteres Problem: Wenn der übergeordnete Prozess beendet ist, beendet sie die Child-Prozesse als auch. Und das ist nicht das, was Sie in CGI-Skript wollen entweder. Einige Experimente haben gezeigt, dass das Problem bei der gemeinsamen Nutzung sys.stdout zu sein schien. Und die Arbeitslösung wurde wie folgt vor: 

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

Ich habe nicht den Code auf anderen Plattformen geprüft und weiß nicht, die Gründe für das Verhalten auf freebsd. Wenn jemand weiß, bitte teilen Sie Ihre Ideen. Googeln auf Hintergrundprozesse in Python beginnen zu vergießen kein Licht noch.

Ich würde empfehlen, das Subprozess Modul statt os.system verwenden, weil es Shell für Sie tut entkommen und ist daher viel sicherer: http://docs.python.org/library/subprocess.html 

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

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

Wenn Sie die Ergebnisse des Befehls zurückkehren möchten, können Sie os.popen . Allerdings ist diese seit Version veraltet 2.6 für die Subprozess Modul , die auch noch andere Antworten abgedeckt. 

import os
os.system("your command")

Beachten Sie, dass dies gefährlich, da der Befehl nicht gereinigt wird. Ich überlasse es Ihnen, für die entsprechende Dokumentation auf dem ‚o‘ to google und ‚sys‘ Module. Es gibt eine Reihe von Funktionen (exec * und Spawn *), die ähnliche Dinge tun wird.

Es gibt viele verschiedene Bibliotheken mit denen Sie externe Befehle mit Python nennen. Für jede Bibliothek habe ich eine Beschreibung gegeben und ein Beispiel für den Aufruf eines externen Befehl gezeigt. Der Befehl, den ich als Beispiel verwendete ls -l (Liste aller Dateien). Wenn Sie mehr über eine der Bibliotheken, um herauszufinden, ich aufgeführt habe und verknüpfen die Dokumentation für jeden von ihnen.

  

Quellen:

  
    
      

Dies sind alle Bibliotheken:

    
  

Hoffentlich wird Ihnen helfen, eine Entscheidung zu treffen, die Bibliothek zu nutzen:)

  

subprocess

Subprocess können Sie externe Befehle aufrufen und schließen sie an ihren Eingang / Ausgang / Fehlerleitungen (stdin, stdout und stderr). Subprocess ist die Standardeinstellung Befehle für die Ausführung, aber manchmal andere Module sind besser. 

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

o ist für „Betriebssystem abhängige Funktionalität“ verwendet. Es kann auch externe Befehle mit os.system und os.popen (Anmerkung: Es gibt auch ein subprocess.Popen) nennen verwendet werden. os immer die Shell ausgeführt und ist eine einfache Alternative für Menschen, die nicht brauchen, oder nicht wissen, wie subprocess.run verwenden. 

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

sh

sh ist ein Teilprozess-Schnittstelle, die Sie Programme können anrufen, als ob sie Funktionen waren. Dies ist nützlich, wenn Sie einen Befehl mehrere Male ausgeführt werden soll. 

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

plumbum ist eine Bibliothek für "Skript-like" Python-Programme. Sie können Programme wie Funktionen wie in sh nennen. Plumbum ist nützlich, wenn Sie eine Pipeline ohne die Shell ausgeführt werden soll. 

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

pexpect

pexpect können Sie Kind Anwendungen laichen, sie kontrollieren und Muster in ihrer Ausgabe zu finden. Dies ist eine bessere Alternative für Befehle an Unterprozess, der einen tty auf Unix erwartet. 

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

Stoff

Stoff ist ein Python 2.5 und 2.7 Bibliothek. Es ermöglicht Ihnen, lokale und Remote-Shell-Befehle auszuführen. Der Stoff ist einfache Alternative für Befehle in einem Secure Shell (SSH)

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

envoy

envoy wird als „Subprozess für den Menschen“ bekannt. Es ist als Komfort-Wrapper um die subprocess Modul verwendet wird. 

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

Befehle

commands enthält Wrapper-Funktionen für os.popen, aber es wird von Python 3 entfernt, da subprocess eine bessere Alternative ist.

wurde das Bearbeiten basierend auf J. F. Sebastian Kommentar.

Ich benutze fabric immer für diese Dinge wie: 

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

Aber das scheint ein gutes Werkzeug zu sein. sh (Python subprocess Schnittstelle)

Sehen Sie ein Beispiel: 

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

Überprüfen Sie die "pexpect" Python-Bibliothek, auch.

Es ermöglicht die interaktive Steuerung von externen Programmen / Befehle, auch ssh, FTP, Telnet, etc. Sie können nur so etwas wie ein: 

child = pexpect.spawn('ftp 192.168.0.24')

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

child.sendline('anonymous')

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

Wenn Sie die Ausgabe des Befehls müssen Sie fordern, dann können Sie subprocess.check_output (Python 2.7+) verwenden. 

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

Beachten Sie auch die Parameter Shell.

  

Wenn Shell True ist, wird der angegebene Befehl durch die Shell ausgeführt werden. Dies kann nützlich sein, wenn Sie Python verwenden es in erster Linie für die verbesserte Steuerung des Datenflusses bietet über die meisten Systemschalen und wollen immer noch bequemen Zugang zu anderen Shell-Funktionen wie Shell Rohre, Dateiname Platzhalter, Umgebungsvariable Expansion und Erweiterung des ~ eines Benutzers zu Hause Verzeichnis. Beachten Sie jedoch, dass Python selbst bietet Implementierungen von vielen schalenartigen Eigenschaften (insbesondere glob, fnmatch, os.walk(), os.path.expandvars(), os.path.expanduser() und shutil).

Mit Standard Library

Verwenden Sie Subprozess Modul (Python 3): 

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

Es ist die empfohlene Standardmethode. Jedoch kompliziertere Aufgaben (Rohre, Ausgang, Eingang, etc.) können langwierig sein zu konstruieren und schreiben.

Hinweis auf Python-Version: Wenn Sie noch Python 2 verwenden, shlex.split können helfen Sie den Befehl für run, call und andere subprocess Funktionen für den Fall analysieren Sie nicht wollen (oder können Sie nicht!), um sie in Form von Listen bieten: 

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

mit externen Abhängigkeiten

Wenn Sie keine externen Abhängigkeiten dagegen, verwenden Sie plumbum : 

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

Es ist der beste subprocess-Wrapper. Es ist Cross-Plattform, das heißt es auf Windows und Unix-ähnlichen Systemen funktioniert. Installieren von pip install plumbum.

Eine weitere beliebte Bibliothek ist sh : 

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

Allerdings fiel sh Windows-Unterstützung, es ist also nicht so genial wie sie verwendet werden. Installieren von pip install sh.

Dies ist, wie ich meine Befehle ausführen. Dieser Code hat alles, was man so ziemlich braucht 

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

Update:

subprocess.run ist der empfohlene Ansatz wie von Python 3.5 wenn Ihr Code muss nicht die Kompatibilität mit früheren Versionen Python halten. Es ist konsistenter und bietet ähnliche Einfachheit der Verwendung als Envoy. (Piping ist allerdings nicht so einfach. Siehe diese Frage, wie .)

Hier einige Beispiele von der Dokumentation .

Führen Sie einen Prozess: 

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

Raise auf fehlgeschlagen Lauf: 

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

Capture-Ausgabe: 

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

Original Antwort:

Ich empfehle versuchen, Envoy . Es ist ein Wrapper für subprocess, die wiederum zielt darauf ab, die älteren Module und Funktionen zu ersetzen . Envoy ist Subprozess für den Menschen.

Beispiel für die Verwendung von der 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
''

Rohr Material um auch: 

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

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

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

Ohne die Ausgabe des Ergebnisses: 

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

Mit Ausgabe des Ergebnisses: 

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

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

... oder für einen sehr einfachen Befehl: 

import os
os.system('cat testfile')

Es gibt auch Plumbum 

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

os.system ist OK, aber irgendwie veraltet. Es ist auch nicht sehr sicher. Stattdessen versuchen subprocess. subprocess ist sh nicht direkt anrufen und ist daher sicherer als os.system.

Weitere Informationen Erhalten Sie hier .

  

Aufruf eines externen Kommandos in Python

Einfache, Verwendung subprocess.run, die eine CompletedProcess Objekt zurückgibt: 

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

Warum?

Ab Python 3.5, empfiehlt die Dokumentation subprocess.run :

  

Der empfohlene Ansatz Aufruf Subprozesse ist die run () Funktion für alle Anwendungsfälle zu verwenden, damit umgehen kann. Für fortgeschrittene Anwendungsfälle kann der zugrunde liegende Popen Schnittstelle direkt verwendet werden.

Hier ist ein Beispiel für eine möglichst einfache Nutzung - und es ist genau so, wie gefragt: 

>>> 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 wartet, bis der Befehl erfolgreich zu beenden, dann ein CompletedProcess Objekt zurückgibt. Es kann stattdessen TimeoutExpired erhöhen oder timeout= (wenn Sie es ein CalledProcessError Argument geben) (falls es nicht und Sie passieren check=True).

Wie Sie aus dem obigen Beispiel, stdout und stderr schließen könnten beide bekommen verrohrt Ihren eigenen stdout und stderr standardmäßig aktiviert.

Wir können das zurückgegebene Objekt inspizieren und den Befehl sehen, die gegeben wurden und die Rückkehr: 

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

Capturing Ausgang

Wenn Sie die Ausgabe aufnehmen möchten, können Sie subprocess.PIPE an den entsprechenden stderr oder stdout passieren kann: 

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

(Ich finde es interessant und leicht eingängig, dass die Version Info statt stdout nach stderr gesetzt wird.)

Übergeben Sie eine Befehlsliste

Man könnte leicht aus bewegen manuell eine Befehlsfolge bereitstellt (wie die Frage schon sagt), um eine Zeichenfolge programmatisch aufgebaut bereitstellt. bauen Sie keine Strings programmatisch. Das stellt ein mögliches Sicherheitsproblem. Es ist besser, Sie nicht davon ausgehen, den Eingang vertrauen. 

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

Hinweis, nur args sollte positionsübergeben werden.

Voll Signatur

Hier ist die eigentliche Signatur in der Quelle und wie durch help(run) gezeigt: 

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

Die popenargs und kwargs werden den Popen Konstruktor gegeben. input kann eine Folge von Bytes sein (oder Unicode, wenn Codierung oder universal_newlines=True angeben), die an den subprocess stdin geleitet wird.

Die Dokumentation beschreibt timeout= und check=True besser als ich es könnte:

  

Die Timeout-Argument wird Popen.communicate () übergeben. Wenn das Timeout   abgelaufen ist, wird das Kind Prozess getötet und gewartet. Das   TimeoutExpired Ausnahme wird erneut angehoben, nachdem das Kind Prozess hat   beendet.

     

Wenn die Prüfung wahr ist, und der Prozess endet mit einem Nicht-Null-Exit-Code, ein   CalledProcessError Ausnahme wird erhöht werden. Attribute, dass   Ausnahme hält die Argumente, den Exit-Code, und stdout und stderr, wenn   sie gefangen genommen wurden.

und dieses Beispiel für check=True ist besser als einer, ich könnte kommen mit: 

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

Expanded Signatur

Hier ist eine erweiterte Signatur, wie in der Dokumentation angegeben: 

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

, dass dies bedeutet, dass nur die args Liste soll positionsübergeben werden. So passieren die restlichen Argumente als Schlüsselwort-Argumente.

Popen

Bei Verwendung Popen statt? Ich würde kämpfen allein Use-Case auf der Grundlage der Argumente zu finden. Direkte Verwendung von Popen würde jedoch geben Ihnen Zugriff auf seine Methoden, einschließlich poll, ‚send_signal‘, ‚beenden‘ und ‚warten‘.

Hier ist die Popen Signatur wie in die Quelle . Ich denke, dies ist die präziseste Kapselung der Informationen (wie opgestellt zu 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):

Aber informativer ist der Popen Dokumentation : 

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)
     

Führen Sie ein Kind-Programm in einem neuen Prozess. Auf POSIX verwendet die Klasse   os.execvp () - Verhalten, das Kind Programm auszuführen. Unter Windows   die Klasse verwendet die Windows-Createprocess () Funktion. Die Argumente   Popen sind wie folgt.

die restliche Dokumentation auf Popen Verständnis wird als eine Übung für die Leser überlassen werden.

Verwendung: 

import os

cmd = 'ls -al'

os.system(cmd)

os - Dieses Modul bietet eine tragbare Art und Weise betriebssystemabhängige Funktionalität mit

.

Für die mehr os Funktionen, hier ist die Dokumentation.

Es kann so einfach sein: 

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

Mit dem os-Modul 

import os
os.system("your command")

zB 

import os
os.system("ifconfig")

subprocess.check_call ist praktisch, wenn Sie nicht über Rückgabewerte testen möchten. Es löst eine Ausnahme bei jedem Fehler.

Ich neige dazu, subprocess zusammen mit shlex (zu handhaben von Strings in Anführungszeichen zu entkommen): 

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

os.system nicht zuzulässt, dass Sie die Ergebnisse speichern, wenn Sie also in irgendeiner Liste oder etwas speichern Ergebnisse subprocess.call funktioniert.

Ich mag shell_command für seine Einfachheit. Es ist oben auf dem Subprozess-Modul eingebaut.

Hier ist ein Beispiel aus der Dokumentation: 

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

Shameless Stecker, schrieb ich eine Bibliothek dafür: P https://github.com/houqp/shell.py

Es ist im Grunde ein Wrapper für popen und shlex für jetzt. Es unterstützt auch die Rohrleitungen Befehle so können Sie Ketten Befehle einfacher in Python. So was Sie tun können Dinge wie: 

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

Unter Linux, falls Sie möchten einen externen Befehl aufrufen, die unabhängig voneinander ausgeführt wird (läuft weiter, nachdem das Python-Skript beendet), können Sie eine einfache Warteschlange als Aufgabe Spooler oder die

ts -S <number-of-slots>

  • Installieren ts nicht Administratorrechte erfordert. Sie können es von der Quelle mit einem einfachen make, fügen Sie es Ihren Weg und du bist fertig.

    • herunterladen und kompilieren
    Lizenziert unter: CC-BY-SA mit Zuschreibung
    Nicht verbunden mit StackOverflow
    scroll top