Hvordan kører man bash-scripts ved hjælp af Python?

Af
Tweet
Share
Share
Pin

Hvis du bruger Linux, vil du helt sikkert elske shell-kommandoerne.

Og hvis du arbejder med Python, så har du måske prøvet at automatisere tingene. Det er en måde at spare tid på. Du kan også have nogle bash-scripts til at automatisere ting.

Python er praktisk til at skrive scripts end bash. Og det er nemt at administrere Python-scripts sammenlignet med bash-scripts. Du vil finde det svært at vedligeholde bash-scripts, når det først vokser.

Men hvad hvis du allerede har bash-scripts, som du vil køre ved hjælp af Python?

Er der nogen måde at udføre bash-kommandoer og scripts i Python?

Ja, Python har et indbygget modul kaldet subprocess, som bruges til at udføre kommandoer og scripts inde i Python-scripts. Lad os se, hvordan man udfører bash-kommandoer og scripts i Python-scripts i detaljer.

Udførelse af bash-kommandoer

Som du måske allerede har set, bruges modulunderprocessen til at udføre bash-kommandoer og scripts. Det giver forskellige metoder og klasser til det samme.

Der er hovedsageligt én metode og én klasse at kende til fra delprocesmodulet. De er kørt og Popen. Disse to hjælper os med at udføre bash-kommandoer i Python-scripts. Lad os se dem én efter én.

subprocess.run()

Metoden subprocess.run() vil tage en liste over strenge som et positionsargument. Dette er obligatorisk, da det har bash-kommandoen og argumenter for det. Det første element på listen er kommandonavnet, og de resterende elementer er argumenterne til kommandoen.

  Sådan ændres indstillingerne for standardformat for Google Docs

Lad os se et hurtigt eksempel.

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

Ovenstående script viser alle elementerne i den aktuelle arbejdsmappe som scriptet ligger. Der er ingen argumenter til kommandoen i ovenstående script. Vi har kun givet bash-kommandoen. Vi kan give yderligere argumenter til ls-kommandoen som -l, -a, -la osv.

Lad os se et hurtigt eksempel med kommandoargumenter.

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

Ovenstående kommando viser alle filerne inklusive skjulte filer sammen med tilladelserne. Vi har givet argumentet la som viser filer og mapper ekstra information og skjulte filer.

Vi kan ende med at lave nogle fejl, mens vi skriver kommandoerne. Fejl vil rejse i henhold til fejlene. Hvad hvis du vil fange dem og bruge dem senere? Ja, vi kan gøre det ved at bruge søgeordsargumentet stderr.

Lad os se et eksempel.

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

Sørg for, at du ikke har filen med navnet sample.txt i arbejdsmappen. Værdien til søgeordsargumentet stderr er PIPE, som hjælper med at returnere fejlen i et objekt. Vi kan få adgang til det senere med samme navn. Og søgeordsargumentteksten hjælper med at fortælle, at outputtet skal være en streng.

På samme måde kan vi fange outputtet af kommandoen ved hjælp af stdout nøgleordsargumentet.

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

subprocess.run() – input

Du kan give input til kommandoerne ved hjælp af input nøgleordet argument. Vi vil give input i et strengformat. Så vi skal indstille søgeordsargumentteksten til True. Som standard tager det det i bytes.

Lad os se på et eksempel.

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

I ovenstående program vil Python-scriptet add.py tage to tal som input. Vi har givet input til Python-scriptet ved hjælp af input nøgleordet argument.

  Sådan tilføjer du tilgængelighedsfunktioner til Google Chrome

subprocess.Popen()

Klassen subprocess.Popen() er avanceret end metoden subprocess.run(). Det giver os flere muligheder for at udføre kommandoerne. Vi vil oprette en instans af subprocess.Popen() og bruge den til forskellige ting som at kende status for kommandoudførelsen, få output, give input osv..,

Der er flere metoder i klassen subprocess.Popen(), som vi har brug for at kende. Lad os se dem én efter én sammen med kodeeksemplerne.

vente

Det bruges til at vente til fuldførelsen af ​​udførelsen af ​​kommandoen. De næste linjer i Python-scriptet udføres ikke før færdiggørelsen af ​​den forrige kommando, der er skrevet efter ventemetoden. Lad os se eksemplet.

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

Kør ovenstående kode og observer outputtet. Du vil se, at meddelelsen afsluttet! udskrives før udførelse af kommandoen. Vi kan undgå det ved at bruge ventemetoden. Lad os vente til fuldførelsen af ​​kommandoen.

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

print("Completed!")

Hvis du ser outputtet for ovenstående kode, vil du indse, at ventetiden faktisk virker. Print-sætningen udføres efter fuldførelsen af ​​kommandoudførelsen.

kommunikere

Metoden communicate bruges til at få output, fejl og give input til kommandoen. Det returnerer en tuple, der indeholder henholdsvis output og fejl. Lad os se et eksempel.

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

subprocess.Popen() – input

Vi kan ikke videregive input til klassen Popen direkte. Vi skal bruge søgeordsargumentet kaldet stdin for at give input til kommandoen. Forekomsten af ​​klassen Popen vil give os stdin-objekt. Den har en metode kaldet skrive, som bruges til at give input til kommandoen.

  Overvåger Zoom virkelig, hvilke apps du bruger under et opkald?

Som vi diskuterede tidligere, vil det tage input som bytes-lignende objekter som standard. Så glem ikke at indstille søgeordsargumentteksten til True, mens du opretter forekomsten af ​​Popen.

Lad os se et eksempel.

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

afstemning

Metodeafstemningen bruges til at kontrollere, om udførelsen af ​​kommandoen er fuldført eller ej. Denne metode vil returnere Ingen, hvis kommandoen stadig udføres. Lad os se et eksempel.

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

I ovenstående kode har vi brugt ping-kommandoen med 5 anmodninger. Der er en uendelig løkke, der itererer indtil afslutningen af ​​kommandoudførelsen. Vi har brugt metodeafstemningen til at kontrollere status for kommandoudførelsen. Hvis metodeafstemningen returnerer anden kode end Ingen, fuldføres eksekveringen. Og den uendelige sløjfe går i stykker.

Udførelse af Bash-scripts

Vi har set to måder at udføre kommandoerne på. Lad os nu se, hvordan man udfører bash-scripts i Python-scripts.

Underprocessen har en metode kaldet call. Denne metode bruges til at udføre bash-scripts. Metoden returnerer exit-koden fra bash-scriptet. Standard exit-koden for bash-scripts er 0. Lad os se et eksempel.

Opret et bash-script med navnet practice.sh som følger.

#!/bin/bash

echo "Hello, World!"
exit 1

Skriv nu et Python-script og kør ovenstående bash-script.

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

Du får følgende output, når du kører ovenstående Python-script.

Hello, World!
1

Konklusion

Vi har set, hvordan man udfører bash-kommandoer og scripts i Python. Du kan bruge dem til at automatisere ting mere effektivt.

Glædelig kodning 👨‍💻