Come leggere / elaborare gli argomenti della riga di comando?

StackOverflow https://stackoverflow.com/questions/1009860

È stato utile?

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 come STORE_ACTIONS o CHECK_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) "

Come puoi vedere optparse " Il modulo optparse è obsoleto con e non sarà ulteriormente sviluppato; lo sviluppo continuerà con il argparse . "

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
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top