Analyse des arguments en Python

Si vous prévoyez un projet de data science ou de machine learning, il est courant de démarrer le développement dans un Jupyter Notebook. Vous bénéficiez d’outils interactifs, exécutez vos modules rapidement, etc. Les arguments ne manquent pas pour faire de Jupyter Notebook votre environnement de prédilection, notamment en data science et en machine learning. Toutefois, ce tutoriel ne porte pas sur cet aspect.

Imaginons que vous deviez exécuter un script Python en tâche planifiée pour ingérer des données dans votre projet de data science. Ou que vous ayez besoin de lancer un script Python pour déployer un modèle de machine learning sur un serveur distant. Dans ce type de scénarios, un simple python your_script.py peut ne pas suffire. Vous devrez peut-être transmettre des options ou des arguments supplémentaires avec python your_script.py. Vous connaissez sans doute déjà l’usage d’arguments additionnels lorsque vous exécutez des commandes (comme ps, ls, etc.) dans un terminal Linux.

Dans ce tutoriel, vous allez apprendre à analyser des arguments et options supplémentaires fournis en ligne de commande avec un script Python. Voici le programme du jour :

• Introduction aux principes de l’analyse d’arguments
• Analyse d’arguments en Python
  • Avec sys.argv
  • Avec getopt
  • Avec argparse

Remarque : ce tutoriel suppose une familiarité de base avec Python.

Qu’est-ce que l’analyse d’arguments ?

Si vous utilisez Linux, vous voyez sans doute très bien de quoi il s’agit. Pour obtenir le récapitulatif des fichiers et dossiers présents dans un répertoire, on emploie souvent la commande ls. Une sortie typique de ls ressemble à :

Cependant, vous pouvez fournir de nombreuses options à la commande ls, par exemple -l. Voyons à quoi ressemble la sortie :

En passant l’option -l, vous obtenez davantage d’informations. Il existe une légère différence entre une option et un argument dans ce contexte. Pour supprimer un fichier ou un dossier de votre répertoire de travail courant, on utilise souvent la commande rm. Supposons que vous ayez un fichier texte nommé demo.txt et que vous exécutiez rm demo.txt pour le supprimer. Dans ce cas, demo.txt est l’argument que vous transmettez à la commande rm. Si vous n’indiquez aucun argument à rm, vous obtiendrez une erreur comme ceci :

Alors, quelle est la différence entre une option et un argument ? Elle saute désormais aux yeux. Les options sont facultatives, tandis que les arguments sont (souvent) nécessaires. Il n’est pas indispensable de passer quoi que ce soit à ls pour obtenir une sortie.

Lorsque vous tapez ls -l ou rm demo.txt, le système d’exploitation analyse la commande selon un mécanisme interne. Ce mécanisme, généralement défini par les développeurs du système, s’appelle l’analyse (parsing).

Si vous souhaitez en savoir plus sur les commandes Linux ainsi que les différentes options et arguments qu’elles acceptent, nous vous recommandons vivement le livre Unix Concepts and Applications.

Voilà pour l’introduction. Presque tous les langages de programmation proposent des fonctionnalités d’analyse d’arguments. Python ne fait pas exception. Trois approches très répandues existent en Python :

• sys.argv
• getopt
• argparse

Nous allons les passer en revue une par une et voir comment les utiliser pour analyser arguments et options. Commençons chronologiquement.

Analyse d’arguments avec sys.argv

Commençons simplement. Dans ce premier exemple, vous allez créer un fichier Python nommé demo1.py. Votre programme acceptera un nombre arbitraire d’arguments passés depuis la ligne de commande (ou le terminal) lors de l’exécution. Il affichera les arguments reçus et le nombre total d’arguments.

Par exemple, si vous exécutez python demo1.py abc 123, le programme renverra :

Number of arguments: 3
Argument(s) passed: ['demo1.py', 'abc', '123']

Notez que le premier argument est toujours le nom du fichier Python. Mais le code peut être modifié pour l’exclure.

Voici le code :

import sys

print('Number of arguments: {}'.format(len(sys.argv)))
print('Argument(s) passed: {}'.format(str(sys.argv)))

Vous importez d’abord le module standard sys. Vous utilisez ensuite le sous-module argv qui renvoie la liste des arguments passés au script Python, où argv[0] contient le nom du script. Si vous exécutez sys.argv dans une cellule comme ci-dessous, vous obtiendrez la liste des fichiers de configuration nécessaires au bon fonctionnement du noyau IPython. Il vaut mieux ne pas y toucher.

sys.argv

['/home/nbuser/anaconda3_501/lib/python3.6/site-packages/ipykernel/__main__.py',
 '-f',
 '/home/nbuser/.local/share/jupyter/runtime/kernel-dabba4f7-e3e0-4c39-99d2-261ba835c53f.json']

Voyons maintenant comment utiliser le module getopt pour analyser arguments et options.

Analyse d’arguments avec getopt

Comparé à sys.argv, le module getopt offre beaucoup plus de flexibilité. Posons d’abord un scénario simple et écrivons le code en conséquence.

Disons que vous avez publié un script Python encore non documenté. Vous souhaitez néanmoins fournir un retour utile aux utilisateurs lorsqu’ils l’exécutent de manière inappropriée. Votre script additionne simplement deux nombres et affiche le résultat. La seule contrainte : l’utilisateur doit fournir les entrées sous forme d’arguments en ligne de commande avec le script Python.

Plus concrètement, le script devrait idéalement être exécuté ainsi :

python add_numbers.py -a 3 -b 8

La sortie attendue est 11. Ici, -a et -b sont les options, et 3, 8 sont les arguments fournis au script. Les options améliorent non seulement la lisibilité, mais aident aussi à piloter le flux d’exécution (pensez à un cas où vous diviseriez au lieu d’additionner). Passons au code :

import getopt
import sys

# Récupérer les arguments de la ligne de commande, hors nom de fichier
argv = sys.argv[1:]
sum = 0

try:
    # Définir les paramètres de getopt
    opts, args = getopt.getopt(argv, 'a:b:', ['foperand', 'soperand'])
    # Vérifier que le nombre d'options est 2 (peut être amélioré)
    if len(opts) == 0 and len(opts) > 2:
      print ('usage: add.py -a <first_operand> -b <second_operand>')
    else:
      # Itérer sur les options et récupérer les valeurs correspondantes
      for opt, arg in opts:
         sum += int(arg)
      print('Sum is {}'.format(sum))

except getopt.GetoptError:
    # Afficher un message utile
    print ('usage: add.py -a <first_operand> -b <second_operand>')
    sys.exit(2)

L’idée est d’abord de récupérer tous les arguments via sys.argv puis de les traiter. Passons à la ligne la plus importante : opts, args = getopt.getopt(argv, 'a:b:', ['foperand', 'soperand'])

La signature de la méthode getopt() est :

getopt.getopt(args, shortopts, longopts=[])

• args est la liste des arguments pris depuis la ligne de commande.
• shortopts est l’endroit où vous spécifiez les lettres d’option. Si vous indiquez a:, cela signifie que votre script doit recevoir l’option a suivie d’une valeur en argument. Techniquement, vous pouvez utiliser autant d’options que nécessaire. Lors du passage en ligne de commande, ces options doivent être préfixées par « - ».
• longopts permet de définir les versions étendues des shortopts. Elles doivent être préfixées par « -- ».

Vous avez défini shortopts sur a:b:, ce qui signifie que votre script Python prendra deux options sous forme de lettres : « a » et « b ». En indiquant « : », vous précisez explicitement que ces options seront suivies d’arguments.

Vous avez défini longopts sur ['foperand', 'soperand'], ce qui autorise l’utilisation de f_operand et s_operand à la place de a et b en tant qu’options. Elles doivent toujours être précédées de --.

Le module getopt fournit également une classe d’exception pratique, GetoptError, pour afficher des messages utiles et guider l’utilisateur dans l’usage de votre script Python. C’est pourquoi vous encapsulez la partie fonctionnelle dans un bloc try et gérez les erreurs dans except.

Voici comment exécuter le script Python :

Remarque : le script ci-dessus n’a pas été programmé pour gérer les longopts. À vous de jouer pour l’étendre.

Passons maintenant à argparse pour l’analyse d’arguments.

Analyse d’arguments avec argparse

Au vu des deux options précédentes, on constate qu’elles ne sont pas très lisibles. Une fois argparse en action, vous conviendrez aussi qu’elles manquent de flexibilité. Pour comprendre l’usage de argparse, partons d’un extrait de code qui met en œuvre le scénario de la section précédente.

import argparse

# Construire l'analyseur d'arguments
ap = argparse.ArgumentParser()

# Ajouter les arguments à l'analyseur
ap.add_argument("-a", "--foperand", required=True,
   help="first operand")
ap.add_argument("-b", "--soperand", required=True,
   help="second operand")
args = vars(ap.parse_args())

# Calculer la somme
print("Sum is {}".format(int(args['foperand']) + int(args['soperand'])))

Pour commencer, argparse, comme les deux autres modules, fait partie de l’installation standard de Python. Vous instanciez l’objet argparse, puis le reste devient très simple à écrire. Prenons par exemple la ligne suivante :

ap.add_argument("-a", "--foperand", required=True, help="first operand")

Vous ajoutez ici l’argument que vous attendez lors de l’exécution du script. Vous fournissez sa version abrégée et sa version étendue. Avec required=True, vous imposez explicitement à l’utilisateur de fournir cet argument. Enfin, vous ajoutez une description claire de l’argument qui s’affichera si l’utilisateur n’emploie pas correctement le script.

La définition est identique pour le second argument. Vous accédez ensuite aux valeurs fournies via leurs clés respectives.

Ce fragment montre à quel point argparse facilite et rend flexible la définition d’arguments en ligne de commande. Voici un exemple d’utilisation :

Constat : avec argparse, tout devient plus simple.

Et maintenant ?

Merci d’avoir suivi ce tutoriel jusqu’au bout. Vous avez désormais en main les modules Python natifs capables d’analyser les arguments fournis en ligne de commande avec votre script. En exercice, adaptez vos projets de machine learning et de data science pour intégrer l’analyse d’arguments et en faire de vrais utilitaires en ligne de commande. Et pas seulement en ML ou data science : utilisez-les partout où c’est pertinent. C’est tout pour aujourd’hui. Pour renforcer vos compétences en Python, découvrez le cours de DataCamp Python Data Science Toolbox (Part 1).