Comment exécuter un programme ou appeler une commande système ?

Question

Comment puis-je appeler une commande externe dans Python comme si je l'avais tapée dans un shell ou une invite de commande?

Answer 1

Utilisez subprocess.run:

import subprocess

subprocess.run(["ls", "-l"]) 

Une autre méthode commune est os.system mais vous ne devriez pas l'utiliser car elle est dangereuse si certaines parties de la commande proviennent de l'extérieur de votre programme ou peuvent contenir des espaces ou d'autres caractères spéciaux, de plus subprocess.run est généralement plus souple (vous pouvez obtenir le stdout, le stderr, le "vrai" code de statut, une meilleure gestion des erreurs, etc.). Même la documentation pour os.system recommande d'utiliser subprocess à la place.

Sur Python 3.4 et antérieur, utilisez subprocess.call à la place de .run:

subprocess.call(["ls", "-l"])

Answer 2

Voici un résumé des façons d'appeler des programmes externes, y compris leurs avantages et leurs inconvénients :

1. os.system passe la commande et les arguments à l'interpréteur de commandes de votre système. C'est agréable car vous pouvez réellement exécuter plusieurs commandes à la fois de cette manière et configurer des tubes et des redirections d'entrée/sortie. Par exemple :

   os.system("some_command < input_file | another_command > output_file")  

   Cependant, bien que ce soit pratique, vous devez gérer manuellement l'échappement des caractères du shell tels que les espaces, etc. D'autre part, cela vous permet également d'exécuter des commandes qui sont simplement des commandes shell et non réellement des programmes externes.

2. os.popen fera la même chose que os.system sauf qu'il vous donne un objet ressemblant à un fichier que vous pouvez utiliser pour accéder à l'entrée/sortie standard de ce processus. Il existe 3 autres variantes de popen qui gèrent tous légèrement différemment l'entrée/sortie. Si vous passez tout en tant que chaîne, alors votre commande est passée au shell ; si vous les passez en tant que liste alors vous n'avez pas à vous soucier de l'échappement de quoi que ce soit. Exemple :

   print(os.popen("ls -l").read())

3. subprocess.Popen. C'est censé être un remplacement pour os.popen, mais a l'inconvénient d'être légèrement plus compliqué en raison de sa complétude. Par exemple, vous diriez :

   print subprocess.Popen("echo Hello World", shell=True, stdout=subprocess.PIPE).stdout.read()

   au lieu de

   print os.popen("echo Hello World").read()

   mais il est agréable d'avoir toutes les options là dans une seule classe unifiée au lieu de 4 fonctions popen différentes. Voir la documentation.

4. subprocess.call. C'est essentiellement comme la classe Popen et prend tous les mêmes arguments, mais il attend simplement que la commande se termine et vous donne le code de retour. Par exemple :

   return_code = subprocess.call("echo Hello World", shell=True)

5. subprocess.run. Uniquement pour Python 3.5+. Similaire aux exemples ci-dessus mais encore plus flexible et renvoie un objet CompletedProcess lorsque la commande a fini de s'exécuter.

6. os.fork, os.exec, os.spawn sont similaires à leurs homologues du langage C, mais je ne les recommande pas en les utilisant directement.

Le module subprocess est probablement ce que vous devriez utiliser.

Enfin, veuillez noter que pour toutes les méthodes où vous passez la commande finale à exécuter par le shell en tant que chaîne et vous êtes responsable de l'échappement. Il y a de sérieuses implications en termes de sécurité si une partie de la chaîne que vous passez n'est pas entièrement fiable. Par exemple, si un utilisateur entre une partie de la chaîne. Si vous n'êtes pas sûr, utilisez uniquement ces méthodes avec des constantes. Pour vous donner une idée des implications, considérez ce code :

print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read()

et imaginez que l'utilisateur entre quelque chose "ma maman ne m'a pas aimé && rm -rf /" qui pourrait effacer tout le système de fichiers.

Answer 3

Implémentation typique :

import subprocess

p = subprocess.Popen('ls', shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
for line in p.stdout.readlines():
    print line,
retval = p.wait()

Vous êtes libre de faire ce que vous voulez avec les données de stdout dans le tuyau. En fait, vous pouvez simplement omettre ces paramètres (stdout= et stderr=) et cela se comportera comme os.system().

Answer 4

Quelques astuces sur comment détacher le processus enfant du processus appelant (démarrer le processus enfant en arrière-plan).

Supposez que vous voulez démarrer une tâche longue à partir d'un script CGI. C'est-à-dire que le processus enfant doit vivre plus longtemps que le processus d'exécution du script CGI.

L'exemple classique de la documentation du module subprocess est le suivant :

import subprocess
import sys

# Du code ici

pid = subprocess.Popen([sys.executable, "longtask.py"]) # Appeler le sous-processus

# Encore un peu de code ici

L'idée ici est que vous ne voulez pas attendre à la ligne 'Appeler le sous-processus' jusqu'à ce que longtask.py ait terminé. Mais il n'est pas clair ce qu'il se passe après la ligne 'encore un peu de code ici' de l'exemple.

Ma plateforme cible était FreeBSD, mais le développement était sur Windows, donc j'ai rencontré le problème sur Windows en premier.

Sous Windows (Windows XP), le processus parent ne se terminera pas tant que longtask.py n'aura pas terminé son travail. Ce n'est pas ce que vous voulez dans un script CGI. Le problème n'est pas spécifique à Python ; dans la communauté PHP, les problèmes sont les mêmes.

La solution est de passer le drapeau de création de processus DETACHED_PROCESS Process Creation Flag à la fonction sous-jacente CreateProcess dans l'API Windows. Si vous avez installé pywin32, vous pouvez importer le drapeau depuis le module win32process, sinon vous devez le définir vous-même :

DETACHED_PROCESS = 0x00000008

pid = subprocess.Popen([sys.executable, "longtask.py"],
                       creationflags=DETACHED_PROCESS).pid

/* UPD 2015.10.27 @eryksun dans un commentaire ci-dessous note que le drapeau sémantiquement correct est CREATE_NEW_CONSOLE (0x00000010) */

Sous FreeBSD, nous avons un autre problème : lorsque le processus parent se termine, il termine également les processus enfants. Et ce n'est pas ce que vous voulez dans un script CGI non plus. Quelques expériences ont montré que le problème semblait être lié au partage de sys.stdout. Et la solution de travail était la suivante :

pid = subprocess.Popen([sys.executable, "longtask.py"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)

Je n'ai pas vérifié le code sur d'autres plateformes et je ne connais pas les raisons du comportement sous FreeBSD. Si quelqu'un sait, veuillez partager vos idées. Une recherche sur le démarrage de processus en arrière-plan en Python ne semble pas encore éclairer.

Answer 5

Je recommanderais d'utiliser le module subprocess plutôt que os.system car il gère l'échappement du shell pour vous et est donc beaucoup plus sûr.

subprocess.call(['ping', 'localhost'])