Jak czytać / przetwarzać argumenty wiersza poleceń?

Jestem pierwotnie programistą C. Widziałem wiele sztuczek i „hacków”, aby przeczytać wiele różnych argumentów.

W jaki sposób programiści Python mogą to zrobić?

Związane z

• Jaki jest najlepszy sposób przechwytywania / analizowania argumentów wiersza poleceń przekazanych do skryptu Python?
• Wdrażasz interfejsy wiersza polecenia w stylu „[polecenie] [akcja] [parametr]?
• Jak mogę przetwarzać argumenty wiersza poleceń w Pythonie?
• Jak sformatować pomocnicze argumenty pozycyjne przy użyciu optparse Pythona?

Kanoniczne rozwiązanie w standardowej bibliotece to argparse( dokumenty ):

Oto przykład:

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 obsługuje (między innymi):

• Wiele opcji w dowolnej kolejności.
• Krótkie i długie opcje.
• Wartości domyślne
• Generowanie komunikatu pomocy użytkowania.

import sys

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

sys.argv to lista zawierająca wszystkie argumenty przekazane do skryptu w wierszu poleceń.

Gruntownie,

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

Chodzę ewangelizując dla argparse, co jest lepsze z tych powodów .. zasadniczo:

(skopiowane z linku)

• moduł argparse może obsługiwać argumenty pozycyjne i opcjonalne, podczas gdy optparse może obsługiwać tylko argumenty opcjonalne

• Argparse nie jest dogmatyczny, jak powinien wyglądać interfejs wiersza poleceń - obsługiwane są opcje takie jak -file lub / file, podobnie jak wymagane opcje. Optparse odmawia obsługi tych funkcji, woląc czystość od praktyczności

• argparse produkuje bardziej pouczające komunikaty o użyciu, w tym użycie wiersza polecenia określone na podstawie argumentów, oraz komunikaty pomocy dla argumentów pozycyjnych i opcjonalnych. Moduł optparse wymaga napisania własnego ciągu użycia i nie ma możliwości wyświetlenia pomocy dla argumentów pozycyjnych.

• argparse obsługuje działania, które zużywają zmienną liczbę argumentów wiersza poleceń, podczas gdy optparse wymaga wcześniejszej znajomości dokładnej liczby argumentów (np. 1, 2 lub 3)

• argparse obsługuje parsery, które wysyłają do komend podrzędnych, podczas gdy optparse wymaga allow_interspersed_argsręcznego ustawienia i wykonania parsera

I mój osobisty faworyt:

• argparse pozwala na określenie parametrów typu i akcji add_argument() za pomocą prostych wywołań, podczas gdy optparse wymaga hakowania atrybutów klasy takich jak STORE_ACTIONSlub, CHECK_METHODSaby uzyskać poprawne sprawdzenie argumentów

Istnieje również argparsemoduł stdlib („ulepszenie” optparsemodułu stdlib ). Przykład ze wstępu do 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))

Stosowanie:

$ script.py 1 2 3 4
4

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

Jednym ze sposobów na to jest użycie sys.argv. Spowoduje to wydrukowanie nazwy skryptu jako pierwszego argumentu i wszystkich innych przekazanych mu parametrów.

import sys

for arg in sys.argv:
    print arg

Docopt biblioteka jest bardzo śliski. Tworzy argument argumentu na podstawie ciągu użycia aplikacji.

Np. Z pliku readopt 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)

Jeśli potrzebujesz czegoś szybkiego i niezbyt elastycznego

main.py:

import sys

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

Następnie uruchomić python main.py James Smith

w celu uzyskania następującego wyniku:

Cześć James Smith

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

Sam używam optparse, ale naprawdę podoba mi się kierunek, w którym podąża Simon Willison ze swoją niedawno wprowadzoną biblioteką optfunc . Działa przez:

„introspekcja definicji funkcji (w tym jej argumentów i ich wartości domyślnych) i wykorzystanie jej do skonstruowania analizatora składni argumentów wiersza poleceń.”

Na przykład ta definicja funkcji:

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

zamienia się w ten tekst pomocy optparse:

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

Lubię getopt z stdlib, np .:

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

Ostatnio pakuję coś podobnego do tego, aby rzeczy były mniej gadatliwe (np. Ukrywanie „-h”).

Pocoo za kliknięcie jest bardziej intuicyjna, wymaga mniej szablonowe, a jest co najmniej tak mocny jak argparse.

Jedyną słabością, jaką do tej pory napotkałem, jest to, że nie można dokonać wielu dostosowań stron pomocy, ale zwykle nie jest to wymagane, a docopt wydaje się być oczywistym wyborem.

Jak widać optparse „Moduł optparse jest przestarzały i nie będzie dalej rozwijany; rozwój będzie kontynuowany z modułem 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

Być może interesuje Cię mały moduł Pythona, który napisałem, aby jeszcze bardziej ułatwić obsługę argumentów wiersza poleceń (open source i swobodny w użyciu) - Commando

Polecam spojrzenie na docopt jako prostą alternatywę dla tych innych.

docopt to nowy projekt, który działa, analizując komunikat o użytkowaniu --help, zamiast wymagać od Ciebie implementacji wszystkiego samodzielnie. Musisz tylko umieścić komunikat o użyciu w formacie POSIX.

Jeszcze inną opcją jest argh . Opiera się na argparse i pozwala pisać takie rzeczy jak:

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

Automatycznie wygeneruje pomoc i tak dalej, a można użyć dekoratorów, aby zapewnić dodatkowe wskazówki na temat tego, jak powinna działać analiza arg.

Moje rozwiązanie to entrypoint2 . Przykład:

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

Tekst pomocy:

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