de sortie de la ligne de commande appelé par le sous-processus?

Cela dépend de la version de Python que vous utilisez. En Python3.3, l'arg est enregistré dans proc.args:

proc = subprocess.Popen(....)
print("the commandline is {}".format(proc.args))

En Python2.7, le args ne sont pas enregistrées, il est juste passé à d'autres fonctions comme le _execute_child. Alors, dans ce cas, la meilleure façon d'obtenir la ligne de commande est à enregistrer lorsque vous avez:

proc = subprocess.Popen(shlex.split(cmd))
print "the commandline is %s" % cmd

---

Notez que si vous avez la liste des arguments (comme le type de chose retourné par shlex.split(cmd), alors vous pouvez récupérer la chaîne de ligne de commande, cmd sans-papiers à l'aide de la fonction subprocess.list2cmdline:

In [14]: import subprocess

In [15]: import shlex

In [16]: cmd = 'foo -a -b --bar baz'

In [17]: shlex.split(cmd)
Out[17]: ['foo', '-a', '-b', '--bar', 'baz']

In [18]: subprocess.list2cmdline(['foo', '-a', '-b', '--bar', 'baz'])
Out[19]: 'foo -a -b --bar baz'

Belle et méthode évolutive

J'ai été en utilisant quelque chose comme ceci:

#!/usr/bin/env python3

import os
import shlex
import subprocess
import sys

def run_cmd(cmd, cwd=None, extra_env=None, extra_paths=None, dry_run=False):
    if extra_env is None:
        extra_env = {}
    newline_separator = ' \\\n'
    out = []
    kwargs = {}
    env = os.environ.copy()

    # cwd
    if 'cwd' is not None:
        kwargs['cwd'] = cwd

    # extra_env
    env.update(extra_env)
    for key in extra_env:
        out.append('{}={}'.format(shlex.quote(key), shlex.quote(extra_env[key])) + newline_separator)

    # extra_paths
    if extra_paths is not None:
        path = ':'.join(extra_paths)
        if 'PATH' in env:
            path += ':' + env['PATH']
        env['PATH'] = path
        out.append('PATH="{}:${{PATH}}"'.format(':'.join(extra_paths)) + newline_separator)

    # Command itself.
    for arg in cmd:
        out.append(shlex.quote(arg) + newline_separator)

    # Print and run.
    kwargs['env'] = env
    print('+ ' + '  '.join(out) + ';')
    if not dry_run:
        subprocess.check_call(cmd, **kwargs)

run_cmd(
    sys.argv[1:],
    cwd='/bin',
    extra_env={'ASDF': 'QW ER'},
    extra_paths=['/some/path1', '/some/path2']
)

Exemple d'exécution:

./a.py echo 'a b' 'c d' 

De sortie:

+ ASDF='QW ER' \
  PATH="/some/path1:/some/path2:${PATH}" \
  echo \
  'a b' \
  'c d' \
;
a b c d

Résumé des caractéristiques:

• fait d'énormes lignes de commande lisible avec une option par ligne
• ajouter un + à des commandes comme sh -x de sorte que les utilisateurs peuvent se différencier des commandes depuis leur sortie facilement
• montrer cd, et des variables d'environnement supplémentaires s'ils sont donnés à la commande. Ces imprimés que si elle est donnée, en ayant un minimum de commande shell.

Tout cela permet aux utilisateurs de facilement copier les commandes manuellement afin de les exécuter si quelque chose tombe en panne, ou pour voir ce qui se passe.

Testé sur Python 3.5.2, Ubuntu 16.04. GitHub en amont.