Comment lire / traiter les arguments de la ligne de commande?

Je suis à l'origine un programmeur C. J'ai vu de nombreuses astuces et "hacks" pour lire de nombreux arguments différents.

De quelles manières les programmeurs Python peuvent-ils procéder?

en relation

• Quelle est la meilleure façon de récupérer / analyser les arguments de ligne de commande passés à un script Python?
• Implémenter des interfaces de ligne de commande de style «[commande] [action] [paramètre]»?
• Comment puis-je traiter des arguments de ligne de commande en Python?
• Comment puis-je formater l'aide à l'argument positionnel à l'aide de l'optparse de Python?

La solution canonique dans la bibliothèque standard est argparse( docs ):

Voici un exemple:

from argparse import ArgumentParser

parser = ArgumentParser()
parser.add_argument("-f", "--file", dest="filename",
                    help="write report to FILE", metavar="FILE")
parser.add_argument("-q", "--quiet",
                    action="store_false", dest="verbose", default=True,
                    help="don't print status messages to stdout")

args = parser.parse_args()

argparse soutient (entre autres):

• Plusieurs options dans n'importe quel ordre.
• Options courtes et longues.
• Les valeurs par défaut.
• Génération d'un message d'aide à l'utilisation.

import sys

print("\n".join(sys.argv))

sys.argv est une liste qui contient tous les arguments passés au script sur la ligne de commande.

Fondamentalement,

import sys
print(sys.argv[1:])

Faire le tour de l'évangélisation pour argparse, ce qui est mieux pour ces raisons .. essentiellement:

(copié à partir du lien)

• Le module argparse peut gérer les arguments positionnels et optionnels, tandis que optparse ne peut gérer que les arguments optionnels

• argparse n'est pas dogmatique sur ce à quoi devrait ressembler votre interface de ligne de commande - les options comme -file ou / file sont prises en charge, tout comme les options requises. Optparse refuse de prendre en charge ces fonctionnalités, préférant la pureté à la praticité

• argparse produit des messages d'utilisation plus informatifs, y compris l'utilisation de la ligne de commande déterminée à partir de vos arguments, et des messages d'aide pour les arguments positionnels et facultatifs. Le module optparse vous oblige à écrire votre propre chaîne d'utilisation et n'a aucun moyen d'afficher l'aide pour les arguments positionnels.

• argparse prend en charge les actions qui consomment un nombre variable d'arguments de ligne de commande, tandis qu'optparse requiert que le nombre exact d'arguments (par exemple 1, 2 ou 3) soit connu à l'avance.

• argparse prend en charge les analyseurs qui expédient vers les sous-commandes, tandis qu'optparse nécessite de définir allow_interspersed_argset d'effectuer la répartition de l'analyseur manuellement

Et mon préféré:

• argparse permet de spécifier les paramètres de type et d'action add_argument() avec de simples callables, tandis qu'optparse nécessite le piratage d'attributs de classe comme STORE_ACTIONSou CHECK_METHODSpour obtenir une vérification correcte des arguments

Il y a aussi le argparsemodule stdlib (une "amélioration" sur le optparsemodule stdlib ). Exemple d' introduction à argparse :

# script.py
import argparse

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        'integers', metavar='int', type=int, choices=range(10),
         nargs='+', help='an integer in the range 0..9')
    parser.add_argument(
        '--sum', dest='accumulate', action='store_const', const=sum,
        default=max, help='sum the integers (default: find the max)')

    args = parser.parse_args()
    print(args.accumulate(args.integers))

Usage:

$ script.py 1 2 3 4
4

$ script.py --sum 1 2 3 4
10

Une façon de le faire consiste à utiliser sys.argv. Cela affichera le nom du script comme premier argument et tous les autres paramètres que vous lui passerez.

import sys

for arg in sys.argv:
    print arg

La bibliothèque docopt est vraiment épurée . Il construit un argument argument à partir de la chaîne d'utilisation de votre application.

Par exemple, dans le fichier Lisezmoi de docopt:

"""Naval Fate.

Usage:
  naval_fate.py ship new <name>...
  naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
  naval_fate.py ship shoot <x> <y>
  naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
  naval_fate.py (-h | --help)
  naval_fate.py --version

Options:
  -h --help     Show this screen.
  --version     Show version.
  --speed=<kn>  Speed in knots [default: 10].
  --moored      Moored (anchored) mine.
  --drifting    Drifting mine.

"""
from docopt import docopt


if __name__ == '__main__':
    arguments = docopt(__doc__, version='Naval Fate 2.0')
    print(arguments)

Si vous avez besoin de quelque chose de rapide et pas très flexible

main.py:

import sys

first_name = sys.argv[1]
last_name = sys.argv[2]
print("Hello " + first_name + " " + last_name)

Ensuite, exécutez python main.py James Smith

pour produire la sortie suivante:

Bonjour James Smith

#set default args as -h , if no args:
if len(sys.argv) == 1: sys.argv[1:] = ["-h"]

J'utilise optparse moi-même, mais j'aime vraiment la direction que prend Simon Willison avec sa bibliothèque optfunc récemment introduite . Il fonctionne par:

"introspecter une définition de fonction (y compris ses arguments et leurs valeurs par défaut) et l'utiliser pour construire un analyseur d'arguments en ligne de commande."

Ainsi, par exemple, cette définition de fonction:

def geocode(s, api_key='', geocoder='google', list_geocoders=False):

est transformé en ce texte d'aide optparse:

    Options:
      -h, --help            show this help message and exit
      -l, --list-geocoders
      -a API_KEY, --api-key=API_KEY
      -g GEOCODER, --geocoder=GEOCODER

J'aime getopt de stdlib, par exemple:

try:
    opts, args = getopt.getopt(sys.argv[1:], 'h', ['help'])
except getopt.GetoptError, err: 
    usage(err)

for opt, arg in opts:
    if opt in ('-h', '--help'): 
        usage()

if len(args) != 1:
    usage("specify thing...")

Dernièrement, j'ai enveloppé quelque chose de similaire à cela pour rendre les choses moins verbeuses (par exemple, rendre "-h" implicite).

De Pocoo click est plus intuitif, nécessite moins de passe-partout et est au moins aussi puissant que l'argparse.

La seule faiblesse que j'ai rencontrée jusqu'à présent est que vous ne pouvez pas faire beaucoup de personnalisation pour aider les pages, mais ce n'est généralement pas une exigence et docopt semble être le choix clair quand il l'est.

Comme vous pouvez le voir optparse "Le module optparse est obsolète et ne sera pas développé davantage; le développement se poursuivra avec le module argparse ."

import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                   help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
                   const=sum, default=max,
                   help='sum the integers (default: find the max)')

args = parser.parse_args()
print(args.accumulate(args.integers))

Assuming the Python code above is saved into a file called prog.py
$ python prog.py -h

Ref-link: https://docs.python.org/3.3/library/argparse.html

Vous pourriez être intéressé par un petit module Python que j'ai écrit pour rendre la gestion des arguments de ligne de commande encore plus facile (open source et gratuit à utiliser) - Commando

Je recommande de regarder docopt comme une alternative simple à ces autres.

docopt est un nouveau projet qui fonctionne en analysant votre message d'utilisation --help plutôt qu'en vous obligeant à tout implémenter vous-même. Il vous suffit de mettre votre message d'utilisation au format POSIX.

Pourtant, une autre option est argh . Il s'appuie sur argparse et vous permet d'écrire des choses comme:

import argh

# declaring:

def echo(text):
    "Returns given word as is."
    return text

def greet(name, greeting='Hello'):
    "Greets the user with given name. The greeting is customizable."
    return greeting + ', ' + name

# assembling:

parser = argh.ArghParser()
parser.add_commands([echo, greet])

# dispatching:

if __name__ == '__main__':
    parser.dispatch()

Il générera automatiquement de l'aide, etc., et vous pouvez utiliser des décorateurs pour fournir des conseils supplémentaires sur la façon dont l'analyse d'arg doit fonctionner.

Ma solution est entrypoint2 . Exemple:

from entrypoint2 import entrypoint
@entrypoint
def add(file, quiet=True): 
    ''' This function writes report.

    :param file: write report to FILE
    :param quiet: don't print status messages to stdout
    '''
    print file,quiet

Texte d'aide:

usage: report.py [-h] [-q] [--debug] file

This function writes report.

positional arguments:
  file         write report to FILE

optional arguments:
  -h, --help   show this help message and exit
  -q, --quiet  don't print status messages to stdout
  --debug      set logging level to DEBUG