Cum de a apela un script de shell din codul python?

De subproces modulul va ajuta.

Flagrant exemplu banal:

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

Unde test.sheste un script de shell simplu, și0` este valoarea de returnare pentru acest termen.

Există unele moduri, folosind os.popen() (învechită) sau tot subproces module, dar această abordare

import os
os.system(command)

este una dintre cele mai simple.

În cazul în care doriți să treacă niște parametri la shell script, puteți utiliza metoda shlex.split():

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

cu test.sh` în același folder:

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

Ieșiri:

$ python test.py 
param1
param2

import os
import sys

Presupunând că test.sh este script de shell care le-ar dori pentru a executa

os.system("sh test.sh")

Utilizați subproces module ca mai sus.

Eu folosesc asa:

subprocess.call(["notepad"])

Am'm execută piton de 3,5 și subproces.apel(['./test.sh']) nu't de lucru pentru mine.

Îți dau trei soluții depinde de ceea ce vrei sa faci cu cel de ieșire.

1 - call script. Veți vedea de ieșire în terminalul. de ieșire este un număr.

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

2 - apel și basculante de execuție și de eroare în șir. Nu't vedea execuție în terminalul dacă nu ai print(stdout). Shell=True ca argument în Popen nu't de lucru pentru mine.

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 - call script și basculante ecoul comenzi de temp.txt în 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)

Don't uitați să luați o privire la doc subproces

În cazul în care script-ul are mai multe argumente

#!/usr/bin/python

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

Producția va dau codul de stare. Dacă script-ul ruleaza cu succes, se va da 0 în caz contrar non-zero întreg.

podname=xyz  serial=1234
0

Mai jos este test.sh script de shell.

#!/bin/bash

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

Subproces module este un bun modul de a lansa sub-procese. Puteți să-l utilizați pentru a apela comenzi shell deoarece acest lucru:

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

Puteți vedea documentația acestuia aici.

Dacă aveți script scris în unele .sh fișier sau un șir lung, atunci puteți folosi sistemul de operare.modulul sistemului. Este destul de simplu și ușor pentru a apela:

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

Această comandă va rula script-ul o dată, la finalizare, și de a bloca până când acesta iese.

Știu că aceasta este o întrebare veche, dar am dat peste asta recent si s-a terminat derutanta mine din Subproces API ca s-a schimbat de când python 3.5.

Noul mod de a executa script-uri externe este cu " run " funcția.

Import subprocess

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

Subproces este bun, dar unii oameni ar putea ca scriptine mai bine. Scriptine a mai ridicat nivel de set de metode, cum ar fi coajă.apel(args), cale.redenumiți(new_name) și cale.muta(src,dst). Scriptine se bazează pe subproces și alții.

Două dezavantaje de scriptine:

• Curent de documentare nivel ar fi mai cuprinzătoare, chiar dacă acesta este suficient.
• Spre deosebire de subproces, scriptine pachetului este în prezent nu este instalat în mod implicit.

Dacă shell script file nu are permisiuni de executare, face acest lucru în felul următor.

python import subproces subproces.rula(['/bin/bash', './test.sh'])

Vă rugăm să Încercați următoarele coduri :

Import Execute 

Execute("zbx_control.sh")