multiple - python flags




Semplice esempio argparse desiderato: 1 argomento, 3 risultati (6)

Ancora un'altra introduzione sommaria, ispirata a questo post .

import argparse

# define functions, classes, etc.

# executes when your script is called from the command-line
if __name__ == "__main__":

    parser = argparse.ArgumentParser()
    #
    # define each option with: parser.add_argument
    #
    args = parser.parse_args() # automatically looks at sys.argv
    #
    # access results with: args.argumentName
    #

Gli argomenti sono definiti con combinazioni di quanto segue:

parser.add_argument( 'name', options... )              # positional argument
parser.add_argument( '-x', options... )                # single-char flag
parser.add_argument( '-x', '--long-name', options... ) # flag with long name

Le opzioni comuni sono:

  • help : descrizione di questo argomento quando viene usato --help .
  • default : valore predefinito se l'arg è omesso.
  • type : se ti aspetti un float o un int (altrimenti è str ).
  • dest : dare un nome diverso a un flag (es. '-x', '--long-name', dest='longName' ).
    Nota: per impostazione predefinita si accede a args.long_name con args.long_name
  • action : per la gestione speciale di determinati argomenti
    • store_true, store_false : per argomenti booleani
      '--foo', action='store_true' => args.foo == True
    • store_const : da utilizzare con l'opzione const
      '--foo', action='store_const', const=42 => args.foo == 42
    • count : per le opzioni ripetute, come in ./myscript.py -vv
      '-v', action='count' => args.v == 2
    • append : per le opzioni ripetute, come in ./myscript.py --foo 1 --foo 2
      '--foo', action='append' => args.foo == ['1', '2']
  • required : se è richiesto un flag o un argomento posizionale no.
  • nargs : per una bandiera per catturare N args
    ./myscript.py --foo ab => args.foo = ['a', 'b']
  • choices : per limitare i possibili input (specificare come lista di stringhe o int se type=int ).

La documentation per il modulo argparse python , sebbene ne sono sicuro, è troppo per il mio piccolo cervello da principiante da afferrare proprio adesso. Non è necessario eseguire calcoli matematici sulla riga di comando o interferire con le linee di formattazione sullo schermo o modificare i caratteri delle opzioni. Tutto quello che voglio fare è "Se arg è A, fallo, se B lo fa, se nessuno dei precedenti mostra aiuto e chiudi" .


Ecco come lo faccio con argparse (con più argomenti):

parser = argparse.ArgumentParser(description='Description of your program')
parser.add_argument('-f','--foo', help='Description for foo argument', required=True)
parser.add_argument('-b','--bar', help='Description for bar argument', required=True)
args = vars(parser.parse_args())

args sarà un dizionario contenente gli argomenti:

if args['foo'] == 'Hello':
    # code here

if args['bar'] == 'World':
    # code here

Nel tuo caso aggiungi semplicemente un argomento.


La documentazione argparse è abbastanza buona, ma lascia alcuni dettagli utili che potrebbero non essere ovvi. (@Diego Navarro ne ha già parlato, ma cercherò di espandere leggermente la sua risposta.) L'utilizzo di base è il seguente:

parser = argparse.ArgumentParser()
parser.add_argument('-f', '--my-foo', default='foobar')
parser.add_argument('-b', '--bar-value', default=3.14)
args = parser.parse_args()

L'oggetto che si ottiene da parse_args() è un oggetto "Namespace": un oggetto le cui variabili membro prendono il nome dagli argomenti della riga di comando. L'oggetto Namespace è il modo in cui accedi ai tuoi argomenti e ai valori ad essi associati:

args = parser.parse_args()
print args.my_foo
print args.bar_value

(Si noti che argparse sostituisce '-' nei nomi degli argomenti con caratteri di sottolineatura durante la denominazione delle variabili.)

In molte situazioni potresti voler usare argomenti semplicemente come bandiere che non hanno valore. Puoi aggiungerli in argparse in questo modo:

parser.add_argument('--foo', action='store_true')
parser.add_argument('--no-foo', action='store_false')

Quanto sopra creerà variabili denominate 'foo' con valore True e 'no_foo' con valore False, rispettivamente:

if (args.foo):
    print "foo is true"

if (args.no_foo is False):
    print "nofoo is false"

Nota anche che puoi usare l'opzione "richiesta" quando aggiungi un argomento:

parser.add_argument('-o', '--output', required=True)

In questo modo se ometti questo argomento alla riga di comando, argparse ti dirà che manca e interromperà l'esecuzione del tuo script.

Infine, tieni presente che è possibile creare una struttura dict dei tuoi argomenti usando la funzione vars , se ciò ti rende la vita più facile.

args = parser.parse_args()
argsdict = vars(args)
print argsdict['my_foo']
print argsdict['bar_value']

Come puoi vedere, vars restituisce un dict con i nomi degli argomenti come chiavi e i loro valori come, er, valori.

Ci sono molte altre opzioni e cose che puoi fare, ma questo dovrebbe riguardare gli scenari di utilizzo più comuni e più comuni.


La mia comprensione della domanda originale è duplice. Innanzitutto, in termini del più semplice esempio argparse, sono sorpreso di non averlo visto qui. Ovviamente, per essere semplice-morto, è anche tutto overhead con poco potere, ma potrebbe farti iniziare.

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("a")
args = parser.parse_args()

if args.a == 'magic.name':
    print 'You nailed it!'

Ma questo argomento posizionale è ora richiesto. Se lo lasci fuori quando invochi questo programma, riceverai un errore sugli argomenti mancanti. Questo mi porta alla seconda parte della domanda originale. Matt Wilkie sembra voler un singolo argomento opzionale senza un'etichetta con nome (le etichette --option). Il mio suggerimento sarebbe quello di modificare il codice di cui sopra come segue:

...
parser.add_argument("a", nargs='?', default="check_string_for_empty")
...
if args.a == 'check_string_for_empty':
    print 'I can tell that no argument was given and I can deal with that here.'
elif args.a == 'magic.name':
    print 'You nailed it!'
else:
    print args.a

Potrebbe esserci una soluzione più elegante, ma funziona e è minimalista.


Nota l' Argparse Tutorial in Python HOWTOs . Parte dalla maggior parte degli esempi di base, come questo:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
args = parser.parse_args()
print(args.square**2)

e progredisce in quelli meno fondamentali.

C'è un esempio con scelta predefinita per un'opzione, come quello che viene chiesto:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbosity", type=int, choices=[0, 1, 2],
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
    print("the square of {} equals {}".format(args.square, answer))
elif args.verbosity == 1:
    print("{}^2 == {}".format(args.square, answer))
else:
    print(answer)

Per aggiungere a ciò che altri hanno dichiarato:

Di solito mi piace usare il parametro 'dest' per specificare un nome di variabile e quindi usare 'globals (). Update ()' per inserire tali variabili nello spazio dei nomi globale.

Uso:

$ python script.py -i "Hello, World!"

Codice:

...
parser.add_argument('-i', '--input', ..., dest='inputted_variable',...)
globals().update(vars(parser.parse_args()))
...
print(inputted_variable) # Prints "Hello, World!"




argparse