Les arguments de la ligne de commande en Python

Après avoir vu ce que sont les arguments de la ligne de commande, il est temps de comprendre ce que le shell fait de cette ligne. Et surtout, qu'est-ce qui est passé au programme final.

C'est alors que nous pourrons voir comment interpréter ces éléments.

Le trajet d'une commande

Lorsque vous exécutez une commande comme :

ls -la /Pictures

Il va y avoir plusieurs étapes successives impliquant plusieurs acteurs :

Le shell (le terminal) reçoit d'abord cette ligne de texte et va la découper en se servant des espaces comme séparateurs. C'est l'étape de tokenization et cette commande devient ainsi une liste de mots (des chaines de caractères) : ls, -la, /Pictures. Le terminal utilisera toujours les espaces comme séparateurs ce qui explique pourquoi on les évite dans les noms des fichiers ou répertoires.
Toujours le shell va regarder le premier mot et retrouver l'exécutable correspondant et passer l'ensemble au système d'exploitation.
Le système d'exploitation prend donc le relais. Il démarre le programme et lui transmet l'ensemble des éléments, y compris le nom du programme lui-même.
Le programme démarre à son tour et reçoit la liste complète créée par le shell.

Gestion des arguments par Python

Dans le cas d'un programme Python lancé avec l'interpréteur, il y a une subtilité. L'interpréteur est lancé avec en argument le nom du script à interpréter. Disons :

python -m clean_raws /pictures/work -v

Python va recevoir la liste des 5 chaines de caractères. Les arguments avant -m (compris) sont des arguments pour Python. Il va donc séparer cette liste en deux.

En interprétant clean_raws, Python va créer la liste sys.argv et lui passer les éléments suivant le -m, c'est à dire dans notre cas les 3 derniers éléments.

Ainsi, si le programme contient le code suivant et qu'il est dans l'arborescence /Users/taverne/work/, vous obtiendrez l'affichage en commentaire :

import sys

print(sys.argv)

# ['/Users/taverne/work/clean_raws.py', '/pictures/work', '-v']

Attention : vous obtenez une liste de chaines de caractères. Si vous passez des données comme des nombres, il faudra les transtyper vers le type attendu.

Récupérer les éléments

Nous avons donc la liste de tous les éléments de la ligne de commande. Le premier est le script invoqué et les suivants les arguments en eux même.

Nous pouvons donc les récupérer de la manière suivante :

script = sys.argv[0]
args = sys.argv[1:]

Nous pouvons parcourir les arguments et, en théorie, les gérer. En théorie, car si obtenir la liste est facile, interpréter correctement les éléments l'est beaucoup moins. Entre les arguments positionnels, les optionnels qui attendent un paramètre, ceux qui se comportent en flag, le fait qu'aucun ordre n'est garanti et que certains paramètres devront être transtypés, la gestion manuelle va être assez laborieuse.

Bien évidemment, il existe plusieurs outils inclus dans la bibliothèque standard qui vont nous faciliter la vie :

Le parser porté du C, getopt est l'outil historique qui fait parti de Python avant même sa version 1.0. Il reproduit l'approche procédurale du C.
La version modernisée, optparse plus déclarative, ajoutée avec Python 2.3.
Enfin, argparse qui a été ajouté en Python 2.7 et 3.2 qui offre plus de fonctionnalités et de contrôle au prix d'une perte de flexibilité (mais qui convient dans la majorité des cas).

L'explication de ces parsers mérite évidemment des tutos dédiés.

N'oublions pas le premier élément

Les différents parsers permettent d'interpréter les arguments de la ligne de commande, c'est à dire ceux à partir du second élément de la liste sys.argv. Le premier élément, l'exécutable, peut être intéressant à vérifier.

En théorie, ce n'est pas la peine, c'est évident que le fichier exécuté est, dans notre exemple, clean_raws.py. (avec toute l’arborescence que je vais omettre pour une question de lisibilité). Oui mais il y a plusieurs situation où ce ne sera pas le cas.

En premier lieu, si vous créez un lien symbolique avec ln -s sous Linux ou mklink sous Windows et créez le lien clean.py qui pointe sur le fichier clean_raws.py, vous aurez deux noms pour exécuter votre programme Python. Et c'est bien le nom utilisé lors de l'appel qui sera le premier élément de la liste.

En second lieu, si vous faites du packaging, vous pouvez créer des lanceurs via la section [project.scripts] du pyproject.toml. Et vous pouvez en créer plusieurs qui pointent vers le même script d'entrée.

Et à quoi ça peut servir ? Simplement à avoir le même programme pour plusieurs commandes. Sur Alpine Linux par exemple, cp et mv sont des liens symboliques vers BusyBox qui fera des choses différentes en fonction du nom invoqué. Vous pouvez donc imaginer un comportement similaire.

En résumé

Lorsque vous lancez un programme en ligne de commande et que vous lui passez des arguments, le shell puis le système d'exploitation lu envoient le contenu de cette ligne de commande sous forme d'une liste d'éléments.

Dans le cas de Python, cette liste est accessible dans la variable sys.argv. Vous pouvez la consulter mais l'interprétation va être laborieuse. C'est ce qui nous amènera aux parsers dédiés dont argparse.