sys et argparse — Infos runtime et analyse d'arguments

Cet article parcourt le module sys, qui te donne accès au runtime Python, et le module argparse, qui structure les arguments en ligne de commande. Tu couvriras les bases de sys.path / sys.argv / sys.exit, puis tu passeras à la définition d'arguments avec conversion de type, valeurs par défaut et choix en utilisant ArgumentParser d'argparse.

Le module sys — lire le runtime Python

Le module sys est une bibliothèque standard qui te donne accès aux informations sur le processus Python en cours d'exécution lui-même. Ce qui peut être importé (sys.path), ce qui a été passé depuis la ligne de commande (sys.argv), la version de Python et la plateforme (sys.version / sys.platform), et comment terminer le processus (sys.exit) — les infos et fonctions sur Python lui-même vivent toutes ici.

`sys.path` est la liste des dossiers que import parcourt pour trouver les modules, scannés dans l'ordre depuis le haut. Avec for p in sys.path: tu peux afficher chaque dossier enregistré une ligne à la fois. Dans le runtime Pyodide tu verras des chemins comme /lib/python312.zip / /lib/python3.12 / /lib/python3.12/lib-dynload / /lib/python3.12/site-packages, alors qu'une installation Python normale liste le dossier de la bibliothèque standard et site-packages (où vont les bibliothèques installées par pip).

Extrais la plateforme et le contenu du chemin de recherche des modules depuis le module sys et affiche-les. Le module sys te donne accès aux informations sur le processus Python en cours d'exécution.

① Importe le module sys

② Utilise sys.platform pour afficher le runtime sous la forme Platform: ◯◯

③ Boucle à travers sys.path avec for et affiche chaque entrée sur sa propre ligne (remplace les chaînes vides '' par une étiquette plus claire)

(Si ton code s'exécute correctement, l'explication apparaîtra.)

sys.platform est un attribut qui retourne l'identifiant de l'OS sous forme de chaîne. Dans le runtime Pyodide du navigateur il affiche emscripten (sur une vraie machine tu verras darwin (Mac) / win32 (Windows) / linux). Il est utilisé quand tu as besoin de te brancher sur le système d'exploitation.

import sys

print("Platform:", sys.platform)
# Mac:        Platform: darwin
# Windows:    Platform: win32
# Linux:      Platform: linux
# Navigateur: Platform: emscripten

sys.argv et argparse — gérer les arguments en ligne de commande

Sur une vraie installation Python, quand tu exécutes une commande comme python script.py user_name 42, les jetons atterrissent dans sys.argv sous forme de liste de chaînes. sys.argv[0] est le nom du script, et sys.argv[1:] contient les arguments que tu as passés. Le module argparse est une bibliothèque standard qui lit sys.argv et la convertit en un objet auquel tu accèdes par attribut, te laissant déclarer la conversion de type, les valeurs par défaut et les restrictions de choix de manière propre.

# script.py (destiné à tourner sur une vraie installation Python)
import sys

print(sys.argv)
# Exemple : exécuter python script.py user_name 42 produit
# ['script.py', 'user_name', '42']

# Les vrais arguments commencent à [1:]
args = sys.argv[1:]
print(args)         # ['user_name', '42']

sys.argv est essentiellement vide dans le navigateur

Le runtime navigateur que cette série utilise n'a pas du tout de ligne de commande, donc sys.argv ne contient qu'une valeur fixe comme ['<exec>']. Vérifie le comportement en vraie machine dans le bloc code ci-dessus ; dans la pratique, tu remplaceras en passant une liste directement à la place de sys.argv.

Une fois que tu commences à démonter manuellement `sys.argv`, tu rencontres tout de suite des exigences comme convertir des chaînes en nombres, supporter des drapeaux optionnels, ou afficher un message d'usage avec --help. Python livre argparse comme bibliothèque standard pour gérer tout ça pour toi, et le flux de base se fait en trois étapes — créer un ArgumentParser, enregistrer les arguments que tu veux recevoir avec add_argument, puis les convertir en valeurs avec parse_args.

# Style Python en vraie machine
import argparse

parser = argparse.ArgumentParser(description="CLI de recherche de produits")
parser.add_argument("--keyword", required=True)         # passer comme --keyword Apple
parser.add_argument("--limit", type=int, default=10)    # auto-converti en int

args = parser.parse_args()                              # lit sys.argv[1:]
print(args.keyword, args.limit)

Dans le navigateur, utilise la forme parse_args(list)

Comme le runtime navigateur n'a pas de sys.argv, appeler parse_args() sans arguments lève une erreur. Utilise la même forme à passage de liste que tu utiliserais dans les tests — parse_args(["--keyword", "Apple", "--limit", "5"]). Sur une vraie machine, omettre cette liste utilise automatiquement sys.argv[1:].

Construis l'analyseur d'arguments pour une CLI de recherche de produits avec argparse. Crée un parser qui accepte deux options, --keyword et --limit, puis analyse une liste d'arguments simulée.

Sur une vraie installation Python, appeler parse_args() sans arguments lit depuis sys.argv automatiquement, mais comme cet exercice tourne dans le navigateur tu passeras une liste à parse_args() manuellement comme substitut de sys.argv.

① Importe argparse et crée un parser

② Enregistre les deux arguments --keyword et --limit

③ Analyse la liste ["--keyword", "Apple", "--limit", "5"] (puisque le navigateur n'a pas de vrai sys.argv, passe la liste directement)

④ Extrais keyword et limit du résultat analysé et affiche-les sur une seule ligne, séparés par un espace

argparse en profondeur — conversion de type, valeurs par défaut, choix

add_argument a plusieurs options qui contrôlent comment un argument se comporte. Quatre d'entre elles couvrent presque tous les cas pratiques de CLI.

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--keyword", required=True)
parser.add_argument("--limit", type=int, default=10)
parser.add_argument("--order", choices=["asc", "desc"], default="asc")

args = parser.parse_args(["--keyword", "Apple", "--limit", "5", "--order", "desc"])
print(args.keyword, args.limit, args.order)
# -> Apple 5 desc

Combiner type et default

Quand tu spécifies les deux type=int, default=10, l'argument reçoit 10 (int) quand omis, et la valeur passée est convertie en int quand fournie. Les valeurs par défaut ne passent pas par la conversion de type, donc écris la valeur par défaut déjà dans le type cible. Écrire default="10" mettrait la chaîne "10" uniquement quand l'argument est omis — un bug subtil.

Définis les arguments d'une CLI de recherche d'inventaire, avec conversion de type, valeurs par défaut et choix. Confirme qu'omettre --limit retombe sur la valeur par défaut.

Sur une vraie machine, parse_args() sans arguments lit depuis sys.argv automatiquement, mais comme tu tournes dans le navigateur tu passeras une liste d'arguments simulée directement.

① Importe argparse et crée un parser

② Enregistre ces trois arguments

- --keyword : obligatoire

- --limit : type entier, par défaut 10

- --order : soit asc soit desc, par défaut asc

③ Analyse une liste équivalente à --keyword Banana --order desc (en omettant --limit)

④ Affiche les trois valeurs, keyword, limit et order, sur une seule ligne séparées par des espaces

sys.exit — retourner un code de sortie

sys.exit(code) est une fonction qui prend un nombre et termine le processus. Par convention, 0 signifie succès et toute valeur non nulle (généralement 1) signifie échec, et les systèmes CI et les scripts shell se branchent sur cette valeur pour décider quoi faire ensuite. En interne, ça lève une exception SystemExit. Tu peux l'attraper avec try / except, mais tu la laisses généralement se propager pour que le processus se termine.

import sys

price = -100

if price < 0:
    print("Erreur : le prix est négatif")
    sys.exit(1)         # rien après ce point ne tourne

print("On continue...")  # ne tourne que quand price >= 0

Écris une validation d'inventaire avec sys.exit. Quand un nombre de stock négatif arrive, le programme doit échouer et le code après ne doit pas tourner.

① Importe sys

② Mets le nombre de stock à -3 (pour simuler une mauvaise valeur)

③ Si le stock est négatif, affiche Erreur : le stock est négatif, puis termine le processus avec le code de sortie 1

④ En dehors du if, affiche le stock sous la forme Vérification stock OK : ◯◯ (cela ne doit pas tourner quand le stock est négatif)