Appeler une commande externe en Python
Comment puis-je appeler une commande externe (comme si je l'avais saisie à l'invite de commande Unix Shell ou Windows) à partir d'un script Python?
Regardez le module du sous-processus dans la bibliothèque standard:
import subprocess
subprocess.run(["ls", "-l"])
L'avantage de subprocess par rapport à system est qu'il est plus flexible (vous pouvez obtenir le stdout, stderr, le "vrai" code d'état, une meilleure gestion des erreurs, etc.).
La documentation officielle recommande le module subprocess sur l'alternative os.system ():
Le module subprocess fournit des fonctionnalités plus puissantes pour générer de nouveaux processus et récupérer leurs résultats. Il est préférable d’utiliser ce module plutôt que d’utiliser cette fonction [
os.system()].
La section " Remplacement d'anciennes fonctions par le sous-processus Module " de la documentation subprocess peut contenir des recettes utiles.
Voici un résumé des manières d’appeler des programmes externes et des avantages et inconvénients de chacun:
os.system("some_command with args")transmet la commande et les arguments au shell de votre système. C'est bien parce que vous pouvez réellement exécuter plusieurs commandes à la fois de cette manière et configurer des canaux et une redirection entrée/sortie. Par exemple:os.system("some_command < input_file | another_command > output_file")Cependant, bien que cela soit pratique, vous devez gérer manuellement l'échappement de caractères Shell tels que des espaces, etc. D'autre part, cela vous permet également d'exécuter des commandes qui sont simplement des commandes Shell et non des programmes externes. Voir la documentation .
stream = os.popen("some_command with args")fera la même chose queos.systemsauf qu'il vous donnera un objet de type fichier que vous pouvez utiliser pour accéder aux entrées/sorties standard de ce processus. Il existe 3 autres variantes de popen qui traitent l’e/s légèrement différemment. Si vous transmettez tout en tant que chaîne, votre commande est transmise au shell; si vous les transmettez sous forme de liste, vous n'avez pas à craindre d'échapper à rien. Voir la documentation .La classe
Popendu modulesubprocess. Ceci est destiné à remplaceros.popen, mais présente l'inconvénient d'être un peu plus compliqué en raison de son exhaustivité. 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 bien d’avoir toutes les options dans une classe unifiée au lieu de 4 fonctions popen différentes. Voir la documentation .
La fonction
calldu modulesubprocess. Ceci est fondamentalement juste comme la classePopenet prend tous les mêmes arguments, mais 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)Voir la documentation .
Si vous utilisez Python 3.5 ou une version ultérieure, vous pouvez utiliser la nouvelle fonction
subprocess.run, qui ressemble beaucoup à la précédente mais qui est encore plus flexible et renvoie un objetCompletedProcessà la fin de l’exécution de la commande.Le module os possède également toutes les fonctions fork/exec/spawn que vous auriez dans un programme C, mais je ne recommande pas de les utiliser directement.
Le module subprocess devrait probablement être ce que vous utilisez.
Enfin, sachez que pour toutes les méthodes dans lesquelles vous passez la dernière commande à exécuter par le shell en tant que chaîne, vous êtes responsable de son échappement. Il y a de graves conséquences pour la sécurité si une partie de la chaîne que vous transmettez ne peut être entièrement approuvée. Par exemple, si un utilisateur entre une partie ou n’importe quelle 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érons ce code:
print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read()
et imaginez que l'utilisateur entre "ma mère ne m'a pas aimé && rm -rf /".
J'utilise typiquement:
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 stdout dans le canal. En fait, vous pouvez simplement omettre ces paramètres (stdout= et stderr=) et cela se comportera comme os.system().
Quelques astuces pour détacher le processus enfant du processus appelant (démarrage du processus enfant en arrière-plan).
Supposons que vous souhaitiez démarrer une tâche longue à partir d'un script CGI, c'est-à-dire que le processus enfant devrait vivre plus longtemps que le processus d'exécution du script CGI.
L'exemple classique tiré de la documentation du module de sous-processus est le suivant:
import subprocess
import sys
# some code here
pid = subprocess.Popen([sys.executable, "longtask.py"]) # call subprocess
# some more code here
L'idée ici est que vous ne voulez pas attendre dans la ligne 'call subprocess' jusqu'à ce que le fichier longtask.py soit terminé. Mais il n’est pas clair ce qui se passe après la ligne «plus de code ici» de l’exemple.
Ma plate-forme cible était FreeBSD, mais le développement était sous Windows, donc j'ai d'abord fait face au problème sous Windows.
Sur Windows (Win XP), le processus parent ne sera pas terminé avant que le fichier longtask.py ait terminé son travail. Ce n'est pas ce que vous voulez dans CGI-script. Le problème n'est pas spécifique à Python, dans la communauté PHP, les problèmes sont les mêmes.
La solution consiste à transmettre DETACHED_PROCESS Indicateur de création de processus à la fonction CreateProcess sous-jacente dans Win API . Si vous avez installé pywin32, vous pouvez importer l'indicateur à partir du 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 indique que l'indicateur sémantiquement correct est CREATE_NEW_CONSOLE (0x00000010) * /
Sur freebsd, nous avons un autre problème: lorsque le processus parent est terminé, il termine également les processus enfants. Et ce n’est pas ce que vous voulez dans CGI-script non plus. Certaines expériences ont montré que le problème semblait être de partager 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 plates-formes et ne connais pas les raisons du comportement sur FreeBSD. Si quelqu'un le sait, partagez vos idées, s'il vous plaît. Googler lors du démarrage de processus en arrière-plan en Python n'éclaire pas encore.
import os
cmd = 'ls -al'
os.system(cmd)
Si vous voulez renvoyer les résultats de la commande, vous pouvez utiliser os.popen . Cependant, cela est déconseillé depuis la version 2.6 au profit du module subprocess , que d'autres réponses ont bien couvert.
Je recommanderais d'utiliser le module subprocess au lieu de os.system, car Shell échappe pour vous et est donc beaucoup plus sûr: http://docs.python.org/library/subprocess.html
subprocess.call(['ping', 'localhost'])
import os
os.system("your command")
Notez que c'est dangereux, car la commande n'est pas nettoyée. Je vous laisse le soin de rechercher sur Google la documentation pertinente sur les modules «os» et «sys». Il y a un tas de fonctions (exec * et spawn *) qui vont faire la même chose.
Il y a beaucoup de bibliothèques différentes qui vous permettent d'appeler des commandes externes avec Python. Pour chaque bibliothèque, j'ai donné une description et un exemple d'appel d'une commande externe. La commande que j'ai utilisée comme exemple est ls -l (liste tous les fichiers). Si vous souhaitez en savoir plus sur l’une des bibliothèques que j’ai énumérées et reliée à la documentation correspondante.
Sources:
- sous-processus: https://docs.python.org/3.5/library/subprocess.html
- shlex: https://docs.python.org/3/library/shlex.html
- os: https://docs.python.org/3.5/library/os.html
- sh: https://amoffat.github.io/sh/
- plumbum: https://plumbum.readthedocs.io/en/latest/
- pexpect: https://pexpect.readthedocs.io/fr/stable/
- tissu: http://www.fabfile.org/
- envoyé: https://github.com/kennethreitz/envoy
- commandes: https://docs.python.org/2/library/commands.html
Ce sont toutes les bibliothèques:
J'espère que cela vous aidera à prendre une décision sur la bibliothèque à utiliser :)
sous-processus
Le sous-processus vous permet d'appeler des commandes externes et de les connecter à leurs canaux d'entrée/sortie/d'erreur (stdin, stdout et stderr). Le sous-processus est le choix par défaut pour l'exécution des commandes, mais parfois d'autres modules sont meilleurs.
subprocess.run(["ls", "-l"]) # Run command
subprocess.run(["ls", "-l"], stdout=subprocess.PIPE) # This will run the command and return any output
subprocess.run(shlex.split("ls -l")) # You can also use the shlex library to split the command
os
os est utilisé pour "la fonctionnalité dépendant du système d'exploitation". Il peut également être utilisé pour appeler des commandes externes avec os.system et os.popen (Remarque: il existe également un sous-processus.popen). os exécutera toujours le shell et constitue une alternative simple pour les personnes qui n'en ont pas besoin ou qui ne savent pas comment utiliser subprocess.run.
os.system("ls -l") # run command
os.popen("ls -l").read() # This will run the command and return any output
sh
sh est une interface de sous-processus qui vous permet d'appeler des programmes comme s'il s'agissait de fonctions. Ceci est utile si vous souhaitez exécuter une commande plusieurs fois.
sh.ls("-l") # Run command normally
ls_cmd = sh.Command("ls") # Save command as a variable
ls_cmd() # Run command as if it were a function
plumbum
plumbum est une bibliothèque pour les programmes Python "de type script". Vous pouvez appeler des programmes tels que des fonctions comme dans sh. Plumbum est utile si vous souhaitez exécuter un pipeline sans Shell.
ls_cmd = plumbum.local("ls -l") # get command
ls_cmd() # run command
pexpect
pexpect vous permet de créer des applications enfants, de les contrôler et de trouver des modèles dans leur sortie. C'est une meilleure alternative au sous-processus pour les commandes qui attendent un tty sous Unix.
pexpect.run("ls -l") # Run command as normal
child = pexpect.spawn('scp foo [email protected]:.') # Spawns child application
child.expect('Password:') # When this is the output
child.sendline('mypassword')
en tissu
fabric est une bibliothèque Python 2.5 et 2.7. Il vous permet d'exécuter des commandes Shell locales et distantes. Fabric est une alternative simple pour l'exécution de commandes dans un shell sécurisé (SSH)
fabric.operations.local('ls -l') # Run command as normal
fabric.operations.local('ls -l', capture = True) # Run command and receive output
envoyé
envoy est appelé "sous-processus pour les humains". Il est utilisé comme un wrapper de commodité autour du module subprocess.
r = envoy.run("ls -l") # Run command
r.std_out # get output
orders
commands contient des fonctions d'encapsulation pour os.popen, mais il a été supprimé de Python 3, car subprocess est une meilleure alternative.
Le montage était basé sur le commentaire de J.F. Sebastian.
J'utilise toujours fabric pour ces choses comme:
from fabric.operations import local
result = local('ls', capture=True)
print "Content:/n%s" % (result, )
Mais cela semble être un bon outil: sh (interface de sous-processus Python) .
Regardez un exemple:
from sh import vgdisplay
print vgdisplay()
print vgdisplay('-v')
print vgdisplay(v=True)
Vérifiez aussi la bibliothèque "pexpect" Python.
Il permet le contrôle interactif de programmes/commandes externes, même ssh, ftp, telnet, etc. Vous pouvez simplement taper quelque chose comme:
child = pexpect.spawn('ftp 192.168.0.24')
child.expect('(?i)name .*: ')
child.sendline('anonymous')
child.expect('(?i)password')
Si vous avez besoin du résultat de la commande que vous appelez, vous pouvez utiliser subprocess.check_output (Python 2.7+).
>>> subprocess.check_output(["ls", "-l", "/dev/null"])
'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
Notez également le paramètre Shell .
Si Shell est
True, la commande spécifiée sera exécutée via le Shell. Cela peut être utile si vous utilisez principalement Python pour le flux de contrôle amélioré proposé par la plupart des interpréteurs de commandes système, tout en souhaitant un accès pratique à d'autres fonctionnalités de Shell, telles que les pipes Shell, les caractères génériques de nom de fichier, l'extension des variables d'environnement et l'extension de ~ au domicile de l'utilisateur annuaire. Cependant, notez que Python lui-même offre des implémentations de nombreuses fonctionnalités de type Shell (en particulier,glob,fnmatch,os.walk(),os.path.expandvars(),os.path.expanduser()etshutil).
Avec bibliothèque standard
Le Utilisez module de sous-processus (Python 3):
import subprocess
subprocess.run(['ls', '-l'])
C'est la méthode standard recommandée. Cependant, des tâches plus complexes (pipes, sortie, entrée, etc.) peuvent être fastidieuses à construire et à écrire.
Note sur la version Python: Si vous utilisez toujours Python 2, subprocess.call fonctionne de manière similaire.
ProTip: shlex.split peut vous aider à analyser la commande pour run, call et d'autres fonctions subprocess si vous ne voulez pas (ou vous ne pouvez pas!) Les fournir sous forme de listes :
import shlex
import subprocess
subprocess.run(shlex.split('ls -l'))
Avec dépendances externes
Si les dépendances externes ne vous dérangent pas, utilisez plumbum :
from plumbum.cmd import ifconfig
print(ifconfig['wlan0']())
C'est le meilleur wrapper subprocess. Il est multi-plateforme, c’est-à-dire qu’il fonctionne à la fois sous Windows et sous Unix. Installez par pip install plumbum.
Une autre bibliothèque populaire est sh :
from sh import ifconfig
print(ifconfig('wlan0'))
Cependant, sh a cessé de prendre en charge Windows. Ce n'est donc pas aussi génial qu'avant. Installez par pip install sh.
C'est comme ça que je lance mes commandes. Ce code contient tout ce dont vous avez besoin
from subprocess import Popen, PIPE
cmd = "ls -l ~/"
p = Popen(cmd , Shell=True, stdout=PIPE, stderr=PIPE)
out, err = p.communicate()
print "Return code: ", p.returncode
print out.rstrip(), err.rstrip()
Mettre à jour:
subprocess.run est l'approche recommandée à partir de Python 3.5 si votre code n'a pas besoin de maintenir la compatibilité avec les versions antérieures de Python. Il est plus cohérent et offre une facilité d’utilisation similaire à celle d’Envoy. (La tuyauterie n’est cependant pas aussi simple. Voir cette question pour savoir comment .)
Voici quelques exemples de the docs .
Lancer un processus:
>>> subprocess.run(["ls", "-l"]) # doesn't capture output
CompletedProcess(args=['ls', '-l'], returncode=0)
Relancer en cas d'échec:
>>> subprocess.run("exit 1", Shell=True, check=True)
Traceback (most recent call last):
...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1
Capture de sortie:
>>> subprocess.run(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE)
CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,
stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\n')
Réponse originale:
Je recommande d'essayer Envoy . C'est un wrapper pour les sous-processus, qui a pour but de remplacer les modules et fonctions plus anciens. Envoy est un sous-processus pour les humains.
Exemple d'utilisation de the readme :
>>> r = envoy.run('git config', data='data to pipe in', timeout=2)
>>> r.status_code
129
>>> r.std_out
'usage: git config [options]'
>>> r.std_err
''
Tuyaux autour aussi:
>>> r = envoy.run('uptime | pbcopy')
>>> r.command
'pbcopy'
>>> r.status_code
0
>>> r.history
[<Response 'uptime'>]
Sans la sortie du résultat:
import os
os.system("your command here")
Avec sortie du résultat:
import commands
commands.getoutput("your command here")
or
commands.getstatusoutput("your command here")
https://docs.python.org/2/library/subprocess.html
... ou pour une commande très simple:
import os
os.system('cat testfile')
Il y a aussi Plumbum
>>> from plumbum import local
>>> ls = local["ls"]
>>> ls
LocalCommand(<LocalPath /bin/ls>)
>>> ls()
u'build.py\ndist\ndocs\nLICENSE\nplumbum\nREADME.rst\nsetup.py\ntests\ntodo.txt\n'
>>> notepad = local["c:\\windows\\notepad.exe"]
>>> notepad() # Notepad window pops up
u'' # Notepad window is closed by user, command returns
os.system est OK, mais un peu daté. Ce n'est pas très sécurisé non plus. Au lieu de cela, essayez subprocess. subprocess n'appelle pas sh directement et est donc plus sécurisé que os.system.
Obtenez plus d'informations ici .
Appeler une commande externe en Python
Simple, utilisez subprocess.run, qui retourne un objet CompletedProcess:
>>> import subprocess
>>> completed_process = subprocess.run('python --version')
Python 3.6.1 :: Anaconda 4.4.0 (64-bit)
>>> completed_process
CompletedProcess(args='python --version', returncode=0)
Pourquoi?
A partir de Python 3.5, la documentation recommande subprocess.run :
L'approche recommandée pour appeler des sous-processus consiste à utiliser la fonction run () pour tous les cas d'utilisation qu'il peut gérer. Pour des cas d'utilisation plus avancés, l'interface Popen sous-jacente peut être utilisée directement.
Voici un exemple d'utilisation la plus simple possible - et exactement comme demandé:
>>> import subprocess
>>> completed_process = subprocess.run('python --version')
Python 3.6.1 :: Anaconda 4.4.0 (64-bit)
>>> completed_process
CompletedProcess(args='python --version', returncode=0)
run attend que la commande se termine avec succès, puis renvoie un objet CompletedProcess. À la place, il peut lever TimeoutExpired (si vous lui donnez un argument timeout=) ou CalledProcessError (s'il échoue et que vous passez check=True).
Comme vous pouvez le déduire de l'exemple ci-dessus, stdout et stderr sont tous deux redirigés vers votre propre stdout et stderr par défaut.
Nous pouvons inspecter l'objet renvoyé et voir la commande qui a été donnée et le code de retour:
>>> completed_process.args
'python --version'
>>> completed_process.returncode
0
Capture de sortie
Si vous souhaitez capturer la sortie, vous pouvez transmettre subprocess.PIPE à la variable stderr ou stdout appropriée:
>>> cp = subprocess.run('python --version',
stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
>>> cp.stderr
b'Python 3.6.1 :: Anaconda 4.4.0 (64-bit)\r\n'
>>> cp.stdout
b''
(Je trouve intéressant et légèrement contre-intuitif que les informations de version soient placées dans stderr au lieu de stdout.)
Passer une liste de commandes
On peut facilement passer d'une chaîne de commande manuellement (comme le suggère la question) à une chaîne générée par programme. Ne construisez pas de chaînes par programmation. Ceci est un problème de sécurité potentiel. Il est préférable de supposer que vous ne faites pas confiance à l'entrée.
>>> import textwrap
>>> args = ['python', textwrap.__file__]
>>> cp = subprocess.run(args, stdout=subprocess.PIPE)
>>> cp.stdout
b'Hello there.\r\n This is indented.\r\n'
Remarque, seule la variable args doit être transmise positionnellement.
Signature complète
Voici la signature réelle dans la source et comme indiqué par help(run):
def run(*popenargs, input=None, timeout=None, check=False, **kwargs):
Les popenargs et kwargs sont attribués au constructeur Popen. input peut être une chaîne d'octets (ou unicode, si vous spécifiez un codage ou universal_newlines=True) qui sera acheminée vers le stdin du sous-processus.
La documentation décrit timeout= et check=True mieux que moi:
L'argument de délai d'attente est passé à Popen.communicate (). Si le délai d'attente expire, le processus enfant sera tué et attendu. Le L'exception TimeoutExpired sera à nouveau déclenchée une fois que le processus enfant aura résilié.
Si check est vrai et que le processus se termine avec un code de sortie non nul, un L'exception CalledProcessError sera déclenchée. Attributs de cela exception contient les arguments, le code de sortie, stdout et stderr if ils ont été capturés.
et cet exemple pour check=True est meilleur que celui que je pourrais trouver:
>>> subprocess.run("exit 1", Shell=True, check=True) Traceback (most recent call last): ... subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1
Signature élargie
Voici une signature étendue, comme indiqué dans la documentation:
subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, Shell=False, cwd=None, timeout=None, check=False, encoding=None, errors=None)
Notez que cela indique que seule la liste des arguments doit être passée positionnellement. Donc, passez les arguments restants comme arguments de mots clés.
Popen
Quand utiliser Popen à la place? J'aurais du mal à trouver un cas d'utilisation basé uniquement sur les arguments. L'utilisation directe de Popen vous donnerait cependant accès à ses méthodes, notamment poll, 'send_signal', 'terminate' et 'wait'.
Voici la signature Popen donnée dans la source . Je pense qu'il s'agit de l'encapsulation la plus précise de l'information (par opposition à help(Popen)):
def __init__(self, args, bufsize=-1, executable=None,
stdin=None, stdout=None, stderr=None,
preexec_fn=None, close_fds=_PLATFORM_DEFAULT_CLOSE_FDS,
Shell=False, cwd=None, env=None, universal_newlines=False,
startupinfo=None, creationflags=0,
restore_signals=True, start_new_session=False,
pass_fds=(), *, encoding=None, errors=None):
Mais plus informatif est la documentation Popen :
subprocess.Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, Shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=(), *, encoding=None, errors=None)Exécutez un programme enfant dans un nouveau processus. Sur POSIX, la classe utilise comportement semblable à os.execvp () pour exécuter le programme enfant. Sous Windows, la classe utilise la fonction Windows CreateProcess (). Les arguments pour Popen sont comme suit.
Comprendre la documentation restante sur Popen restera comme un exercice pour le lecteur.
Cela peut être aussi simple:
import os
cmd = "your command"
os.system(cmd)
Utilisation:
import os
cmd = 'ls -al'
os.system(cmd)
os - Ce module fournit un moyen portable d'utiliser des fonctionnalités dépendant du système d'exploitation.
Pour les fonctions plus os, ici est la documentation.
subprocess.check_call est pratique si vous ne souhaitez pas tester les valeurs de retour. Il lève une exception sur toute erreur.
J'ai tendance à utiliser sous-processus avec shlex (pour gérer l'échappement des chaînes citées):
>>> import subprocess, shlex
>>> command = 'ls -l "/your/path/with spaces/"'
>>> call_params = shlex.split(command)
>>> print call_params
["ls", "-l", "/your/path/with spaces/"]
>>> subprocess.call(call_params)
os.system ne vous permet pas de stocker les résultats, donc si vous souhaitez stocker les résultats dans une liste ou quelque chose de subprocess.call fonctionne.
Il y a une autre différence ici qui n'est pas mentionnée précédemment.
subprocess.Popen exécute la <commande> en tant que sous-processus. Dans mon cas, je dois exécuter le fichier <a> qui doit communiquer avec un autre programme, <b>.
J'ai essayé le sous-processus, et l'exécution a réussi. Cependant, <b> ne peut pas communiquer avec <a> . Tout est normal lorsque je lance les deux à partir du terminal.
Un de plus: (NOTE: kwrite se comporte différemment des autres applications. Si vous essayez ce qui suit avec Firefox, les résultats ne seront pas les mêmes.)
Si vous essayez os.system("kwrite"), le flux de programme se bloque jusqu'à ce que l'utilisateur ferme kwrite. Pour surmonter cela, j'ai plutôt essayé os.system(konsole -e kwrite). Cette fois, le programme a continué de circuler, mais kwrite est devenu le sous-processus de la console.
N'importe qui exécute kwrite, qui n'est pas un sous-processus (c'est-à-dire qu'il doit apparaître dans le moniteur système à l'extrême gauche de l'arborescence).
J'aime assez Shell_command pour sa simplicité. Il est construit sur le module de sous-processus.
Voici un exemple tiré de la documentation:
>>> from Shell_command import Shell_call
>>> Shell_call("ls *.py")
setup.py Shell_command.py test_Shell_command.py
0
>>> Shell_call("ls -l *.py")
-rw-r--r-- 1 ncoghlan ncoghlan 391 2011-12-11 12:07 setup.py
-rw-r--r-- 1 ncoghlan ncoghlan 7855 2011-12-11 16:16 Shell_command.py
-rwxr-xr-x 1 ncoghlan ncoghlan 8463 2011-12-11 16:17 test_Shell_command.py
0
utiliser le module os
import os
os.system("your command")
par exemple
import os
os.system("ifconfig")
Prise sans vergogne, j'ai écrit une bibliothèque pour cela: P https://github.com/houqp/Shell.py
C'est essentiellement une enveloppe pour popen et shlex pour le moment. Il prend également en charge les commandes de tuyauterie afin que vous puissiez les chaîner plus facilement en Python. Ainsi, vous pouvez faire des choses comme:
ex('echo hello Shell.py') | "awk '{print $2}'"
Sous Linux, si vous souhaitez appeler une commande externe qui s'exécutera indépendamment (continuera à s'exécuter une fois le script python terminé), vous pouvez utiliser une simple file d'attente comme spooler de tâches ou la commande at
Un exemple avec spooler de tâches:
import os
os.system('ts <your-command>')
Remarques sur le spouleur de tâches (ts):
Vous pouvez définir le nombre de processus simultanés à exécuter ("slots") avec:
ts -S <number-of-slots>L'installation de
tsne nécessite pas de privilèges d'administrateur. Vous pouvez le télécharger et le compiler à partir des sources avec une simplemake, l'ajouter à votre chemin et vous avez terminé.
Vous pouvez utiliser Popen, puis vérifier l'état de la procédure:
from subprocess import Popen
proc = Popen(['ls', '-l'])
if proc.poll() is None:
proc.kill()
Découvrez subprocess.Popen .
Sous Windows, vous pouvez simplement importer le module subprocess et exécuter des commandes externes en appelant subprocess.Popen(), subprocess.Popen().communicate() et subprocess.Popen().wait() comme ci-dessous:
# Python script to run a command line
import subprocess
def execute(cmd):
"""
Purpose : To execute a command and return exit status
Argument : cmd - command to execute
Return : exit_code
"""
process = subprocess.Popen(cmd, Shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(result, error) = process.communicate()
rc = process.wait()
if rc != 0:
print "Error: failed to execute command:", cmd
print error
return result
# def
command = "tasklist | grep python"
print "This process detail: \n", execute(command)
Sortie:
This process detail:
python.exe 604 RDP-Tcp#0 4 5,660 K
Le moyen le plus simple d'exécuter n'importe quelle commande et d'obtenir le résultat:
from commands import getstatusoutput
try:
return getstatusoutput("ls -ltr")
except Exception, e:
return None
Pour récupérer l'identifiant réseau du neutron openstack:
#!/usr/bin/python
import os
netid= "nova net-list | awk '/ External / { print $2 }'"
temp=os.popen(netid).read() /* here temp also contains new line (\n) */
networkId=temp.rstrip()
print(networkId)
Sortie de nova net-list
+--------------------------------------+------------+------+
| ID | Label | CIDR |
+--------------------------------------+------------+------+
| 431c9014-5b5d-4b51-a357-66020ffbb123 | test1 | None |
| 27a74fcd-37c0-4789-9414-9531b7e3f126 | External | None |
| 5a2712e9-70dc-4b0e-9281-17e02f4684c9 | management | None |
| 7aa697f5-0e60-4c15-b4cc-9cb659698512 | Internal | None |
+--------------------------------------+------------+------+
Sortie de print (networkId)
27a74fcd-37c0-4789-9414-9531b7e3f126
Voici mes deux cents: À mon avis, c'est la meilleure pratique pour traiter avec des commandes externes ...
Ce sont les valeurs de retour de la méthode execute ...
pass, stdout, stderr = execute(["ls","-la"],"/home/user/desktop")
C'est la méthode execute ...
def execute(cmdArray,workingDir):
stdout = ''
stderr = ''
try:
try:
process = subprocess.Popen(cmdArray,cwd=workingDir, stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=1)
except OSError:
return [False, '', 'ERROR : command(' + ' '.join(cmdArray) + ') could not get executed!']
for line in iter(process.stdout.readline, b''):
try:
echoLine = line.decode("utf-8")
except:
echoLine = str(line)
stdout += echoLine
for line in iter(process.stderr.readline, b''):
try:
echoLine = line.decode("utf-8")
except:
echoLine = str(line)
stderr += echoLine
except (KeyboardInterrupt,SystemExit) as err:
return [False,'',str(err)]
process.stdout.close()
returnCode = process.wait()
if returnCode != 0 or stderr != '':
return [False, stdout, stderr]
else:
return [True, stdout, stderr]
Invoke est un outil et une bibliothèque d'exécution Python (2.7 et 3.4+). Il fournit une API propre et de haut niveau pour l'exécution des commandes Shell
>>> from invoke import run
>>> cmd = "pip install -r requirements.txt"
>>> result = run(cmd, hide=True, warn=True)
>>> print(result.ok)
True
>>> print(result.stdout.splitlines()[-1])
Successfully installed invocations-0.13.0 pep8-1.5.7 spec-1.3.1
Ici, on appelle une commande externe et retourne ou affiche le résultat de la commande:
Python Sous-processus check_output est bon pour
Exécutez la commande avec des arguments et renvoyez sa sortie sous forme de chaîne d'octets.
import subprocess
proc = subprocess.check_output('ipconfig /all')
print proc
Utilisation:
import subprocess
p = subprocess.Popen("df -h", Shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()[0]
print p.split("\n")
Cela donne une sortie Nice avec laquelle il est plus facile de travailler:
['Filesystem Size Used Avail Use% Mounted on',
'/dev/sda6 32G 21G 11G 67% /',
'none 4.0K 0 4.0K 0% /sys/fs/cgroup',
'udev 1.9G 4.0K 1.9G 1% /dev',
'tmpfs 387M 1.4M 386M 1% /run',
'none 5.0M 0 5.0M 0% /run/lock',
'none 1.9G 58M 1.9G 3% /run/shm',
'none 100M 32K 100M 1% /run/user',
'/dev/sda5 340G 222G 100G 69% /home',
'']
Pour ajouter à la discussion, si vous incluez une console Python, vous pouvez appeler des commandes externes depuis IPython . Dans l'invite IPython, vous pouvez appeler des commandes Shell en ajoutant le préfixe "!". Vous pouvez également combiner le code Python avec le shell et affecter la sortie des scripts du shell aux variables Python.
Par exemple:
In [9]: mylist = !ls
In [10]: mylist
Out[10]:
['file1',
'file2',
'file3',]
Appeler une commande externe en Python
Un moyen simple d'appeler une commande externe consiste à utiliser os.system(...). Et cette fonction renvoie la valeur de sortie de la commande. Mais l'inconvénient est que nous n'aurons ni stdout, ni stdout.
ret = os.system('some_cmd.sh')
if ret != 0 :
print 'some_cmd.sh execution returned failure'
Appeler une commande externe en Python en arrière-plan
subprocess.Popen offre plus de flexibilité pour exécuter une commande externe plutôt que d'utiliser os.system. Nous pouvons lancer une commande en arrière-plan et attendre qu'elle se termine. Et après cela, nous pouvons obtenir le stdout et stderr.
proc = subprocess.Popen(["./some_cmd.sh"], stdout=subprocess.PIPE)
print 'waiting for ' + str(proc.pid)
proc.wait()
print 'some_cmd.sh execution finished'
(out, err) = proc.communicate()
print 'some_cmd.sh output : ' + out
Appel d'une commande externe longue durée en Python en arrière-plan et arrêt après un certain temps
Nous pouvons même démarrer un long processus en arrière-plan en utilisant subprocess.Popen et le tuer après un certain temps, une fois que sa tâche est terminée.
proc = subprocess.Popen(["./some_long_run_cmd.sh"], stdout=subprocess.PIPE)
# Do something else
# Now some_long_run_cmd.sh exeuction is no longer needed, so kill it
os.system('kill -15 ' + str(proc.pid))
print 'Output : ' proc.communicate()[0]
Il existe de nombreuses façons d’exécuter des commandes externes en Python, Toutes ont leurs inconvénients et leurs inconvénients.
Mes collègues et moi écrivons des outils d'administration système Python. Nous devons donc exécuter de nombreuses commandes externes. Parfois, vous souhaitez qu'elles bloquent ou s'exécutent de manière asynchrone, que le délai d'expiration, la mise à jour toutes les secondes, etc.
Il existe également différentes manières de gérer le code de retour et les erreurs, .__ et vous pouvez analyser la sortie et fournir une nouvelle entrée (dans un style expect .). Ou vous devrez rediriger stdin, stdout et stderr pour s'exécuter dans un tty différent (par exemple, lorsque vous utilisez screen).
Donc, vous devrez probablement écrire beaucoup de wrappers autour de la commande externe. Voici donc un module Python que nous avons écrit et qui peut gérer presque tout ce que vous voulez, et sinon, il est très flexible, vous pouvez donc facilement l’étendre:
https://github.com/hpcugent/vsc-base/blob/master/lib/vsc/utils/run.py
Par exemple (sous Linux):
import subprocess
subprocess.run('mkdir test.dir', Shell=True)
Cela crée test.dir dans le répertoire en cours ..__ Notez que cela fonctionne également:
import subprocess
subprocess.call('mkdir test.dir', Shell=True)
Le code équivalent utilisant os.system est:
import os
os.system('mkdir test.dir')
La meilleure pratique consisterait à utiliser un sous-processus au lieu de os, avec .run privilégié par rapport à .call. Tout ce que vous devez savoir sur le sous-processus est ici . Notez également que toute la documentation Python est disponible au téléchargement depuis ici . J'ai téléchargé le PDF dans le format .Zip. Je le mentionne car il existe un bon aperçu du module os dans tutorial.pdf (page 81). En outre, c'est une ressource faisant autorité pour les codeurs Python.
Pour Python 3.5+, il est recommandé d'utiliser la fonction run du module de sous-processus . Cela renvoie un objet CompletedProcess, à partir duquel vous pouvez facilement obtenir le résultat ainsi que le code de retour.
from subprocess import PIPE, run
command = ['echo', 'hello']
result = run(command, stdout=PIPE, stderr=PIPE, universal_newlines=True)
print(result.returncode, result.stdout, result.stderr)
J'utilise souvent la fonction suivante pour les commandes externes, ce qui est particulièrement utile pour processus longs . La méthode ci-dessous tails traite le résultat while il est en cours d'exécution et renvoie le résultat, déclenche une exception si le processus échoue.
Il s'avère que le processus est effectué à l'aide de la méthode poll () sur le processus .
import subprocess,sys
def exec_long_running_proc(command, args):
cmd = "{} {}".format(command, " ".join(str(arg) if ' ' not in arg else arg.replace(' ','\ ') for arg in args))
print(cmd)
process = subprocess.Popen(cmd, Shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
# Poll process for new output until finished
while True:
nextline = process.stdout.readline().decode('UTF-8')
if nextline == '' and process.poll() is not None:
break
sys.stdout.write(nextline)
sys.stdout.flush()
output = process.communicate()[0]
exitCode = process.returncode
if (exitCode == 0):
return output
else:
raise Exception(command, exitCode, output)
Vous pouvez l'invoquer comme ceci:
exec_long_running_proc(command = "Hive", args=["-f", hql_path])
Un moyen simple consiste à utiliser le module os:
import os
os.system('ls')
Sinon, vous pouvez également utiliser le module de sous-processus
import subprocess
subprocess.check_call('ls')
Si vous voulez que le résultat soit stocké dans une variable, essayez:
import subprocess
r = subprocess.check_output('ls')
Utilisez subprocess.call :
from subprocess import call
# using list
call(["echo", "Hello", "world"])
# single string argument varies across platforms so better split it
call("echo Hello world".split(" "))
L'utilisation de la fonction Popen du module subprocess Python est le moyen le plus simple d'exécuter des commandes Linux. En cela, la fonction Popen.communicate() donnera la sortie de vos commandes. Par exemple
import subprocess
..
process = subprocess.Popen(..) # Pass command and arguments to the function
stdout, stderr = process.communicate() # Get command output and error
..
Si vous devez appeler une commande Shell depuis un bloc-notes Python (comme Jupyter , Zeppelin, Databricks ou Google Cloud Datalab), vous pouvez simplement utiliser le préfixe !.
Par exemple,
!ls -ilF
J'ai écrit une petite bibliothèque pour aider avec ce cas d'utilisation:
https://pypi.org/project/citizenshell/
Il peut être installé en utilisant
pip install citizenshell
Et ensuite utilisé comme suit:
from citizenshell import sh
assert sh("echo Hello World") == "Hello World"
Vous pouvez séparer stdout de stderr et extraire le code de sortie comme suit:
result = sh(">&2 echo error && echo output && exit 13")
assert result.stdout() == ["output"]
assert result.stderr() == ["error"]
assert result.exit_code() == 13
Et le plus intéressant est que vous n'avez pas à attendre la sortie du shell sous-jacent avant de commencer à traiter la sortie:
for line in sh("for i in 1 2 3 4; do echo -n 'It is '; date +%H:%M:%S; sleep 1; done", wait=False)
print ">>>", line + "!"
imprimera les lignes telles qu'elles sont disponibles grâce à l'attente = False
>>> It is 14:24:52!
>>> It is 14:24:53!
>>> It is 14:24:54!
>>> It is 14:24:55!
Plus d'exemples peuvent être trouvés à https://github.com/meuter/citizenshell
Il existe deux manières principales d'exécuter des commandes Shell à l'aide de Python. Les deux exemples mentionnés ci-dessous montrent comment on peut obtenir le nom du répertoire de travail actuel (pwd) en utilisant Python. Vous pouvez utiliser toute autre commande Unix à la place de pwd.
1.> 1ère méthode: On peut utiliser les modules os de python et system () à partir de là pour exécuter des commandes Shell en Python.
import os
os.system('pwd')
Sortie:
/Users/siddharth
1.> 2ème méthode: Une autre méthode consiste à utiliser les fonctions subprocess module et call () .
import subprocess
subprocess.call('pwd')
Sortie:
/Users/siddharth
Je recommanderais la méthode suivante 'run' et elle nous aidera à obtenir STDOUT, STDERR et le statut de sortie en tant que dictionnaire; L'appelant de celui-ci peut lire le retour de dictionnaire par la méthode 'run' pour connaître l'état actuel du processus.
def run (cmd):
print "+ DEBUG exec({0})".format(cmd)
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, Shell=True)
(out, err) = p.communicate()
ret = p.wait()
out = filter(None, out.split('\n'))
err = filter(None, err.split('\n'))
ret = True if ret == 0 else False
return dict({'output': out, 'error': err, 'status': ret})
#end
Après quelques recherches, j'ai le code suivant qui fonctionne très bien pour moi. Il imprime essentiellement stdout et stderr en temps réel. J'espère que ça aide quelqu'un d'autre qui en a besoin.
stdout_result = 1
stderr_result = 1
def stdout_thread(pipe):
global stdout_result
while True:
out = pipe.stdout.read(1)
stdout_result = pipe.poll()
if out == '' and stdout_result is not None:
break
if out != '':
sys.stdout.write(out)
sys.stdout.flush()
def stderr_thread(pipe):
global stderr_result
while True:
err = pipe.stderr.read(1)
stderr_result = pipe.poll()
if err == '' and stderr_result is not None:
break
if err != '':
sys.stdout.write(err)
sys.stdout.flush()
def exec_command(command, cwd=None):
if cwd is not None:
print '[' + ' '.join(command) + '] in ' + cwd
else:
print '[' + ' '.join(command) + ']'
p = subprocess.Popen(
command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd
)
out_thread = threading.Thread(name='stdout_thread', target=stdout_thread, args=(p,))
err_thread = threading.Thread(name='stderr_thread', target=stderr_thread, args=(p,))
err_thread.start()
out_thread.start()
out_thread.join()
err_thread.join()
return stdout_result + stderr_result
Sultan est un paquet récent destiné à cette fin. Fournit quelques détails sur la gestion des privilèges utilisateur et l’ajout de messages d’erreur utiles.
from sultan.api import Sultan
with Sultan.load(Sudo=True, hostname="myserver.com") as sultan:
sultan.yum("install -y tree").run()
J'ai écrit un wrapper pour gérer les erreurs et rediriger la sortie, entre autres.
import shlex
import psutil
import subprocess
def call_cmd(cmd, stdout=sys.stdout, quiet=False, Shell=False, raise_exceptions=True, use_shlex=True, timeout=None):
"""Exec command by command line like 'ln -ls "/var/log"'
"""
if not quiet:
print("Run %s", str(cmd))
if use_shlex and isinstance(cmd, (str, unicode)):
cmd = shlex.split(cmd)
if timeout is None:
process = subprocess.Popen(cmd, stdout=stdout, stderr=sys.stderr, Shell=shell)
retcode = process.wait()
else:
process = subprocess.Popen(cmd, stdout=stdout, stderr=sys.stderr, Shell=shell)
p = psutil.Process(process.pid)
finish, alive = psutil.wait_procs([p], timeout)
if len(alive) > 0:
ps = p.children()
ps.insert(0, p)
print('waiting for timeout again due to child process check')
finish, alive = psutil.wait_procs(ps, 0)
if len(alive) > 0:
print('process {} will be killed'.format([p.pid for p in alive]))
for p in alive:
p.kill()
if raise_exceptions:
print('External program timeout at {} {}'.format(timeout, cmd))
raise CalledProcessTimeout(1, cmd)
retcode = process.wait()
if retcode and raise_exceptions:
print("External program failed %s", str(cmd))
raise subprocess.CalledProcessError(retcode, cmd)
Vous pouvez l'appeler comme ça:
cmd = 'ln -ls "/var/log"'
stdout = 'out.txt'
call_cmd(cmd, stdout)
Le module subprocess décrit ci-dessus par Eli est très puissant, mais la syntaxe pour effectuer un appel système standard et inspecter sa sortie est inutilement prolixe.
Le moyen le plus simple de faire un appel système consiste à utiliser le module controls (Linux uniquement).
> import commands
> commands.getstatusoutput("grep matter alice-in-wonderland.txt")
(0, "'Then it doesn't matter which way you go,' said the Cat.")
Le premier élément du tuple est le code de retour du processus. Le deuxième élément est sa sortie standard (et erreur standard, fusionnée).
Les développeurs Python ont "déconseillé" le module de commandes, mais cela ne signifie pas que vous ne devriez pas l'utiliser. Seulement, ils ne le développent plus, ce qui est bien, car il est déjà parfait (à sa petite mais importante fonction).
Comme certaines des réponses étaient liées aux versions précédentes de python ou utilisaient le module os.system, je publie cette réponse pour les personnes comme moi qui ont l'intention d'utiliser subprocess dans python 3.5+. Ce qui suit a fait le tour pour moi sur Linux:
import subprocess
#subprocess.run() returns a completed process object that can be inspected
c = subprocess.run(["ls", "-ltrh"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
print(c.stdout.decode('utf-8'))
Comme indiqué dans la documentation , PIPE, les valeurs sont des séquences d'octets et, pour les montrer correctement, le décodage doit être pris en compte. Pour les versions ultérieures de python, text=True et encoding='utf-8' sont ajoutés aux kwargs de subprocess.run() .
La sortie du code susmentionné est:
total 113M
-rwxr-xr-x 1 farzad farzad 307 Jan 15 2018 vpnscript
-rwxrwxr-x 1 farzad farzad 204 Jan 15 2018 ex
drwxrwxr-x 4 farzad farzad 4.0K Jan 22 2018 scripts
.... # some other lines
Vous pouvez également utiliser subprocess.getoutput() et subprocess.getstatusutput(), qui sont fonctions d'invocation de shell héritées à partir du module obsolète commands, c'est-à-dire :
subprocess.getstatusoutput(cmd)Retourne (
exitcode,output) de l'exécution decmddans un shell.
subprocess.getoutput(cmd)Renvoie la sortie (
stdoutetstderr) de l'exécution decmddans un shell.
Vous pouvez utiliser import puis le nom du fichier. Par exemple, en utilisant le module incorporé 'random': import random
Si vous utilisezPASen utilisant une entrée utilisateur dans les commandes, vous pouvez utiliser ceci.
from os import getcwd
from subprocess import check_output
from shlex import quote
def sh(command):
return check_output(quote(command), Shell=True, cwd=getcwd(), universal_newlines=True).strip()
Et l'utiliser comme
branch = sh('git rev-parse --abbrev-ref HEAD')
Shell=True va engendrer un shell, vous pouvez donc utiliser un tuyau et d'autres choses de ce type sh('ps aux | grep python'). C’est très pratique pour exécuter des commandes codées en dur et en traiter la sortie. Le universal_lines=True s'assure que la sortie est renvoyée dans une chaîne au lieu de binaire.
cwd=getcwd() s'assurera que la commande est exécutée avec le même répertoire de travail que l'interpréteur. C'est très pratique pour que les commandes git fonctionnent comme dans l'exemple de nom de branche git ci-dessus.
Quelques recettes
- mémoire libre en mégaoctets:
sh('free -m').split('\n')[1].split()[1] - espace libre sur/en pourcentage
sh('df -m /').split('\n')[1].split()[4][0:-1] - charge du processeur
sum(map(float, sh('ps -ef -o pcpu').split('\n')[1:])
Mais ce n'est pas sûr pour l'entrée de l'utilisateur, à partir de la documentation:
Considérations de sécurité¶
Contrairement à d'autres fonctions popen, cette implémentation n'appellera jamais implicitement un shell système. Cela signifie que tous les caractères, y compris les métacaractères Shell, peuvent être transmis en toute sécurité aux processus enfants. Si le shell est appelé explicitement, via Shell = True, il incombe à l’application de s’assurer que tous les espaces et métacaractères sont cités correctement pour éviter les vulnérabilités d’injection du shell.
Lorsque vous utilisez Shell = True, la fonction shlex.quote () peut être utilisée pour échapper correctement les espaces et les métacaractères Shell dans des chaînes devant être utilisées pour construire des commandes Shell.
Même en utilisant shlex.quote(), il est bon de garder un peu de paranoïa lorsque vous utilisez les entrées utilisateur pour les commandes Shell. Une option consiste à utiliser une commande hardcode pour extraire une sortie générique et un filtrage par entrée utilisateur. Quoi qu'il en soit, l'utilisation de Shell=False s'assurera que seul le processus exact que vous souhaitez exécuter sera exécuté ou que vous obtiendrez une erreur No such file or directory.
De plus, il y a un impact sur les performances de Shell=True; d'après mes tests, il semble être environ 20% plus lent que Shell=False (valeur par défaut).
In [50]: timeit("check_output('ls -l'.split(), universal_newlines=True)", number=1000, globals=globals())
Out[50]: 2.6801227919995654
In [51]: timeit("check_output('ls -l', universal_newlines=True, Shell=True)", number=1000, globals=globals())
Out[51]: 3.243950183999914
Si vous écrivez un script shell Python et que vous avez IPython installé sur votre système, vous pouvez utiliser la magie exceptionnelle pour exécuter une commande dans IPython:
!ls
filelist = !ls