Come chiamare uno script di shell dal codice Python?

Come chiamare uno script di shell dal codice Python?

Il modulo di sottoprocesso ti aiuterà.

Esempio palesemente banale:

>>> import subprocess
>>> subprocess.call(['./test.sh']) # Thanks @Jim Dennis for suggesting the []
0 
>>> 

Dov'è test.shun semplice script di shell ed 0è il suo valore di ritorno per questa corsa.

Ci sono alcuni modi usando os.popen()(deprecato) o l'intero subprocessmodulo, ma questo approccio

import os
os.system(command)

è uno dei più semplici.

Nel caso in cui si desideri passare alcuni parametri allo script della shell, è possibile utilizzare il metodo shlex.split () :

import subprocess
import shlex
subprocess.call(shlex.split('./test.sh param1 param2'))

con test.shnella stessa cartella:

#!/bin/sh
echo $1
echo $2
exit 0

Uscite:

$ python test.py 
param1
param2

import os
import sys

Supponendo test.sh è lo script della shell che si desidera eseguire

os.system("sh test.sh")

Utilizzare il modulo di sottoprocesso come indicato sopra.

Lo uso così:

subprocess.call(["notepad"])

Sto eseguendo python 3.5 e subprocess.call (['./ test.sh']) non funziona per me.

Ti do tre soluzioni dipende da cosa vuoi fare con l'output.

1 - chiama lo script. Vedrai un output nel tuo terminale. l'output è un numero.

import subprocess 
output = subprocess.call(['test.sh'])

2 - chiama ed esegue il dump dell'esecuzione e dell'errore nella stringa. Non vedi l'esecuzione nel tuo terminale a meno che non stampi (stdout). Shell = True come argomento in Popen non funziona per me.

import subprocess
from subprocess import Popen, PIPE

session = subprocess.Popen(['test.sh'], stdout=PIPE, stderr=PIPE)
stdout, stderr = session.communicate()

if stderr:
    raise Exception("Error "+str(stderr))

3 - chiama lo script e scarica i comandi echo di temp.txt in temp_file

import subprocess
temp_file = open("temp.txt",'w')
subprocess.call([executable], stdout=temp_file)
with open("temp.txt",'r') as file:
    output = file.read()
print(output)

Non dimenticare di dare un'occhiata al sottoprocesso del documento

Il modulo dei sottoprocessi è un buon modulo per avviare i sottoprocessi. Puoi usarlo per chiamare i comandi di shell come questo:

subprocess.call(["ls","-l"]);
#basic syntax
#subprocess.call(args, *)

Puoi vedere la sua documentazione qui.

Se lo script è stato scritto in un file .sh o in una stringa lunga, è possibile utilizzare il modulo os.system. È abbastanza semplice e facile da chiamare:

import os
os.system("your command here")
# or
os.system('sh file.sh')

Questo comando eseguirà lo script una volta, fino al completamento, e lo bloccherà fino alla sua uscita.

Nel caso in cui lo script abbia più argomenti

#!/usr/bin/python

import subprocess
output = subprocess.call(["./test.sh","xyz","1234"])
print output

L'output fornirà il codice di stato. Se lo script viene eseguito correttamente, verrà restituito 0 intero diverso da zero.

podname=xyz  serial=1234
0

Di seguito è riportato lo script della shell test.sh.

#!/bin/bash

podname=$1
serial=$2
echo "podname=$podname  serial=$serial"

Il sottoprocesso è buono ma ad alcune persone potrebbe piacere di più la scriptina . Scriptine ha un set di metodi più di alto livello come shell.call (args) , path.rename (new_name) e path.move (src, dst) . La scriptina si basa su sottoprocessi e altri.

Due svantaggi della scriptine:

• L'attuale livello di documentazione sarebbe più completo anche se è sufficiente.
• A differenza del sottoprocesso, il pacchetto di scriptine non è attualmente installato per impostazione predefinita.

So che questa è una vecchia domanda, ma di recente mi sono imbattuto in questo e alla fine mi ha sbagliato a guidare l' API di sottoprocesso come modificata da Python 3.5.

Il nuovo modo di eseguire script esterni è con la runfunzione, che esegue il comando descritto da args. Attende il completamento del comando, quindi restituisce un'istanza CompletedProcess.

import subprocess

subprocess.run(['./test.sh'])

Se il file di script della shell non dispone delle autorizzazioni di esecuzione, procedere come segue.

import subprocess
subprocess.run(['/bin/bash', './test.sh'])

Prova i seguenti codici:

Import Execute 

Execute("zbx_control.sh")