web-dev-qa-db-fra.com

Comment lire / traiter les arguments en ligne de commande?

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

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

Apparenté, relié, connexe

pythoncommand-linecommand-line-arguments
572
edgerA

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 prend en charge (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.
410
Ayman Hourieh
_import sys

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

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

Fondamentalement,

_import sys
print(sys.argv[1:])
_
511
John Slavick

Il suffit de faire le tour de l'évangélisation pour argparse qui est meilleur pour ces raisons .. essentiellement:

(copié du lien)

  • le module argparse peut gérer des arguments positionnels et optionnels, alors qu'optparse ne peut gérer que des arguments optionnels

  • argparse n’est pas dogmatique sur ce à quoi devrait ressembler votre interface de ligne de commande - des options telles que -file ou/file sont prises en charge, de même que les options obligatoires. Optparse refuse de prendre en charge ces fonctionnalités, préférant la pureté à la fonctionnalité

  • argparse génère des messages d'utilisation plus informatifs, notamment une utilisation de la ligne de commande déterminée à partir de vos arguments, ainsi que des messages d'aide pour les arguments de position et les arguments facultatifs. Le module optparse nécessite que vous écriviez votre propre chaîne d'utilisation et n'a aucun moyen d'afficher de l'aide pour les arguments de position.

  • argparse prend en charge les actions qui consomment un nombre variable d'arguments en 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 syntaxiques qui envoient des sous-commandes, tandis qu'optparse nécessite de définir allow_interspersed_args et d'effectuer manuellement l'envoi de l'analyseur.

Et mon préféré:

  • argparse permet de spécifier les paramètres de type et d'action à add_argument() à l'aide de simples callables, tandis qu'optparse requiert des attributs de classe de piratage tels que STORE_ACTIONS ou CHECK_METHODS pour obtenir le contrôle correct des arguments.
125
Silfheed

Il y a aussi argparse module stdlib (une "amélioration" sur le module stdlib optparse). Exemple de l'introduction à argparse :

# script.py
import argparse

if __== '__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
67
jfs

Une façon de le faire est d'utiliser sys.argv. Cela imprimera le nom du script en tant que premier argument et tous les autres paramètres que vous lui transmettez.

import sys

for arg in sys.argv:
    print arg
49
JPCosta

La bibliothèque docopt est vraiment lisse. Il crée un argument dicté par la chaîne d'utilisation de votre application.

Par exemple, à partir du fichier 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 __== '__main__':
    arguments = docopt(__doc__, version='Naval Fate 2.0')
    print(arguments)
48
ralbatross

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)

Puis lancez python main.py James Smith

pour produire la sortie suivante:

Bonjour James Smith

41
Kent Munthe Caspersen
#set default args as -h , if no args:
if len(sys.argv) == 1: sys.argv[1:] = ["-h"]
26
whi

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

"Introspection d’une définition de fonction (y compris ses arguments et leurs valeurs par défaut) et utilisation de celle-ci pour construire un analyseur d’argument en ligne de commande."

Donc, 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
19
Van Gale

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 pour rendre les choses moins verbeuses (par exemple, en rendant "-h" implicite).

8
Peter Ericson

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

7
tverrbjelke

Le clic de Pocoo est plus intuitif, nécessite moins de passe-partout et est au moins aussi puissant que argparse.

La seule faiblesse que j'ai rencontrée jusqu'à présent est que vous ne pouvez pas personnaliser beaucoup les pages d'aide, mais ce n'est généralement pas une exigence et docopt semble être le choix évident quand il le faut.

7
Ryne Everett
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
5
JON

Vous pouvez être intéressé par un petit module Python que j’ai écrit pour faciliter encore plus la gestion des arguments en ligne de commande (open source et libre d’utilisation) - Commando

4
Mufasa

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

docopt est un nouveau projet qui analyse votre message d'utilisation --help plutôt que de vous demander de tout mettre en œuvre vous-même. Il vous suffit de mettre votre message d'utilisation au format POSIX.

4
David C. Bishop

Encore 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 __== '__main__':
    parser.dispatch()

Il générera automatiquement de l'aide, etc., et vous pouvez utiliser les décorateurs pour fournir des indications supplémentaires sur le fonctionnement de l'analyse des arguments.

3
circular-ruin

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
0
ponty