Comment lire / traiter les arguments en ligne de commande?

Question

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

Quels sont les moyens par lesquels les programmeurs Python peuvent le faire?

Connexes

• Quel est le meilleur moyen de récupérer / analyser les arguments de ligne de commande transmis à un script Python?
• Implémentation d'une & # 8220; [commande] [action ] [paramètre] & # 8221; interfaces de style ligne de commande?
• Comment puis-je traiter les arguments de ligne de commande en Python?
• Comment formater l'aide d'argument de position à l'aide de Python & # 8217; optparse?

Answer 1

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.
• Valeurs par défaut.
• Génération d'un message d'aide à l'utilisation.

Answer 2

import sys

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

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

Fondamentalement,

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

Answer 3

Nous ne faisons qu'évangéliser pour argparse , ce qui est préférable pour ces raisons .. essentiellement:

(copié du lien)

• Le module argparse peut gérer des positions et des arguments optionnels, tandis que optparse ne peut gérer que facultatif arguments

• argparse n’est pas dogmatique quelle est votre interface de ligne de commande devrait ressembler à - options comme -file ou / file sont supportés, comme le sont options requises. Optparse refuse de soutenir ces fonctionnalités, préférant la pureté avant la praticité

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

• argparse soutient les actions qui consommer un nombre variable de arguments en ligne de commande, tandis qu'optparse exige que le nombre exact de les arguments (par exemple 1, 2 ou 3) doivent être connus à l'avance

• argparse prend en charge les analyseurs syntaxiques qui envoi à des sous-commandes, tout en optparse nécessite un réglage allow_interspersed_args et effectuer les opérations suivantes envoi manuel du parseur

Et mon préféré:

• argparse autorise le type et paramètres d'action pour add_argument () être spécifié avec simple callables, alors qu'optparse nécessite piratage des attributs de classe comme STORE_ACTIONS ou CHECK_METHODS pour obtenir vérification correcte des arguments

Answer 4

Il existe également un argparse module stdlib (un " ; amélioration "sur le module optparse de stdlib). Exemple tiré de l'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))

Utilisation:

$ script.py 1 2 3 4
4

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

Answer 5

Une des façons de le faire consiste à utiliser sys.argv . Ceci 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

Answer 6

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 __name__ == '__main__':
    arguments = docopt(__doc__, version='Naval Fate 2.0')
    print(arguments)

Answer 7

Si vous avez besoin de quelque chose de rapide et peu flexible

main.py:

import sys

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

Exécutez ensuite python main.py James Smith

pour produire le résultat suivant:

  

Bonjour James Smith

Answer 8

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

Answer 9

J'utilise moi-même optparse, mais j'aime vraiment la direction prise par Simon Willison avec son optfunc bibliothèque. Cela fonctionne par:

  

" introspection d'une fonction   définition (y compris ses arguments)   et leurs valeurs par défaut) et en utilisant   que pour construire une ligne de commande   analyseur d'arguments. "

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

Answer 10

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...")

Ces derniers temps, j’ai utilisé quelque chose de similaire pour rendre les choses moins verbeuses (par exemple, rendre "implicite").

Answer 11

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

Answer 12

Le

clic de Pocoo est plus intuitif, nécessite moins de passe-partout et est au moins aussi puissant qu'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 obligatoire et docopt semble être le choix évident quand il le sera.

Answer 13

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

Answer 14

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

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.

Answer 15

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

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

Answer 16

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

Answer 17

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