shell example - Appeler une commande externe en Python




os.system executer (25)

Voici un résumé des moyens d’appeler des programmes externes et des avantages et inconvénients de chacun:

  1. os.system("some_command with args") transmet la commande et les arguments au shell de votre système. Cela est pratique car 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 .

  2. stream = os.popen("some_command with args") fera la même chose que os.system sauf qu'il vous donne 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 .

  3. La classe Popen du module de subprocess - subprocess . Ceci est destiné à remplacer os.popen mais présente l’inconvénient d’être un peu plus compliqué du fait qu’il est aussi complet. 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 dans une classe unifiée au lieu de 4 fonctions popen différentes. Voir la documentation .

  4. La fonction d' call du module de subprocess - subprocess . Cela ressemble fondamentalement à la classe Popen et 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 .

  5. 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 objet CompletedProcess à la fin de l’exécution de la commande.

  6. Le module os a é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 de subprocess devrait probablement être ce que vous utilisez.

Enfin, sachez que pour toutes les méthodes dans lesquelles vous passez la commande finale à exécuter par le shell en tant que chaîne, vous êtes responsable de son échappement. Il y a de graves implications en matière de sécurité si une partie de la chaîne que vous passez 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 maman ne m'a pas aimé && rm -rf /".

Comment appeler une commande externe (comme si je l'avais saisie à l'invite de commande Unix ou Windows) à partir d'un script Python?


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


os.systemne vous permet pas de stocker des résultats, donc si vous souhaitez stocker des résultats dans une liste ou quelque chose subprocess.callfonctionne.


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

Regardez le module de sous - processus dans la bibliothèque standard:

from subprocess import call
call(["ls", "-l"])

L'avantage du sous - processus par rapport au système est qu'il est plus flexible (vous pouvez obtenir le stdout, le stderr, le code "réel", une meilleure gestion des erreurs, etc.).

La documentation officielle recommande le module de sous - processus plutôt que l'option os.system ():

Le module de sous-processus offre des fonctionnalités plus puissantes pour générer de nouveaux processus et extraire leurs résultats. L'utilisation de ce module est préférable à l'utilisation de cette fonction [ os.system() ].

La section " Remplacement de fonctions plus anciennes avec le module de sous-processus " de la documentation de sous - processus peut contenir des recettes utiles.

Documentation officielle sur le module de sous - processus :


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 Linux, si vous souhaitez appeler une commande externe qui s'exécutera indépendamment (continuera à s'exécuter après la fin du script python), vous pouvez utiliser une simple file d'attente comme spooler de tâches ou la commande at

Un exemple avec le spouleur de tâches:

#!/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)

Remarques sur le spooler de tâches ( ts):

  1. Vous pouvez définir le nombre de processus simultanés à exécuter ("slots") avec:

    ts -S <number-of-slots>

  2. L'installation tsne nécessite pas de privilèges d'administrateur. Vous pouvez le télécharger et le compiler à partir des sources en un simple make, l'ajouter à votre chemin et vous avez terminé.


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:

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

plombier

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 le shell.

ls_cmd = plumbum.local("ls -l") # get command
ls_cmd() # run command

attendre

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 de subprocess - subprocess .

r = envoy.run("ls -l") # Run command
r.std_out # get output

commandes

os.popen commands contient des fonctions d' os.popen pour os.popen , mais elle a été supprimée de Python 3 car le subprocess - subprocess constitue une meilleure alternative.

Le montage était basé sur le commentaire de JF Sebastian.


J'aime bien 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

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

import os
cmd = 'ls -al'
os.system(cmd)

Si vous souhaitez 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 de sous - processus , ce que d'autres réponses ont bien couvert.


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 la question pour savoir comment .)

Voici quelques exemples tirés de la documentation .

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 https://github.com/kennethreitz/envoy . C'est un wrapper pour le sous-processus, qui à son tour vise à remplacer les anciens modules et fonctions. Envoy est un sous-processus pour les humains.

Exemple d'utilisation du 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'>]

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.


J'utilise toujours des 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)

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 «un peu plus de code ici» de l’exemple.

Ma plate-forme cible était FreeBSD, mais le développement se faisait sous Windows. J'ai donc d'abord rencontré le 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 à passer l'indicateur de création de processus DETACHED_PROCESS à la fonction CreateProcess sous-jacente dans Win API. Si vous avez installé pywin32, vous pouvez importer l'indicateur 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 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 je 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.


Avec bibliothèque standard

Le module de sous-processus Use (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.

Remarque sur la version Python: Si vous utilisez toujours Python 2, subprocess.call fonctionne de manière similaire.

ProTip: docs.python.org/2/library/shlex.html#shlex.split peut vous aider à analyser la commande pour run , call et autres fonctions de subprocess au cas où vous ne voudriez pas (ou que vous ne puissiez 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 de subprocess . Il est multi-plateforme, c’est-à-dire qu’il fonctionne à la fois sous Windows et sous Unix. Installer par pip install plumbum .

Une autre bibliothèque populaire est sh :

from sh import ifconfig
print(ifconfig('wlan0'))

Cependant, sh abandonné le support Windows, ce qui fait qu'il n'est plus aussi génial qu'auparavant. Installer par pip install sh .


Je recommanderais d'utiliser le module subprocess au lieu de os.system car il génère un échappement de shell pour vous et est donc beaucoup plus sûr: http://docs.python.org/library/subprocess.html

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

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


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

Cela peut être aussi simple:

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

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> n'a pas pu 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 essayé à la place 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).



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 il fonctionne 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 correctement, puis renvoie un objet CompletedProcess . Au lieu de cela, il peut augmenter TimeoutExpired (si vous lui donnez un timeout= argument) ou CalledProcessError (s'il échoue et que vous transmettez check=True ).

Comme vous pouvez le déduire de l'exemple ci-dessus, stdout et stderr sont 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 le subprocess.PIPE à la commande 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. C'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'

Notez que seuls les args doivent être passés 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 les kwargs sont donnés au constructeur Popen . input peut être une chaîne d'octets (ou unicode, si vous spécifiez encoding ou universal_newlines=True ) qui sera acheminée vers le stdin du sous-processus.

La documentation décrit timeout= et check=True mieux que je pourrais:

L'argument de délai d'attente est passé à Popen.communicate (). Si le délai expire, le processus enfant sera tué et attendu. L'exception TimeoutExpired sera à nouveau déclenchée une fois le processus enfant terminé.

Si check est vrai et que le processus se termine avec un code de sortie différent de zéro, une exception CalledProcessError sera déclenchée. Les attributs de cette exception contiennent les arguments, le code de sortie, ainsi que stdout et stderr s'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 place? Je m'efforcerais de trouver un cas d'utilisation basé uniquement sur les arguments. Cependant, l'utilisation directe de Popen vous donnerait accès à ses méthodes, y compris poll , 'send_signal', 'terminate' et 'wait'.

Voici la signature Popen telle qu'elle est donnée dans la source . Je pense que ceci est 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 la documentation de Popen est plus informative:

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écuter un programme enfant dans un nouveau processus. Sur POSIX, la classe utilise un comportement semblable à os.execvp () pour exécuter le programme enfant. Sous Windows, la classe utilise la fonction Windows CreateProcess (). Les arguments de Popen sont les suivants.

Comprendre la documentation restante sur Popen restera comme un exercice pour le lecteur.


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 a la valeur 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 et que vous souhaitez tout de même accéder facilement à d'autres fonctionnalités du interpréteur de commandes, telles que les pipes shell, les jokers de nom de fichier, le développement de variables d'environnement et l'extension de ~ vers le domicile de l'utilisateur. annuaire. Cependant, notez que Python lui-même offre des implémentations de nombreuses fonctionnalités similaires à celles du shell (notamment glob , fnmatch , os.walk() , os.path.expandvars() , os.path.expanduser() et shutil ).


si variable est définie et que vous voulez vérifier si elle a une valeur, vous pouvez simplement a or b

def test(myvar=None):
    # shorter than: print myvar if myvar else "no Input"
    print myvar or "no Input"

test()
test([])
test(False)
test('hello')
test(['Hello'])
test(True)

va sortir

no Input
no Input
no Input
hello
['Hello']
True




python shell command subprocess external