Appel d'une commande externe à partir de Python

subprocess.check_call est pratique si vous ne souhaitez pas tester les valeurs de retour. Il lève une exception sur toute erreur.

Cela peut être aussi simple:

import os
cmd = "your command"
os.system(cmd)

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)

Production:

This process detail:
python.exe                     604 RDP-Tcp#0                  4      5,660 K

Voici comment j'exécute mes commandes. Ce code a à peu près 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()

Vérifiez également la bibliothèque Python "pexpect".

Il permet un contrôle interactif des 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')

import os
os.system("your command")

Notez que cela est dangereux, car la commande n'est pas nettoyée. Je vous laisse le soin de google pour la documentation pertinente sur les modules 'os' et 'sys'. Il existe un tas de fonctions (exec * et spawn *) qui feront des choses similaires.

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 stdout dans le canal. En fait, vous pouvez simplement omettre ces paramètres (stdout= et stderr=) et cela se comportera comme os.system().

Utilisez le sous-processus .

... ou pour une commande très simple:

import os
os.system('cat testfile')

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, un subprocess.call fonctionne.

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")