Sådan udføres eksterne kommandoer i Python

Python subprocess

Kørsel af systemkommandoer fra Python

Python giver kraftfulde funktioner til at udføre eksterne programmer og systemkommandoer direkte fra dine scripts. Denne funktion giver dig mulighed for at udnytte Pythons enkelhed, mens du drager fordel af det store udvalg af værktøjer, der er tilgængelige i dit operativsystem.

Uanset om du automatiserer gentagne opgaver eller integrerer komplekse arbejdsgange, kan forståelsen af, hvordan du kalder systemkommandoer i Python, forbedre din produktivitet betydeligt. I denne guide vil vi undersøge forskellige metoder til at opnå dette effektivt.

Kommando Beskrivelse
subprocess.run Udfører en kommando i en subshell. Kan fange output og fejl.
subprocess.run([...], capture_output=True) Indfanger standardoutput og standardfejl for den udførte kommando.
subprocess.run([...], shell=True) Kører kommandoen gennem skallen, hvilket tillader shell-funktioner som jokertegn.
subprocess.Popen Udfører en kommando i en ny proces, hvilket giver mere kontrol over dens udførelse.
process.stdout.readline() Læser en linje af output fra processens standard output.
os.system Udfører en kommando i en subshell, der almindeligvis bruges til simpel kommandoudførelse.
subprocess.check_output Kører en kommando og returnerer dens output. Rejser en undtagelse, hvis kommandoen mislykkes.
os.environ.copy() Opretter en kopi af de aktuelle miljøvariabler, hvilket tillader ændringer.
env parameter in subprocess.run Specificerer miljøvariabler for den nye proces.

Forståelse af scriptudførelse i Python

De leverede scripts demonstrerer forskellige måder at udføre eksterne kommandoer ved hjælp af Python. Det kommandoen er alsidig, så du kan køre shell-kommandoer direkte fra dit Python-script. For eksempel, udskriver en besked til konsollen, mens fanger output fra ls -l kommando, der viser en detaljeret mappeliste. Ved brug af med tillader brug af shell-funktioner, såsom jokertegnudvidelse, hvilket gør det praktisk til mere komplekse kommandoer.

Det kommando giver mere kontrol over kommandoudførelse ved at tillade asynkron kommandokørsel og interaktion med processens input- og outputstrømme. For eksempel scripteksemplet med Pinger kontinuerligt den lokale maskine og læser hver linje af output. Derudover bruges til simpel kommandoudførelse, men mangler fleksibiliteten til subprocess. Miljøvariabler kan ændres og videregives til underprocessen vha og parameter i , hvilket tillader dynamisk kommandoudførelse baseret på miljøet.

Udførelse af eksterne kommandoer i Python

Bruger Pythons underprocesmodul

import subprocess
# Example 1: Running a simple shell command
subprocess.run(['echo', 'Hello, World!'])
# Example 2: Capturing the output of a command
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
print(result.stdout)
# Example 3: Running a command with shell=True
subprocess.run('echo Hello from the shell', shell=True)
# Example 4: Checking the return code
result = subprocess.run(['ls', 'nonexistentfile'], capture_output=True)
if result.returncode != 0:
    print('Command failed')
# Example 5: Using subprocess.Popen for more control
process = subprocess.Popen(['ping', 'localhost'], stdout=subprocess.PIPE)
while True:
    output = process.stdout.readline()
    if output == b'' and process.poll() is not None:
        break
    if output:
        print(output.strip().decode())

Automatisering af systemopgaver med Python

Bruger os.system og subproces moduler

import os
import subprocess
# Example 1: Using os.system to run a command
os.system('echo This is a test')
# Example 2: Running a command and capturing output with subprocess
result = subprocess.run(['date'], capture_output=True, text=True)
print('Current date and time:', result.stdout)
# Example 3: Executing multiple commands
commands = ['echo First command', 'echo Second command']
for cmd in commands:
    os.system(cmd)
# Example 4: Running a command with environment variables
env = os.environ.copy()
env['MY_VAR'] = 'Hello'
subprocess.run('echo $MY_VAR', shell=True, env=env)
# Example 5: Handling command errors
try:
    subprocess.check_output(['false_command'], stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
    print('An error occurred:', e.output.decode())

Avancerede teknikker til udførelse af systemkommandoer

Et andet aspekt ved at udføre systemkommandoer i Python involverer at bruge modul til at håndtere shell-kommando-parsing. Dette modul giver en måde at opdele shell-kommandoer i et listeformat, som derefter kan videregives til funktioner. Dette sikrer, at argumenter med mellemrum håndteres korrekt. Derudover kan du bruge at dirigere standard input-, output- og fejlstrømmene til moderprocessen, hvilket muliggør mere kompleks kommunikation mellem processer.

For eksempel kan kædekommandoer og behandle deres output sekventielt opnås ved at overføre outputtet fra en kommando til en anden ved at bruge . Dette giver dig mulighed for at oprette kraftfulde kommandosekvenser, der ligner det, du ville gøre i et shell-script. Du kan også bruge at køre flere underproceskommandoer samtidigt, hvilket forbedrer effektiviteten af ​​dit script, især når du håndterer I/O-bundne opgaver.

  1. Hvordan kan jeg køre en shell-kommando og få dens output i Python?
  2. Brug med for at fange kommandoens output.
  3. Hvad er forskellen mellem og ?
  4. er en enklere grænseflade, der venter på, at kommandoen er fuldført, mens giver mere kontrol over kommandoudførelsen, hvilket tillader asynkron drift.
  5. Hvordan håndterer jeg fejl, når jeg kører en systemkommando?
  6. Brug og klodser med at fange og håndtere fejl.
  7. Kan jeg sende miljøvariabler til en kommando?
  8. Ja, brug parameter i eller at videregive miljøvariabler.
  9. Hvordan kører jeg flere kommandoer i rækkefølge?
  10. Brug eller i en løkke eller kæde kommandoer ved hjælp af rør med .
  11. Hvordan kan jeg udføre en kommando, der kræver brugerinput?
  12. Brug med og kommunikere med processen vha .
  13. Hvad er brugen af i kommandoudførelse?
  14. hjælper med at parse shell-kommandoer korrekt, og sikrer, at argumenter med mellemrum håndteres korrekt.
  15. Hvordan kører jeg en kommando i baggrunden?
  16. Brug uden at vente på, at processen er fuldført eller brug at styre baggrundsudførelse.

Avancerede teknikker til udførelse af systemkommandoer

Et andet aspekt ved at udføre systemkommandoer i Python involverer at bruge modul til at håndtere shell-kommando-parsing. Dette modul giver en måde at opdele shell-kommandoer i et listeformat, som derefter kan videregives til funktioner. Dette sikrer, at argumenter med mellemrum håndteres korrekt. Derudover kan du bruge at dirigere standard input-, output- og fejlstrømmene til moderprocessen, hvilket muliggør mere kompleks kommunikation mellem processer.

For eksempel kan sammenkædning af kommandoer og behandling af deres output sekventielt opnås ved at overføre outputtet fra en kommando til en anden vha. . Dette giver dig mulighed for at oprette kraftfulde kommandosekvenser, der ligner det, du ville gøre i et shell-script. Du kan også bruge at køre flere underproceskommandoer samtidigt, hvilket forbedrer effektiviteten af ​​dit script, især når du håndterer I/O-bundne opgaver.

Udførelse af eksterne kommandoer i Python er en alsidig og kraftfuld funktion, der kan forbedre dine scripting- og automatiseringsopgaver markant. Ved at bruge modul, kan du køre shell-kommandoer, fange deres output og håndtere fejl effektivt. Det funktion giver et enklere alternativ til grundlæggende kommandoudførelse. Derudover inkorporerer modul sikrer korrekt parsing af komplekse shell-kommandoer. At forstå disse teknikker gør dig i stand til at udnytte Pythons styrker, mens du udnytter det fulde potentiale af dit operativsystems kommandolinjeværktøjer.