Module subprocess de Python
subprocessest un module de la bibliothèque standard Python utilisé pour créer et gérer des sous-processus.
subprocessIl vous permet d'exécuter des commandes externes dans des programmes Python et d'interagir avec ces commandes.
Viasubprocessle module, vous pouvez exécuter des commandes système, appeler d'autres programmes et obtenir leur sortie ou leurs messages d'erreur.
Pourquoi utiliser le module subprocess ?
En Python, il est parfois nécessaire d'exécuter des commandes système ou d'appeler d'autres programmes pour accomplir des tâches spécifiques. Par exemple, vous pouvez avoir besoin d'exécuter une commande shell, de lancer une application externe ou d'interagir avec un outil en ligne de commande.subprocessLe module offre un moyen sûr et flexible de répondre à ces besoins.
Par rapport auxos.system()ouos.popen()approches,subprocessle module offre des fonctionnalités plus puissantes et un meilleur contrôle. Il vous permet de gérer plus finement les flux d'entrée, de sortie et d'erreur des sous-processus, et peut gérer des scénarios plus complexes.
Fonctionnalités principales du module subprocess
1. Exécuter des commandes externes
subprocess.run()OuisubprocessL'une des fonctions les plus couramment utilisées du module. Elle peut exécuter une commande externe et attendre que la commande se termine. Voici un exemple simple :
Exemple
# Exécuter une commande shell simple
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
# Afficher la sortie de la commande
print(result.stdout)
Dans cet exemple,subprocess.run()a exécuté lals -lcommande et capturé la sortie dansresult.stdoutle résultat.
2. Gérer l'entrée et la sortie
subprocessLe module vous permet de contrôler les flux d'entrée, de sortie et d'erreur des sous-processus. Vous pouvez transmettre des données à l'entrée standard d'un sous-processus, ou lire des données à partir de la sortie standard et de l'erreur standard d'un sous-processus. Voici un exemple :
Exemple
# Exécuter une commande et transmettre l'entrée au sous-processus
result = subprocess.run(['grep', 'python'], input='hello\npython\nworld', capture_output=True, text=True)
# Afficher la sortie de la commande
print(result.stdout)
Dans cet exemple,subprocess.run()a exécuté lagrep pythoncommande et avons passé la chaîne'hello\npython\nworld'comme entrée du sous-processus.
3. Gérer les erreurs
subprocessLe module vous permet également de gérer les erreurs des sous-processus. Si un sous-processus renvoie un code de statut de sortie non nul,subprocess.run()il lèvera uneCalledProcessErrorexception.result.returncodeVous pouvez vérifier
Exemple
try:
result = subprocess.run(['ls', 'nonexistent_file'], capture_output=True, text=True, check=True)
except subprocess.CalledProcessError as e:
print(f"Command failed with return code {e.returncode}")
print(f"Error output: {e.stderr}")
Exemplesubprocess.run()Dans cet exemple,ls nonexistent_filea exécuté laCalledProcessErrorcommande. Comme le fichier n'existe pas, la commande a échoué et a levé une
Utilisation avancée du module subprocess
1. Utilisation de la classe Popen
subprocess.Popen1. Utilisation de la classe PopenPopenLa classe fournit une interface de plus bas niveau qui vous permet de contrôler les sous-processus de manière plus flexible. Vous pouvez utiliser
Exemple
Exemple
process = subprocess.Popen(['ping', 'google.com'], stdout=subprocess.PIPE, text=True)
# Démarrer un sous-processus
while True:
output = process.stdout.readline()
if output == '' and process.poll() is not None:
break
if output:
print(output.strip())
# Lire la sortie du sous-processus
return_code = process.poll()
print(f"Processus terminé avec le code de retour {return_code}")
# Obtenir le code de sortie du sous-processussubprocess.PopenDans cet exemple,ping google.coma démarré un
2. Utilisation des tubes
subprocess2. Utilisation des tubes
Exemple
Exemple
p1 = subprocess.Popen(['ls', '-l'], stdout=subprocess.PIPE)
p2 = subprocess.Popen(['grep', 'py'], stdin=p1.stdout, stdout=subprocess.PIPE, text=True)
# Utiliser un tube pour connecter deux commandes
output = p2.communicate()[0]
print(output)
# Obtenir la sortie finalels -lDans cet exemple,grep pyla sortie de la commande est transmise àpycommande, et la sortie finale contient
Méthodes, classes et paramètres courants du module subprocess
Ce qui suit est une description des méthodes, classes et paramètres courants du module subprocess de Python, incluant les descriptions fonctionnelles et des exemples :
Méthodes principales du module subprocess
| Méthode | Description | Exemple |
|---|---|---|
subprocess.run() | Exécuter une commande et attendre la fin (recommandé) | subprocess.run(["ls", "-l"], capture_output=True, text=True) |
subprocess.Popen() | Créer un sous-processus (contrôle de bas niveau) | proc = subprocess.Popen(["ping", "google.com"], stdout=subprocess.PIPE) |
subprocess.call() | Exécuter une commande et renvoyer le code de sortie (ancienne méthode) | exit_code = subprocess.call(["python", "--version"]) |
subprocess.check_call() | Exécuter une commande et lever une exception en cas d'échec | subprocess.check_call(["git", "commit"]) |
subprocess.check_output() | Exécuter une commande et renvoyer la sortie (ancienne méthode) | output = subprocess.check_output(["date"], text=True) |
Attributs de l'objet subprocess.CompletedProcess (objet de retour de la méthode run())
| Attribut | Description |
|---|---|
args | Liste des arguments de la commande exécutée |
returncode | Code de statut de sortie du processus (0 indique le succès) |
stdout | Contenu de la sortie standard (si définicapture_output） |
stderr | Contenu de l'erreur standard (si définicapture_output） |
Méthodes/attributs courants de la classe subprocess.Popen
| Méthode/Attribut | Description | Exemple |
|---|---|---|
poll() | Vérifie si le processus est terminé (renvoieNoneTrue pour indiquer qu'il est en cours d'exécution) | if proc.poll() is None: print("Running") |
wait() | Bloque jusqu'à la fin du processus | proc.wait() |
communicate() | Entrée/sortie interactive | stdout, stderr = proc.communicate(input="data") |
terminate() | Envoyer le signal de terminaison (SIGTERM) | proc.terminate() |
kill() | Terminer de force le processus (SIGKILL) | proc.kill() |
stdin | Le flux d'entrée standard du processus | proc.stdin.write("input") |
stdout | Le flux de sortie standard du processus | print(proc.stdout.read()) |
stderr | Le flux d'erreur standard du processus | errors = proc.stderr.read() |
Descriptions des paramètres communs (applicables à run() et Popen())
| Paramètre | Description | Valeur d'exemple |
|---|---|---|
args | Commande (liste ou chaîne) | ["ls", "-l"]ou"ls -l" |
stdin | Configuration de l'entrée standard | subprocess.PIPE(pipe),None(inherit) |
stdout | Configuration de la sortie standard | subprocess.PIPE、open('log.txt', 'w') |
stderr | Configuration de l'erreur standard | subprocess.STDOUT(fusionné dans stdout) |
shell | Indique s'il faut exécuter via Shell | True(prend en charge les commandes sous forme de chaîne) |
cwd | Chemin du répertoire de travail | "/tmp" |
env | Variables d'environnement personnalisées | {"PATH": "/usr/bin"} |
timeout | Délai d'attente (secondes) | 30 |
text | Indique si l'entrée/sortie est une chaîne (pas des octets) | True |
Exemple
Exécuter une commande et capturer la sortie :
Exemple
print(result.stdout) # Sortie : "Hello\n"
Exécuter des commandes complexes via le shell :
subprocess.run("grep 'error' log.txt | wc -l", shell=True, check=True)Obtenir le flux de sortie en temps réel :Exemple
while True:
line = proc.stdout.readline()
if not line: break
print(line.decode().strip())
Contrôle du délai d'attente :
Exemple
subprocess.run(["sleep", "10"], timeout=5)
except subprocess.TimeoutExpired:
print("La commande a expiré !")