Come leggere / elaborare gli argomenti della riga di comando?

Sono originariamente un programmatore C. Ho visto numerosi trucchi e "hack" per leggere molti argomenti diversi.

Quali sono alcuni dei modi in cui i programmatori Python possono farlo?

Relazionato

• Qual è il modo migliore per afferrare / analizzare gli argomenti della riga di comando passati a uno script Python?
• Implementazione di interfacce da riga di comando in stile "[comando] [azione] [parametro]"?
• Come posso elaborare gli argomenti della riga di comando in Python?
• Come posso formattare l'argomento posizionale per usare optparse di Python?

La soluzione canonica nella libreria standard è argparse( docs ):

Ecco un esempio:

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 supporta (tra le altre cose):

• Molteplici opzioni in qualsiasi ordine.
• Opzioni corte e lunghe.
• Valori standard.
• Generazione di un messaggio di aiuto per l'utilizzo.

import sys

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

sys.argv è un elenco che contiene tutti gli argomenti passati allo script dalla riga di comando.

Fondamentalmente,

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

Basta andare in giro per evangelizzare per argparse, il che è meglio per questi motivi ... essenzialmente:

(copiato dal link)

• Il modulo argparse può gestire argomenti posizionali e opzionali, mentre optparse può gestire solo argomenti opzionali

• argparse non è dogmatico su come dovrebbe apparire l'interfaccia della riga di comando: sono supportate opzioni come -file o / file, così come le opzioni richieste. Optparse rifiuta di supportare queste funzionalità, preferendo la purezza alla praticità

• argparse produce messaggi di utilizzo più informativi, incluso l'uso della riga di comando determinato dai tuoi argomenti, e aiuta i messaggi per argomenti sia posizionali che opzionali. Il modulo optparse richiede di scrivere la propria stringa di utilizzo e non ha modo di visualizzare la guida per gli argomenti posizionali.

• argparse supporta azioni che consumano un numero variabile di argomenti della riga di comando, mentre optparse richiede che il numero esatto di argomenti (ad es. 1, 2 o 3) sia noto in anticipo

• argparse supporta i parser che inviano ai sotto-comandi, mentre optparse richiede l'impostazione allow_interspersed_argse l'esecuzione manuale del parser

E il mio preferito personale:

• argparse consente di specificare i parametri di tipo e azione add_argument() con semplici callable, mentre optparse richiede l'attribuzione di attributi di classe come STORE_ACTIONSo CHECK_METHODSper ottenere il corretto controllo degli argomenti

C'è anche il argparsemodulo stdlib (un "miglioramento" sul optparsemodulo di stdlib ). Esempio dall'introduzione ad 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))

Uso:

$ script.py 1 2 3 4
4

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

Un modo per farlo è usare sys.argv. Questo stamperà il nome dello script come primo argomento e tutti gli altri parametri che gli passerai.

import sys

for arg in sys.argv:
    print arg

Il docopt libreria è davvero liscia. Crea un argomento dettato dalla stringa di utilizzo per la tua app.

Ad esempio dal readme di 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)

Se hai bisogno di qualcosa di veloce e non molto flessibile

main.py:

import sys

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

Quindi corri python main.py James Smith

per produrre il seguente output:

Ciao James Smith

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

Uso optparse da solo, ma mi piace molto la direzione che Simon Willison sta prendendo con la sua libreria optfunc recentemente introdotta . Funziona da:

msgstr "introspezione di una definizione di funzione (compresi i suoi argomenti e i loro valori predefiniti) e utilizzo di quello per costruire un parser di argomenti da riga di comando."

Quindi, ad esempio, questa definizione di funzione:

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

viene trasformato in questo testo di aiuto optparse:

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

Mi piace getopt da stdlib, ad esempio:

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

Ultimamente sto avvolgendo qualcosa di simile a questo per rendere le cose meno dettagliate (ad esempio, rendendo implicito "-h").

Di Pocoo click è più intuitivo, richiede meno scaldabagni ed è almeno potente quanto l'argparse.

L'unica debolezza che ho riscontrato finora è che non puoi fare molta personalizzazione per aiutare le pagine, ma di solito non è un requisito e docopt sembra la scelta chiara quando lo è.

Come puoi vedere optparse "Il modulo optparse è obsoleto e non verrà ulteriormente sviluppato; lo sviluppo continuerà con il modulo 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

Potresti essere interessato a un piccolo modulo Python che ho scritto per rendere ancora più semplice la gestione degli argomenti della riga di comando (open source e gratis da usare) - Commando

Consiglio di consultare docopt come una semplice alternativa a questi altri.

docopt è un nuovo progetto che funziona analizzando il tuo messaggio di utilizzo --help anziché richiedere di implementare tutto da solo. Devi solo mettere il tuo messaggio di utilizzo nel formato POSIX.

Ancora un'altra opzione è argh . Si basa su argparse e ti consente di scrivere cose come:

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()

Genererà automaticamente aiuto e così via, ed è possibile utilizzare i decoratori per fornire ulteriori indicazioni su come dovrebbe funzionare l'arg-parsing.

La mia soluzione è entrypoint2 . Esempio:

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

Testo guida:

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