Chiamare un comando esterno in Python

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

Domanda

Come posso chiamare un comando esterno (come se lo avessi digitato nella shell Unix o nel prompt dei comandi di Windows) da un Python copione?

È stato utile?

Soluzione

Guarda al modulo del sottoprocesso nella libreria standard:

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

Il vantaggio di sottoprocesso contro sistema è che è più flessibile (puoi ottenere stdout, stderr, il codice di stato "reale", una migliore gestione degli errori, ecc...).

IL documentazione ufficiale raccomanda il sottoprocesso modulo sull'alternativa os.system():

IL sottoprocesso il modulo fornisce funzionalità più potenti per generare nuovi processi e recuperare i loro risultati;è preferibile usare quel modulo piuttosto che usare questa funzione [os.system()].

IL "Sostituzione delle funzioni precedenti con il modulo sottoprocesso"sezione nel sottoprocesso la documentazione può contenere alcune ricette utili.

Le versioni precedenti di Python usano la chiamata:

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

Altri suggerimenti

Ecco un riepilogo dei modi per chiamare programmi esterni e i vantaggi e gli svantaggi di ciascuno:

  1. os.system("some_command with args") passa il comando e gli argomenti alla shell del tuo sistema.Questo è utile perché puoi effettivamente eseguire più comandi contemporaneamente in questo modo e impostare pipe e reindirizzamento di input/output.Per esempio: 

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

    Tuttavia, sebbene ciò sia conveniente, è necessario gestire manualmente l'escape dei caratteri della shell come spazi, ecc.D'altra parte, questo ti consente anche di eseguire comandi che sono semplicemente comandi di shell e non veri e propri programmi esterni.Vedere la documentazione.

  2. stream = os.popen("some_command with args") farà la stessa cosa di os.system tranne che ti fornisce un oggetto simile a un file che puoi utilizzare per accedere all'input/output standard per quel processo.Esistono altre 3 varianti di popen che gestiscono l'i/o in modo leggermente diverso.Se passi tutto come una stringa, il tuo comando viene passato alla shell;se li passi come elenco, non devi preoccuparti di sfuggire a nulla.Vedere la documentazione.

  3. IL Popen classe del subprocess modulo.Questo è inteso come sostituto di os.popen ma ha lo svantaggio di essere leggermente più complicato poiché è così completo.Ad esempio, diresti:

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

    invece di: 

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

    ma è bello avere tutte le opzioni in un'unica classe unificata invece di 4 diverse funzioni popen.Vedere la documentazione.

  4. IL call funzione da subprocess modulo.Questo è fondamentalmente proprio come il Popen class e accetta tutti gli stessi argomenti, ma attende semplicemente il completamento del comando e fornisce il codice di ritorno.Per esempio:

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

    Vedere la documentazione.

  5. Se utilizzi Python 3.5 o versioni successive, puoi utilizzare il nuovo subprocess.run funzione, che è molto simile alla precedente ma ancora più flessibile e restituisce a CompletedProcess oggetto quando il comando termina l'esecuzione.

  6. Il modulo os ha anche tutte le funzioni fork/exec/spawn che avresti in un programma C, ma non consiglio di usarle direttamente.

IL subprocess module dovrebbe probabilmente essere quello che usi.

Infine, tieni presente che per tutti i metodi in cui passi il comando finale che deve essere eseguito dalla shell come stringa e sei responsabile dell'escape. Ci sono gravi implicazioni per la sicurezza se qualsiasi parte della stringa che passi non può essere completamente attendibile.Ad esempio, se un utente inserisce parte/qualsiasi parte della stringa.Se non sei sicuro, utilizza questi metodi solo con costanti.Per darti un suggerimento sulle implicazioni considera questo codice:

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

e immagina che l'utente inserisca qualcosa "mia mamma non mi amava && rm -rf /" che potrebbe cancellare l'intero filesystem.

Di solito utilizzo:

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

Sei libero di fare quello che vuoi con il stdout dati nella pipe.In effetti, puoi semplicemente omettere quei parametri (stdout= E stderr=) e si comporterà come os.system().

Alcuni suggerimenti su come staccare il processo figlio da quello chiamante (avviando il processo figlio in background).

Supponiamo di voler avviare un'attività lunga da uno script CGI, ovvero il processo figlio dovrebbe durare più a lungo del processo di esecuzione dello script CGI.

L'esempio classico tratto dalla documentazione del modulo sottoprocesso è:

import subprocess
import sys

# some code here

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

# some more code here

L'idea qui è che non vuoi aspettare nella riga 'call subprocess' fino al termine di longtask.py.Ma non è chiaro cosa succede dopo la riga "qualche altro codice qui" dell'esempio.

La mia piattaforma di destinazione era FreeBSD, ma lo sviluppo era su Windows, quindi ho affrontato il problema prima su Windows.

Su Windows (Win XP), il processo principale non terminerà finché longtask.py non avrà terminato il suo lavoro.Non è quello che vuoi nello script CGI.Il problema non è specifico di Python, nella comunità PHP i problemi sono gli stessi.

La soluzione è passare DETACHED_PROCESS Flag di creazione del processo alla funzione CreateProcess sottostante nell'API win.Se hai installato pywin32 puoi importare il flag dal modulo win32process, altrimenti dovresti definirlo tu stesso:

DETACHED_PROCESS = 0x00000008

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

/* AGGIORNAMENTO 2015.10.27 @eryksun in un commento qui sotto nota che il flag semanticamente corretto è CREATE_NEW_CONSOLE (0x00000010) */

Su freebsd abbiamo un altro problema:quando il processo genitore termina, termina anche i processi figli.E non è nemmeno quello che vuoi nello script CGI.Alcuni esperimenti hanno dimostrato che il problema sembrava risiedere nella condivisione di sys.stdout.E la soluzione di lavoro era la seguente:

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

Non ho controllato il codice su altre piattaforme e non conosco le ragioni del comportamento su freebsd.Se qualcuno lo sa, per favore condividi le tue idee.Cercare su Google l'avvio di processi in background in Python non fa ancora luce.

Consiglierei di utilizzare il modulo subprocess invece di os.system perché esegue l'escape della shell per te ed è quindi molto più sicuro: http://docs.python.org/library/subprocess.html

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

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

Se vuoi restituire i risultati del comando, puoi usare os.popen.Tuttavia, questo è deprecato dalla versione 2.6 a favore di modulo del sottoprocesso, che altre risposte hanno coperto bene.

import os
os.system("your command")

Tieni presente che questo è pericoloso, poiché il comando non viene pulito.Lascio a te la possibilità di cercare su Google la documentazione pertinente sui moduli "os" e "sys".Ci sono un sacco di funzioni (exec* e spawn*) che faranno cose simili.

Esistono molte librerie diverse che ti consentono di chiamare comandi esterni con Python.Per ogni libreria ho fornito una descrizione e mostrato un esempio di chiamata di un comando esterno.Il comando che ho usato come esempio è ls -l (elenca tutti i file).Se vuoi saperne di più su una qualsiasi delle librerie che ho elencato e collegato la documentazione per ciascuna di esse.

Fonti:

Queste sono tutte le biblioteche:

Spero che questo ti aiuti a prendere una decisione su quale libreria utilizzare :)

sottoprocesso

Il sottoprocesso consente di chiamare comandi esterni e collegarli ai relativi pipe di input/output/errore (stdin, stdout e stderr).Il sottoprocesso è la scelta predefinita per l'esecuzione dei comandi, ma a volte altri moduli sono migliori.

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 viene utilizzato per "funzionalità dipendenti dal sistema operativo".Può essere utilizzato anche per richiamare comandi esterni con os.system E os.popen (Nota:C'è anche un sottoprocesso.popen).os eseguirà sempre la shell ed è una semplice alternativa per le persone che non ne hanno bisogno o non sanno come usarlo subprocess.run.

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

sh

sh è un'interfaccia di sottoprocesso che consente di chiamare programmi come se fossero funzioni.Ciò è utile se desideri eseguire un comando più volte.

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 è una libreria per programmi Python "simili a script".Puoi chiamare programmi come funzioni come in sh.Plumbum è utile se vuoi eseguire una pipeline senza shell.

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

aspettativa

pexpect ti consente di generare applicazioni figlie, controllarle e trovare modelli nel loro output.Questa è un'alternativa migliore al sottoprocesso per i comandi che prevedono un tty su Unix.

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

tessuto

fabric è una libreria Python 2.5 e 2.7.Ti consente di eseguire comandi shell locali e remoti.Fabric è una semplice alternativa per eseguire comandi in una shell sicura (SSH)

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

inviato

envoy è noto come "sottoprocesso per gli umani".Viene utilizzato come comodo involucro attorno al subprocess modulo.

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

comandi

commands contiene funzioni wrapper per os.popen, ma da allora è stato rimosso da Python 3 subprocess è un'alternativa migliore.

Il montaggio era basato su J.F.Il commento di Sebastiano.

Lo uso sempre fabric per queste cose come:

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

Ma questo sembra essere un buon strumento: sh (Interfaccia del sottoprocesso Python).

Guarda un esempio:

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

Controlla anche la libreria Python "pexpect".

Consente il controllo interattivo di programmi/comandi esterni, anche ssh, ftp, telnet, ecc.Puoi semplicemente digitare qualcosa come:

child = pexpect.spawn('ftp 192.168.0.24')

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

child.sendline('anonymous')

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

Se hai bisogno dell'output dal comando che stai chiamando, puoi usare sottoprocesso.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'

Da notare anche il conchiglia parametro.

Se la shell è True, il comando specificato verrà eseguito tramite la shell.Questo può essere utile se stai usando Python principalmente per il flusso di controllo avanzato che offre sulla maggior parte delle shell di sistema e desideri comunque un comodo accesso ad altre funzionalità della shell come pipe della shell, caratteri jolly dei nomi di file, espansione delle variabili di ambiente ed espansione di ~ nella home dell'utente directory.Tuttavia, tieni presente che Python stesso offre implementazioni di molte funzionalità simili alla shell (in particolare, glob, fnmatch, os.walk(), os.path.expandvars(), os.path.expanduser(), E shutil).

Con libreria standard

L'uso modulo del sottoprocesso (Pitone 3):

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

È il modo standard consigliato.Tuttavia, attività più complicate (pipe, output, input, ecc.) possono essere noiose da costruire e scrivere.

Nota sulla versione Python:Se stai ancora utilizzando Python 2, subprocess.call funziona in modo simile.

Suggerimento: shlex.split può aiutarti ad analizzare il comando run, call, e altro subprocess funzioni nel caso in cui non vuoi (o non puoi!) fornirle sotto forma di elenchi:

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

Con dipendenze esterne

Se non ti preoccupano le dipendenze esterne, usa plumbum:

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

È la migliore subprocess involucro.È multipiattaforma, ad es.funziona sia su sistemi Windows che Unix.Installa entro pip install plumbum.

Un'altra libreria popolare è sh:

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

Tuttavia, sh ha abbandonato il supporto di Windows, quindi non è fantastico come una volta.Installa entro pip install sh.

Ecco come eseguo i miei comandi.Questo codice ha praticamente tutto ciò di cui hai bisogno

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

Aggiornamento:

subprocess.run è l'approccio consigliato a partire da Python 3.5 se il tuo codice non ha bisogno di mantenere la compatibilità con le versioni precedenti di Python.È più coerente e offre una facilità d'uso simile a Envoy.(Tuttavia, le tubazioni non sono così semplici.Vedere questa domanda su come.)

Ecco alcuni esempi da i documenti.

Esegui un processo:

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

Rilancio in caso di esecuzione fallita:

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

Uscita di cattura:

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

Risposta originale:

Consiglio di provare Inviato.È un wrapper per il sottoprocesso, che a sua volta mira a sostituire i moduli e le funzioni più vecchi.Envoy è un sottoprocesso per gli umani.

Esempio di utilizzo da il file leggimi:

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

Metti in giro anche le cose:

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

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

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

Senza l'output del risultato:

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

Con output del risultato:

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

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

...o per un comando molto semplice:

import os
os.system('cat testfile')

C'è anche 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 va bene, ma è un po' datato.Inoltre non è molto sicuro.Invece, prova subprocess. subprocess non chiama direttamente sh ed è quindi più sicuro di os.system.

Ottieni maggiori informazioni Qui.

Chiamare un comando esterno in Python

Semplice, usalo subprocess.run, che restituisce a CompletedProcess oggetto:

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

Perché?

A partire da Python 3.5, la documentazione consiglia sottoprocesso.run:

L'approccio consigliato per richiamare i sottoprocessi è utilizzare la funzione run() per tutti i casi d'uso che può gestire.Per casi d'uso più avanzati, è possibile utilizzare direttamente l'interfaccia Popen sottostante.

Ecco un esempio dell'utilizzo più semplice possibile e funziona esattamente come richiesto:

>>> 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 attende che il comando venga completato con successo, quindi restituisce a CompletedProcess oggetto.Potrebbe invece rilanciare TimeoutExpired (se gli dai un timeout= argomento) o CalledProcessError (se fallisce e passi check=True).

Come puoi dedurre dall'esempio precedente, stdout e stderr vengono entrambi reindirizzati al tuo stdout e stderr per impostazione predefinita.

Possiamo ispezionare l'oggetto restituito e vedere il comando che è stato dato e il codice restituito:

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

Catturare l'output

Se vuoi catturare l'output, puoi passare subprocess.PIPE all'appropriato stderr O 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''

(Trovo interessante e leggermente controintuitivo che le informazioni sulla versione vengano inserite su stderr anziché su stdout.)

Passa un elenco di comandi

Si potrebbe facilmente passare dal fornire manualmente una stringa di comando (come suggerisce la domanda) al fornire una stringa creata a livello di codice. Non creare stringhe a livello di codice. Questo è un potenziale problema di sicurezza.È meglio presumere che non ti fidi dell'input. 

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

Nota, solo args dovrebbe essere passato posizionalmente.

Firma completa

Ecco la firma effettiva nella fonte e come mostrato da help(run):

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

IL popenargs E kwargs sono dati al Popen costruttore. input può essere una stringa di byte (o unicode, se specificata la codifica o universal_newlines=True) che verrà reindirizzato allo stdin del sottoprocesso.

La documentazione descrive timeout= E check=True meglio di quanto potessi:

L'argomento timeout viene passato a Popen.communicate().Se il timeout scade, il processo del bambino verrà ucciso e atteso.L'eccezione espressa dal timeoutine verrà riavviata dopo che il processo figlio è terminato.

Se il controllo è vero e il processo esce con un codice di uscita diverso da zero, verrà sollevata un'eccezione chiamataprocesserror.Gli attributi di tale eccezione contengono gli argomenti, il codice di uscita e StDout e Stderr se sono stati catturati.

e questo esempio per check=True è migliore di quello che potrei inventare:

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

Firma estesa

Ecco una firma estesa, come indicato nella documentazione:

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

Tieni presente che ciò indica che solo l'elenco degli argomenti deve essere passato in modo posizionale.Quindi passa gli argomenti rimanenti come argomenti di parole chiave.

Popen

Quando utilizzare Popen Invece?Farei fatica a trovare un caso d'uso basato solo sugli argomenti.Utilizzo diretto di Popen ti darebbe, tuttavia, accesso ai suoi metodi, incluso poll, "send_signal", "termina" e "aspetta".

Ecco il Popen firma come riportata la fonte.Penso che questo sia l'incapsulamento più preciso delle informazioni (al contrario di 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):

Ma più informativo è IL Popen documentazione:

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)

Esegui un programma figlio in un nuovo processo.Su POSIX, la classe utilizza OS.execvp ()-simile a un comportamento per eseguire il programma figlio.Su Windows, la classe utilizza la funzione Windows CreateProcess ().Gli argomenti di Popen sono i seguenti.

Comprendere la documentazione rimanente su Popen sarà lasciato come esercizio al lettore.

Utilizzo:

import os

cmd = 'ls -al'

os.system(cmd)

os: questo modulo fornisce un modo portatile di utilizzare funzionalità dipendenti dal sistema operativo.

Per di più os funzioni, Qui è la documentazione.

Può essere così semplice:

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

utilizzare il modulo del sistema operativo

import os
os.system("your command")

per esempio

import os
os.system("ifconfig")

subprocess.check_call è utile se non vuoi testare i valori restituiti.Genera un'eccezione per qualsiasi errore.

Tendo a usare sottoprocesso insieme a shlex (per gestire l'escape delle stringhe tra virgolette):

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

C'è qui un'altra differenza che non è stata menzionata in precedenza.

subprocess.Popen esegue il <comando> come sottoprocesso.Nel mio caso, devo eseguire il file <a> che deve comunicare con un altro programma, <b>.

Ho provato il sottoprocesso e l'esecuzione ha avuto successo.Tuttavia <b> non è riuscito a comunicare con <a>.Tutto è normale quando eseguo entrambi dal terminale.

Ancora uno:(NOTA:kwrite si comporta diversamente dalle altre applicazioni.Se provi quanto segue con Firefox, i risultati non saranno gli stessi.)

Se provi os.system("kwrite"), il flusso del programma si blocca finché l'utente non chiude kwrite.Per superarlo ho provato invece os.system(konsole -e kwrite).Questa volta il programma ha continuato a scorrere, ma kwrite è diventato il sottoprocesso della console.

Chiunque esegue kwrite non essendo un sottoprocesso (ad es.nel monitor di sistema deve apparire sul bordo più a sinistra dell'albero).

os.system non ti consente di memorizzare i risultati, quindi se desideri memorizzare i risultati in qualche elenco o qualcosa del genere subprocess.call lavori.

mi piace abbastanza comando_shell per la sua semplicità.È costruito sopra il modulo sottoprocesso.

Ecco un esempio dai documenti:

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

Plug spudorato, ho scritto una libreria per questo: Phttps://github.com/houqp/shell.py

Fondamentalmente è un involucro per popen e shlex per ora.Supporta anche i comandi di piping in modo da poter concatenare i comandi più facilmente in Python.Quindi puoi fare cose come:

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

Sotto Linux, nel caso in cui desideri chiamare un comando esterno che verrà eseguito in modo indipendente (continuerà a essere eseguito dopo il termine dello script Python), puoi utilizzare una semplice coda come spooler di attività o il A comando

Un esempio con lo spooler di attività:

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

Note sullo spooler delle attività (ts):

  1. È possibile impostare il numero di processi simultanei da eseguire ("slot") con:

    ts -S <number-of-slots>

  2. Installazione ts non richiede privilegi di amministratore.Puoi scaricarlo e compilarlo dal sorgente con un semplice make, aggiungilo al tuo percorso e il gioco è fatto.

Puoi usare Popen, e poi puoi controllare lo stato della procedura:

from subprocess import Popen

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

Guardare sottoprocesso.Popen.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top