Come leggere / elaborare gli argomenti della riga di comando?
-
06-07-2019 - |
Domanda
Sono originariamente un programmatore C. Ho visto numerosi trucchi e "hack" " leggere molti argomenti diversi.
Quali sono alcuni dei modi in cui i programmatori Python possono farlo?
correlati
- Qual è il modo migliore per afferrare / analizzare gli argomenti della riga di comando passati a uno script Python?
- Implementazione di un "[comando] [azione] [parametro ] "Interfacce da riga di comando stile?
- Come posso elaborare gli argomenti della riga di comando in Python?
- Come posso formattare l'argomento posizionale per usare Python optparse?
Soluzione
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):
- Opzioni multiple in qualsiasi ordine.
- Opzioni corte e lunghe.
- Valori predefiniti.
- Generazione di un messaggio di aiuto per l'uso.
Altri suggerimenti
import sys
print("\n".join(sys.argv))
sys.argv
è un elenco che contiene tutti gli argomenti passati allo script dalla riga di comando.
In sostanza,
import sys
print(sys.argv[1:])
Basta andare in giro per l'evangelizzazione di argparse che è meglio per questi motivi .. essenzialmente:
(copiato dal link)
-
Il modulo argparse può gestire la posizione e argomenti opzionali, mentre optparse può gestire solo facoltativo argomenti
-
argparse non è dogmatico quale è l'interfaccia della riga di comando dovrebbe apparire come - opzioni come -file o / file sono supportati, così come sono opzioni richieste. Optparse si rifiuta di supportare queste funzionalità, preferendo purezza sulla praticità
-
argparse produce di più messaggi informativi sull'utilizzo, incluso utilizzo della riga di comando determinato da argomenti e messaggi di aiuto per sia posizionale che facoltativo argomenti. Il modulo optparse richiede di scrivere il proprio utilizzo stringa e non ha modo di essere visualizzato aiuto per argomenti posizionali.
-
argparse supporta l'azione che consumare un numero variabile di args da riga di comando, mentre optparse richiede che il numero esatto di gli argomenti (ad es. 1, 2 o 3) sono noti in anticipo
-
argparse supporta i parser che inviare a sottocomandi, mentre optparse richiede l'impostazione
allow_interspersed_args
e facendo il invio parser manualmente
E il mio preferito personale:
- argparse consente il tipo e
parametri di azione su
add_argument ()
da specificare con semplice callable, mentre optparse richiede hacking di attributi di classe comeSTORE_ACTIONS
oCHECK_METHODS
per ottenere controllo argomento corretto
C'è anche argparse
modulo stdlib (un " ; impovement " sul modulo optparse
di stdlib). Esempio da l'introduzione a 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))
Utilizzo:
$ 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 passi.
import sys
for arg in sys.argv:
print arg
La libreria docopt è 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 esegui 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 il suo optfunc libreria. Funziona da:
" introspezione di una funzione definizione (compresi i suoi argomenti e i loro valori predefiniti) e utilizzo quello per costruire una riga di comando parser di argomenti. "
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) "
Il Pocoo di Pocoo è più intuitivo, richiede meno platee 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 è.
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 guardare 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, e puoi usare i decoratori per fornire una guida extra su come dovrebbe funzionare l'arg-parsing.
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
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 di aiuto:
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