Cum să rulați scripturi bash folosind Python?

Dacă utilizați Linux, atunci cu siguranță v-ar plăcea comenzile shell.

Și dacă lucrați cu Python, atunci este posibil să fi încercat să automatizați lucrurile. Este o modalitate de a economisi timp. Este posibil să aveți și niște scripturi bash pentru a automatiza lucrurile.

Python este la îndemână pentru a scrie scripturi decât bash. Și gestionarea scripturilor Python este ușoară în comparație cu scripturile bash. Vă va fi dificil să mențineți scripturile bash odată ce acestea vor crește.

Dar dacă aveți deja scripturi bash pe care doriți să le rulați folosind Python?

Există vreo modalitate de a executa comenzile și scripturile bash în Python?

Da, Python are un modul încorporat numit subproces, care este folosit pentru a executa comenzile și scripturile din interiorul scripturilor Python. Să vedem în detaliu cum să executăm comenzile și scripturile bash în scripturile Python.

Executarea comenzilor Bash

După cum poate ați văzut deja, subprocesul modulului este folosit pentru a executa comenzile și scripturile bash. Oferă metode și clase diferite pentru același lucru.

Există în principal o metodă și o clasă despre care trebuie să știți din modulul de subproces. Ei sunt alergați și Popen. Aceste două ne ajută să executăm comenzile bash în scripturile Python. Să-i vedem unul câte unul.

subprocess.run()

Metoda subprocess.run() va lua o listă de șiruri ca argument pozițional. Acest lucru este obligatoriu deoarece are comanda bash și argumente pentru aceasta. Primul element din listă este numele comenzii, iar elementele rămase sunt argumentele comenzii.

Să vedem un exemplu rapid.

import subprocess
subprocess.run(["ls"])

Scriptul de mai sus listează toate elementele din directorul de lucru curent, deoarece se află scriptul. Nu există argumente pentru comandă în scriptul de mai sus. Am dat doar comanda bash. Putem oferi argumente suplimentare la comanda ls, cum ar fi -l, -a, -la etc.

Să vedem un exemplu rapid cu argumente de comandă.

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

Comanda de mai sus afișează toate fișierele, inclusiv fișierele ascunse, împreună cu permisiunile. Am oferit argumentul la care afișează fișiere și directoare informații suplimentare și fișiere ascunse.

S-ar putea să ajungem să facem unele greșeli în timp ce scriem comenzile. Erorile vor apărea în funcție de greșeli. Ce se întâmplă dacă doriți să le capturați și să le folosiți mai târziu? Da, putem face asta folosind argumentul cheie stderr.

Să vedem un exemplu.

import subprocess
result = subprocess.run(["cat", "sample.txt"], stderr=subprocess.PIPE, text=True)
print(result.stderr)

Asigurați-vă că nu aveți fișierul cu numele sample.txt în directorul de lucru. Valoarea argumentului cuvânt cheie stderr este PIPE, care ajută la returnarea erorii într-un obiect. Îl putem accesa mai târziu cu același nume. Și textul argument al cuvântului cheie ajută la a spune că rezultatul ar trebui să fie un șir.

În mod similar, putem captura rezultatul comenzii folosind argumentul cheie stdout.

import subprocess
result = subprocess.run(["echo", "Hello, World!"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
print(result.stdout)

subprocess.run() – intrare

Puteți da intrare comenzilor folosind argumentul cheie de intrare. Vom oferi intrări într-un format șir. Deci, trebuie să setăm textul argument al cuvântului cheie la True. În mod implicit, o ia în octeți.

Să ne uităm la un exemplu.

import subprocess
subprocess.run(["python3", "add.py"], text=True, input="2 3")

În programul de mai sus, scriptul Python add.py va lua ca intrare două numere. Am dat intrarea scriptului Python folosind argumentul cheie de intrare.

subproces.Popen()

Clasa subprocess.Popen() este avansată decât metoda subprocess.run(). Ne oferă mai multe opțiuni pentru a executa comenzile. Vom crea o instanță a subprocesului.Popen() și o vom folosi pentru diverse lucruri, cum ar fi cunoașterea stării de execuție a comenzii, obținerea ieșirii, introducerea de date etc.,

Există mai multe metode ale clasei subprocess.Popen() pe care trebuie să le cunoaștem. Să le vedem unul câte unul împreună cu exemplele de cod.

aștepta

Este folosit pentru a aștepta până la finalizarea execuției comenzii. Următoarele linii ale scriptului Python nu se vor executa până la finalizarea comenzii anterioare care este scrisă după metoda wait. Să vedem exemplul.

import subprocess
process = subprocess.Popen(["ls", "-la"])
print("Completed!")

Rulați codul de mai sus și observați rezultatul. Veți vedea că mesajul Terminat! este tipărită înainte de executarea comenzii. O putem evita folosind metoda așteptării. Să așteptăm până la finalizarea comenzii.

import subprocess
process = subprocess.Popen(["ls", "-la"])
process.wait()

print("Completed!")

Dacă vedeți rezultatul codului de mai sus, atunci vă veți da seama că așteptarea funcționează de fapt. Instrucțiunea print este executată după finalizarea execuției comenzii.

comunica

Metoda de comunicare este utilizată pentru a obține rezultatul, eroarea și pentru a da intrare comenzii. Returnează un tuplu care conține rezultat și, respectiv, eroare. Să vedem un exemplu.

import subprocess
process = subprocess.Popen(["echo", "Hello, World!"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
result = process.communicate()
print(result)

subproces.Popen() – intrare

Nu putem trece direct intrarea către clasa Popen. Trebuie să folosim argumentul cheie numit stdin pentru a da intrarea comenzii. Instanța clasei Popen ne va furniza obiectul stdin. Are o metodă numită write care este folosită pentru a da intrarea comenzii.

După cum am discutat mai devreme, va lua intrări ca obiecte asemănătoare octeților în mod implicit. Deci, nu uitați să setați textul argument al cuvântului cheie la True în timp ce creați instanța lui Popen.

Să vedem un exemplu.

import subprocess
process = subprocess.Popen(["python3", "add.py"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
process.stdin.write("2 3")
process.stdin.close()
print(process.stdout.read())

sondaj

Metoda de sondare este folosită pentru a verifica dacă execuția comenzii este finalizată sau nu. Această metodă va returna None dacă comanda este încă în execuție. Să vedem un exemplu.

import subprocess
process = subprocess.Popen(['ping', '-c 5', 'geekflare.com'], stdout=subprocess.PIPE, text=True)
while True:
    output = process.stdout.readline()
    if output:
    	print(output.strip())
    result = process.poll()
    if result is not None:
        break

În codul de mai sus, am folosit comanda ping cu 5 solicitări. Există o buclă infinită care iterează până la finalizarea execuției comenzii. Am folosit metoda sondajului pentru a verifica starea execuției comenzii. Dacă sondajul metodei returnează alt cod decât None, atunci execuția se finalizează. Și bucla infinită se rupe.

Executarea scripturilor Bash

Am văzut două moduri de a executa comenzile. Acum, să vedem cum să executăm scripturile bash în scripturile Python.

Subprocesul are o metodă numită call. Această metodă este folosită pentru a executa scripturile bash. Metoda returnează codul de ieșire din scriptul bash. Codul de ieșire implicit pentru scripturile bash este 0. Să vedem un exemplu.

Creați un script bash cu numele practice.sh, după cum urmează.

#!/bin/bash

echo "Hello, World!"
exit 1

Acum, scrieți un script Python, executați scriptul bash de mai sus.

import subprocess
exit_code = subprocess.call('./practice.sh')
print(exit_code)

Veți obține următorul rezultat odată ce rulați scriptul Python de mai sus.

Hello, World!
1

Concluzie

Am văzut cum să executăm comenzi și scripturi bash în Python. Le puteți folosi pentru a automatiza lucrurile mai eficient.

Codare fericită 👨‍💻