Une introduction à Python Subprocess : Principes de base et exemples

Quand utiliser Python Subprocess

Voyons quand utiliser le module Python subprocess.

Automatisation des tâches du système

Le module de sous-processus peut être utilisé pour automatiser diverses tâches du système, telles que l'exécution de sauvegardes, le démarrage et l'arrêt de services et la programmation de tâches cron. Par exemple, vous pouvez utiliser le module de sous-processus pour exécuter la commande cp afin de créer une sauvegarde d'un fichier ou la commande service pour démarrer et arrêter des services sur les systèmes Linux. Vous pouvez également utiliser le module subprocess pour planifier des tâches à exécuter à des intervalles spécifiques à l'aide de cron ou d'autres outils de planification.

Exécution d'outils en ligne de commande

Le module subprocess peut être utilisé pour exécuter des outils de ligne de commande tels que grep, sed, et awk, et traiter leurs résultats dans votre code Python. Par exemple, vous pouvez utiliser le module subprocess pour exécuter la commande grep afin de rechercher un motif spécifique dans un fichier, puis traiter le résultat dans votre code Python. Cela peut être utile pour des tâches telles que l'analyse de journaux, le traitement de données et la manipulation de texte.

Exécution d'exécutables externes

Le module de sous-processus peut exécuter d'autres exécutables, tels que les fichiers .exe sous Windows, et contrôler leur comportement. Par exemple, vous pouvez utiliser le module subprocess pour exécuter un exécutable qui effectue une tâche spécifique, puis utiliser la sortie de cet exécutable dans votre propre code. Cela peut être utile pour le traitement d'images, l'analyse de données et les tâches d'apprentissage automatique.

Exécution de scripts en tant que processus d'arrière-plan

Vous pouvez utiliser le module subprocess pour exécuter des scripts en tant que processus d'arrière-plan, de sorte qu'ils continuent à s'exécuter après la sortie du programme principal. Par exemple, vous pouvez utiliser le module subprocess pour exécuter un script qui effectue une tâche spécifique et quitter le programme principal sans attendre la fin du script. Cela peut être utile pour la surveillance, l'enregistrement et la collecte de données.

Exécution de scripts avec un interpréteur autre que Python

Le module subprocess peut vous aider à exécuter des scripts écrits dans d'autres langages tels que Perl, Ruby et Bash. Par exemple, vous pouvez utiliser le module subprocess pour exécuter un script Perl qui effectue une tâche spécifique, puis utiliser la sortie de ce script dans votre propre code. Cela peut être utile pour le traitement des données, la manipulation de texte et l'administration du système.

Traitement parallèle

Le module de sous-processus peut être utilisé pour exécuter plusieurs processus en parallèle, ce qui peut être utile pour des tâches telles que le traitement d'images, l'analyse de données et l'apprentissage automatique. Par exemple, vous pouvez utiliser le module subprocess pour exécuter plusieurs instances du même script, chacune traitant une partie différente des données, puis combiner les résultats.

Exemples de sous-processus en Python 

Voyons maintenant quelques exemples de sous-processus Python.

python subprocess run

La méthode subprocess.run() est un moyen pratique d'exécuter un sous-processus et d'attendre qu'il se termine. Il vous permet de choisir la commande à exécuter et d'ajouter des options telles que des arguments, des variables d'environnement et des redirections d'entrée/sortie. Une fois le sous-processus lancé, la méthode run() se bloque jusqu'à ce que le sous-processus se termine et renvoie un objet CompletedProcess, qui contient le code de retour et la sortie du sous-processus.

La méthode subprocess.run() prend plusieurs arguments, dont voici quelques-uns :

• args: La commande à exécuter et ses arguments, transmis sous la forme d'une liste de chaînes de caractères.

• capture_output: Lorsqu'il vaut True, il capture la sortie standard et l'erreur standard.

• text: Lorsqu'il vaut True, il renvoie le stdout et le stderr sous forme de chaîne de caractères, sinon sous forme d'octets.

• check: une valeur booléenne qui indique s'il faut vérifier le code de retour du sous-processus. Si la vérification est vraie et que le code de retour est différent de zéro, le sous-processus CalledProcessError est activé.

• timeout: Une valeur en secondes qui spécifie combien de temps il faut attendre que le sous-processus se termine avant de s'arrêter.

• shell: Valeur booléenne indiquant si la commande doit être exécutée dans un shell. Cela signifie que la commande est transmise sous la forme d'une chaîne de caractères et que les fonctionnalités propres à l'interpréteur de commandes, telles que l'expansion de caractères génériques et la substitution de variables, peuvent être utilisées.

La méthode subprocess.run() renvoie également un objet CompletedProcess, qui contient les attributs suivants :

• args: La commande et les arguments qui ont été exécutés.

• returncode: Le code de retour du sous-processus.

• stdout: La sortie standard du sous-processus, sous la forme d'un objet bytes.

• stderr: L'erreur standard du sous-processus, sous la forme d'un objet bytes.

Exemple 1 : Exécution de commandes shell :

import subprocess

result = subprocess.run(["dir"], shell=True, capture_output=True, text=True)

print(result.stdout)

Sortie : 

Volume in drive C has no label.

Volume Serial Number is E414-A41C

 Directory of C:\Users\owner

01/25/2023  10:56 AM    <DIR>          .

01/25/2023  10:56 AM    <DIR>          ..

07/19/2021  01:19 PM    <DIR>          .anaconda

07/19/2021  01:19 PM    <DIR>          .astropy

07/19/2021  01:19 PM    <DIR>          .aws

09/12/2022  08:48 AM               496 .bash_history

03/27/2022  03:08 PM    <DIR>          .cache

09/26/2021  06:58 AM    <DIR>          .conda

09/26/2021  06:59 AM                25 .condarc

…

Les utilisateurs de Linux ou de Mac remplacent dir par ls et se débarrassent de l'argument shell.

Exemple 2 : Exécution de scripts Python :

Vous pouvez également exécuter un script python à l'aide de la méthode subprocess.run(). Commençons par créer un simple script Python dans le fichier .py

print(“This is the output from subprocess module”)

Enregistrez ce fichier sous my_python_file.py. Vous pouvez maintenant utiliser le module subprocess pour exécuter ce fichier :

import subprocess

result = subprocess.run(["python", "my_python_file.py"], capture_output=True, text=True)

print(result.stdout)

Sortie :

This is the output from subprocess module

Exemple 3 : Exécution du code Python directement à partir d'une fonction :

Pour des cas d'utilisation simples, vous pouvez passer directement une commande python dans la fonction subprocess.run(). Voici comment :

result = subprocess.run(["C:/Users/owner/anaconda3/python", "-c", "print('This is directly from a subprocess.run() function')"], capture_output = True, text = True)

print(result.stdout)

Sortie :

This is directly from a subprocess.run() function

Dans la liste args, le premier élément C:/Users/owner/anaconda3/python est un chemin d'accès à l'exécutable Python (votre chemin d'accès peut être différent). Le deuxième élément, -c, est une balise Python qui permet à l'utilisateur d'écrire du code Python sous forme de texte sur la ligne de commande. Le troisième élément, print(...), est la commande Python elle-même.

Exemple 4 : Utilisation de l'argument de vérification

L'argument check est un argument facultatif de la fonction subprocess.run() du module de sous-processus Python. Il s'agit d'une valeur booléenne qui détermine si la fonction doit vérifier le code de retour de la commande exécutée.

Lorsque check est défini sur True, la fonction vérifie le code de retour de la commande et lève une exception CalledProcessError si le code de retour est différent de zéro. L'exception aura pour attributs le code de retour, stdout, stderr, et command.

Lorsque check est défini sur False (valeur par défaut), la fonction ne vérifie pas le code de retour et ne lève pas d'exception, même si la commande échoue.

import subprocess

result = subprocess.run(["python", "file_donot_exist.py"], capture_output=True, text=True, check=True)

print(result.stdout)

print(result.stderr)

Sortie :

---------------------------------------------------------------------------

CalledProcessError                        Traceback (most recent call last)

<ipython-input-81-503b60184db8> in <module>

      1 import subprocess

----> 2 result = subprocess.run(["python", "file_donot_exist.py"], capture_output=True, text=True, check=True)

      3 print(result.stdout)

      4 print(result.stderr)

~\anaconda3\lib\subprocess.py in run(input, capture_output, timeout, check, *popenargs, **kwargs)

    514         retcode = process.poll()

    515         if check and retcode:

--> 516             raise CalledProcessError(retcode, process.args,

    517                                      output=stdout, stderr=stderr)

    518     return CompletedProcess(process.args, retcode, stdout, stderr)

CalledProcessError: Command '['python', 'file_donot_exist.py']' returned non-zero exit status 2.

Notez que la commande a échoué car file_donot_exist.py n'existe pas. Contrairement à ce qui se passe lorsque vous définissez check=True, votre processus n'échouera pas ; au lieu de cela, vous obtiendrez le message d'erreur de stdout. 

import subprocess

result = subprocess.run(["python", "my_python_file2.py"], capture_output=True, text=True, check=False)

print(result.stdout)

print(result.stderr)

Sortie :

python: can't open file 'my_python_file2.py': [Errno 2] No such file or directory

python subprocess Popen

subprocess.Popen() est une interface de bas niveau pour l'exécution de sous-processus, tandis que subprocess.run est une enveloppe de haut niveau autour de Popen, destinée à être plus pratique à utiliser.

Popen vous permet de lancer un nouveau processus et d'interagir avec ses flux standard d'entrée, de sortie et d'erreur. Il renvoie une poignée au processus en cours qui peut être utilisée pour attendre que le processus se termine, vérifier son code de retour ou y mettre fin.

run() est une fonction plus pratique qui vous permet d'exécuter une commande et de capturer sa sortie en un seul appel, sans avoir à créer un objet Popen et à gérer les flux vous-même. Il vous permet également de spécifier diverses options pour l'exécution de la commande, par exemple de lever une exception si la commande échoue.

En général, vous devriez utiliser run() si vous avez juste besoin d'exécuter une commande et de capturer sa sortie et Popen si vous avez besoin de plus de contrôle sur le processus, comme interagir avec ses flux d'entrée et de sortie.

La classe Popen prend les mêmes arguments que run(), y compris les arguments qui spécifient la commande à exécuter et d'autres arguments facultatifs tels que stdin, stdout, stderr, shell, cwd, et env. De plus, la classe Popen possède plusieurs méthodes qui vous permettent d'interagir avec le processus, telles que communicate(), poll(), wait(), terminate(), et kill().

import subprocess

p = subprocess.Popen(["python", "--help"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

output, errors = p.communicate()

print(output)

Sortie :

usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...

Options and arguments (and corresponding environment variables):

-b     : issue warnings about str(bytes_instance), str(bytearray_instance)

         and comparing bytes/bytearray with str. (-bb: issue errors)

-B     : don't write .pyc files on import; also PYTHONDONTWRITEBYTECODE=x

-c cmd : program passed in as string (terminates option list)

-d     : debug output from parser; also PYTHONDEBUG=x

-E     : ignore PYTHON* environment variables (such as PYTHONPATH)

…

Cette opération exécute la commande python –help et crée un nouvel objet Popen, qui est stocké dans la variable p. La sortie et l'erreur standard de la commande sont capturées à l'aide de la méthode communicate() et stockées dans les variables output et errors, respectivement.

subprocess.Popen est utile lorsque vous souhaitez contrôler davantage le processus, par exemple en lui envoyant des données d'entrée, en recevant des données de sortie ou en attendant qu'il se termine.

Appel de sous-processus en python

subprocess.call() est une fonction du module de sous-processus de Python qui est utilisée pour exécuter une commande dans un processus séparé et attendre qu'elle se termine. Il renvoie le code de retour de la commande, qui est égal à zéro si la commande a réussi, et différent de zéro si elle a échoué.

La fonction call() prend les mêmes arguments que run(), y compris les arguments qui spécifient la commande à exécuter, et d'autres arguments facultatifs, tels que stdin, stdout, stderr, shell, cwd, et env.

La sortie standard et l'erreur de la commande sont envoyées aux mêmes stdout et stderr que le processus parent, à moins que vous ne les redirigiez à l'aide des arguments stdout et stderr.

import subprocess

return_code = subprocess.call(["python", "--version"])

if return_code == 0:

    print("Command executed successfully.")

else:

    print("Command failed with return code", return_code)

Sortie :

Command executed successfully.

La commande python –version sera exécutée dans un processus séparé et attendra qu'elle soit terminée. Le code de retour de la commande sera stocké dans la variable return_code. Il sera égal à zéro si la commande a réussi, et différent de zéro si elle a échoué.

subprocess.call() est utile lorsque vous souhaitez exécuter une commande et vérifier le code de retour, mais que vous n'avez pas besoin de capturer la sortie.

python subprocess check_output

check_output est une fonction du module subprocess qui est similaire à run(), mais elle ne renvoie que la sortie standard de la commande et soulève une exception CalledProcessError si le code de retour est différent de zéro.

La fonction check_output() prend les mêmes arguments que run(), y compris les arguments qui spécifient la commande à exécuter, et d'autres arguments facultatifs, tels que stdin, stderr, shell, cwd, et env.

La fonction check_output() renvoie la sortie standard de la commande sous la forme d'un objet octet ou d'une chaîne de caractères, si text=True est fourni.

import subprocess

try:

    output = subprocess.check_output(["python", "--version"], text=True)

    print(output)

except subprocess.CalledProcessError as e:

    print(f"Command failed with return code {e.returncode}")

Sortie :

Python 3.8.8

Pipe de sous-processus Python

Le module Python subprocess permet de créer et d'interagir avec des processus enfants, qui peuvent être utilisés pour exécuter d'autres programmes ou commandes. L'une des caractéristiques du module de sous-processus est la possibilité de créer des tuyaux, qui permettent la communication entre le processus parent et le processus enfant.

Un tuyau est un canal de communication unidirectionnel qui relie la sortie standard d'un processus à l'entrée standard d'un autre processus. Un tuyau peut relier la sortie d'une commande à l'entrée d'une autre, ce qui permet d'utiliser la sortie de la première commande comme entrée de la seconde.

Les tuyaux peuvent être créés à l'aide du module de sous-processus avec la classe Popen en spécifiant l'argument stdout ou stdin comme subprocess.PIPE.

Par exemple, le code suivant crée un tuyau qui relie la sortie de la commande ls à l'entrée de la commande grep, qui filtre la sortie pour n'afficher que les lignes contenant le mot "file":

import subprocess

ls_process = subprocess.Popen(["ls"], stdout=subprocess.PIPE, text=True)

grep_process = subprocess.Popen(["grep", "sample"], stdin=ls_process.stdout, stdout=subprocess.PIPE, text=True)

output, error = grep_process.communicate()

print(output)

print(error)

Sortie :

sample_data

Dans cet exemple, la classe Popen est utilisée pour créer deux processus enfants, l'un pour la commande ls et l'autre pour la commande grep. Le stdout de la commande ls est connecté au stdin de la commande grep à l'aide de subprocess.PIPE, ce qui crée un tuyau entre les deux processus. La méthode communicate() est utilisée pour envoyer la sortie de la commande ls à la commande grep et récupérer la sortie filtrée.

Conclusion

Le module Python subprocess offre un moyen puissant et flexible de créer des processus enfants et d'interagir avec eux, ce qui vous permet d'exécuter d'autres programmes ou de lancer des commandes à partir de votre script Python. Des commandes simples comme subprocess.call() aux fonctionnalités plus avancées comme les pipes, la redirection des entrées et sorties et le passage de variables d'environnement, le module subprocess a quelque chose à offrir pour presque tous les cas d'utilisation. C'est un excellent moyen d'automatiser des tâches répétitives, d'exécuter des commandes système et même d'interagir avec d'autres langages de programmation et plates-formes.

Lorsque vous travaillez avec le module subprocess, il est important de vous rappeler que l'exécution de commandes externes présente un risque pour la sécurité, en particulier lorsque vous utilisez le paramètre shell=True ou que vous transmettez des données d'entrée non nettoyées. C'est toujours une bonne pratique d'utiliser la fonction subprocess.run() qui vous permet de spécifier diverses options sur la façon dont la commande doit être exécutée, comme par exemple lever une exception si la commande échoue. 

Si vous souhaitez vous plonger dans les possibilités infinies de l'automatisation de la ligne de commande grâce à Python, consultez notre cours Automatisation de la ligne de commande en Python. Dans ce cours, vous apprendrez à écrire un code d'automatisation qui parcourra un système de fichiers, recherchera des fichiers qui suivent un modèle, puis déterminera si les fichiers sont dupliqués dans l'un des nombreux cas. À l'issue de ce cours, vous serez en mesure de gérer et d'interagir avec les processus Unix, ainsi que d'automatiser une série d'activités courantes du système de fichiers. 

Améliorez les compétences de votre équipe en Python avec DataCamp for Business

Si vous ou votre équipe cherchez à améliorer vos compétences en Python et en automatisation de ligne de commande, envisagez d'explorer DataCamp for Business. DataCamp offre des solutions d'apprentissage sur mesure pour des équipes de toutes tailles, aidant les entreprises à rester en tête dans le paysage technologique en évolution rapide. Avec DataCamp for Business, vous pouvez améliorer les compétences de votre équipe grâce à des cours et des parcours d'apprentissage personnalisés conçus pour développer une expertise en Python, en automatisation et en d'autres outils essentiels de la science des données. Que vous soyez une startup ou une entreprise, DataCamp for Business vous offre les ressources et la flexibilité nécessaires pour atteindre les objectifs d'apprentissage de votre équipe. Demandez une démonstration dès aujourd'hui pour en savoir plus.