Python Academy · Leçon

Sous-commandes et options

Construire des CLI complexes

Sous-commandes et options est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Pourquoi utiliser des sous-commandes ?

Des outils comme git possèdent des sous-commandes : git add, git commit. argparse les prend en charge grâce aux sous-analyseurs, chaque sous-commande ayant ses propres arguments.

import argparse

parser = argparse.ArgumentParser(prog='tool')
sub = parser.add_subparsers(dest='command')
print('subparsers ready')

Ajouter des sous-analyseurs

add_subparsers renvoie un objet dont la méthode add_parser crée chaque sous-commande. dest enregistre celle qui a été choisie.

import argparse

parser = argparse.ArgumentParser()
sub = parser.add_subparsers(dest='command')
sub.add_parser('start')
sub.add_parser('stop')
args = parser.parse_args(['start'])
print('command:', args.command)

Arguments propres à chaque sous-commande

Chaque sous-analyseur peut définir ses propres arguments. La sous-commande add de cet exemple reçoit un nom ; list n'en reçoit aucun.

import argparse

parser = argparse.ArgumentParser()
sub = parser.add_subparsers(dest='command')
p_add = sub.add_parser('add')
p_add.add_argument('name')
sub.add_parser('list')
args = parser.parse_args(['add', 'milk'])
print(args.command, args.name)

Distribuer selon la commande

Après l'analyse, utilisez args.command pour exécuter la logique appropriée.

import argparse

parser = argparse.ArgumentParser()
sub = parser.add_subparsers(dest='command')
p_add = sub.add_parser('add')
p_add.add_argument('item')
sub.add_parser('clear')

args = parser.parse_args(['add', 'eggs'])
if args.command == 'add':
    print('adding', args.item)
elif args.command == 'clear':
    print('clearing all')

set_defaults pour les fonctions de traitement

Une approche claire consiste à associer une fonction à chaque sous-analyseur avec set_defaults(func=...), puis à appeler args.func(args).

import argparse

def do_hi(args):
    print('hi', args.who)

parser = argparse.ArgumentParser()
sub = parser.add_subparsers()
p = sub.add_parser('hi')
p.add_argument('who')
p.set_defaults(func=do_hi)

args = parser.parse_args(['hi', 'Ana'])
args.func(args)

Options partagées avec des analyseurs parents

Un analyseur parent contient les options communes à plusieurs sous-commandes, ce qui évite les répétitions. Transmettez parents=[base] et add_help=False.

import argparse

base = argparse.ArgumentParser(add_help=False)
base.add_argument('--verbose', action='store_true')

parser = argparse.ArgumentParser()
sub = parser.add_subparsers(dest='cmd')
sub.add_parser('run', parents=[base])
args = parser.parse_args(['run', '--verbose'])
print(args.cmd, args.verbose)

Valeurs par défaut pour chaque option

Les options des sous-commandes peuvent avoir leurs propres valeurs par défaut et leurs propres types, tout comme les arguments de niveau supérieur.

import argparse

parser = argparse.ArgumentParser()
sub = parser.add_subparsers(dest='cmd')
p = sub.add_parser('scale')
p.add_argument('--factor', type=float, default=1.0)
args = parser.parse_args(['scale'])
print('factor:', args.factor)

Ajouter plusieurs fois une option

action='append' permet de fournir une option plusieurs fois, en rassemblant chaque valeur dans une liste.

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--tag', action='append', default=[])
args = parser.parse_args(['--tag', 'a', '--tag', 'b'])
print(args.tag)

Compter les options

action='count' compte le nombre d'apparitions d'une option, selon le modèle classique de verbosité -vvv.

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('-v', action='count', default=0)
args = parser.parse_args(['-v', '-v', '-v'])
print('verbosity level:', args.v)

Un outil à deux commandes

La combinaison de sous-commandes, de fonctions de traitement et d'options partagées produit une CLI structurée à plusieurs commandes.

import argparse

def add(args):
    print('add', args.item, 'qty', args.qty)

def remove(args):
    print('remove', args.item)

parser = argparse.ArgumentParser()
sub = parser.add_subparsers()
pa = sub.add_parser('add')
pa.add_argument('item')
pa.add_argument('--qty', type=int, default=1)
pa.set_defaults(func=add)
pr = sub.add_parser('remove')
pr.add_argument('item')
pr.set_defaults(func=remove)

args = parser.parse_args(['add', 'pen', '--qty', '3'])
args.func(args)

Sous-commande obligatoire

Définissez required=True sur les sous-analyseurs afin que l'utilisateur doive choisir une commande ; sinon, argparse génère une erreur.

import argparse

parser = argparse.ArgumentParser()
sub = parser.add_subparsers(dest='cmd', required=True)
sub.add_parser('go')
args = parser.parse_args(['go'])
print('chosen:', args.cmd)

Vérification rapide

Vérifiez votre compréhension des sous-commandes et des options.

Récapitulatif

Vous avez appris à utiliser les sous-commandes et les options :

add_subparsers et add_parser servent à créer des outils à plusieurs commandes.
set_defaults(func=...) distribue l'exécution aux fonctions de traitement.
Les analyseurs parents partagent les options communes.
Les actions append et count gèrent les options répétées.

Suite : la bibliothèque Click pour créer des CLI à base de décorateurs.

Questions Fréquemment Posées

La leçon « Sous-commandes et options » est-elle gratuite ?

Oui — le texte complet de « Sous-commandes et options » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Sous-commandes et options » ?

Construire des CLI complexes Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Sous-commandes et options » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Python Academy