Potrzebny prosty przykładowy argument: 1 argument, 3 wyniki

Dokumentacja dla argparse moduł Pythona , podczas gdy doskonała Jestem pewien, jest zbyt dużo dla mój malutki Początkujący mózg do uchwycenia chwili. Nie muszę robić matematyki w wierszu poleceń ani mieszać się z formatowaniem linii na ekranie ani zmieniać znaków opcji. Wszystko, co chcę zrobić, to „Jeśli arg to A, zrób to, jeśli B to zrób, jeśli żadne z powyższych nie pokaże pomocy i wyjdź” .

Moje rozumienie pierwotnego pytania jest dwojakie. Po pierwsze, jeśli chodzi o najprostszy możliwy przykładowy argument, jestem zaskoczony, że go tutaj nie widziałem. Oczywiście, aby być śmiertelnie prostym, wszystko to jest również kosztowne z niewielką mocą, ale może zacząć.

import argparse

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

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

Ale ten argument pozycyjny jest teraz wymagany. Jeśli pominiesz to podczas wywoływania tego programu, pojawi się błąd dotyczący brakujących argumentów. To prowadzi mnie do drugiej części pierwotnego pytania. Wydaje się, że Matt Wilkie chce pojedynczego opcjonalnego argumentu bez nazwanej etykiety (etykiety opcji). Moją sugestią byłoby zmodyfikowanie powyższego kodu w następujący sposób:

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

Może być bardziej eleganckie rozwiązanie, ale działa i jest minimalistyczne.

Oto sposób, w jaki to robię argparse(z wieloma argumentami):

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 będzie słownikiem zawierającym argumenty:

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

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

W twoim przypadku wystarczy dodać tylko jeden argument.

argparseDokumentacja jest dość dobre, ale pomija kilka przydatnych informacji, które mogą nie być oczywiste. (@Diego Navarro już o tym wspomniał, ale postaram się nieco rozwinąć jego odpowiedź). Podstawowe użycie jest następujące:

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

Obiekt, z którego wracasz, parse_args()to obiekt „Przestrzeń nazw”: Obiekt, którego zmienne składowe są nazwane na podstawie argumentów wiersza poleceń. NamespaceCelem jest jak masz dostęp do swoich argumentów i wartości związanych z nimi:

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

(Zauważ, że argparsezastępuje „-” w nazwach argumentów podkreśleniami podczas nazywania zmiennych).

W wielu sytuacjach możesz chcieć użyć argumentów po prostu jako flag, które nie przyjmują żadnej wartości. Możesz dodać te w argparse w następujący sposób:

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

Powyższe spowoduje utworzenie zmiennych o nazwach odpowiednio „foo” o wartości True i „no_foo” o wartości False:

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

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

Pamiętaj również, że możesz dodać opcję „wymagane” podczas dodawania argumentu:

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

W ten sposób, jeśli pominiesz ten argument w wierszu poleceń argparse, powie ci, że go brakuje i zatrzymasz wykonywanie skryptu.

Na koniec zauważ, że możliwe jest stworzenie struktury dyktowania twoich argumentów za pomocą varsfunkcji, jeśli to ułatwi ci życie.

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

Jak widać, varszwraca dykton z nazwami argumentów jako kluczami i ich wartościami jako, er, wartości.

Istnieje wiele innych opcji i rzeczy, które możesz zrobić, ale powinno to obejmować najważniejsze, najczęstsze scenariusze użycia.

Matt pyta o parametry pozycyjne w argparse i zgadzam się, że brakuje dokumentacji Pythona w tym aspekcie. Nie ma jednego kompletnego przykładu na nieparzystych stronach ~ 20, które pokazują zarówno analizę, jak i użycie parametrów pozycyjnych .

Żadna z pozostałych odpowiedzi tutaj nie pokazuje pełnego przykładu parametrów pozycyjnych, więc oto kompletny przykład:

# tested with python 2.7.1
import argparse

parser = argparse.ArgumentParser(description="An argparse example")

parser.add_argument('action', help='The action to take (e.g. install, remove, etc.)')
parser.add_argument('foo-bar', help='Hyphens are cumbersome in positional arguments')

args = parser.parse_args()

if args.action == "install":
    print("You asked for installation")
else:
    print("You asked for something other than installation")

# The following do not work:
# print(args.foo-bar)
# print(args.foo_bar)

# But this works:
print(getattr(args, 'foo-bar'))

Rzeczą, która mnie odrzuciła, jest to, że argparse przekształci nazwany argument „--foo-bar” na „foo_bar”, ale parametr pozycyjny o nazwie „foo-bar” pozostanie jako „foo-bar”, dzięki czemu mniej oczywiste jest, jak użyj go w swoim programie.

Zwróć uwagę na dwie linie na końcu mojego przykładu - żaden z nich nie będzie działał, aby uzyskać wartość parametru pozycyjnego foo-bar. Pierwszy jest oczywiście błędny (jest to wyrażenie arytmetyczne args.foo minus pasek), ale drugi też nie działa:

AttributeError: 'Namespace' object has no attribute 'foo_bar'

Jeśli chcesz użyć tego foo-baratrybutu, musisz go użyć getattr, jak widać w ostatnim wierszu mojego przykładu. Dziwne jest to, że jeśli spróbujesz dest=foo_barzmienić nazwę właściwości na coś, co jest łatwiej dostępne, otrzymasz naprawdę dziwny komunikat o błędzie:

ValueError: dest supplied twice for positional argument

Oto jak działa powyższy przykład:

$ python test.py
usage: test.py [-h] action foo-bar
test.py: error: too few arguments

$ python test.py -h
usage: test.py [-h] action foo-bar

An argparse example

positional arguments:
  action      The action to take (e.g. install, remove, etc.)
  foo-bar     Hyphens are cumbersome in positional arguments

optional arguments:
  -h, --help  show this help message and exit

$ python test.py install foo
You asked for installation
foo

Jeszcze jedno wprowadzenie podsumowujące, zainspirowane tym postem .

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
    #

Argumenty są definiowane za pomocą kombinacji następujących elementów:

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

Typowe opcje to:

• help : opis tego argumentu, gdy --helpjest używany.
• default : wartość domyślna, jeśli argument jest pominięty.
• wpisz : jeśli oczekujesz a floatlub int(inaczej jest str).
• dest : nadaj flagę inną nazwę (np '-x', '--long-name', dest='longName'.).
  Uwaga: domyślnie--long-name można uzyskać dostęp za pomocąargs.long_name
• akcja : dla specjalnego postępowania z niektórymi argumentami
  • store_true, store_false: dla argumentów logicznych
    '--foo', action='store_true' => args.foo == True
  • store_const: do użycia z opcjąconst
'--foo', action='store_const', const=42 => args.foo == 42
  • count: dla powtarzających się opcji, jak w./myscript.py -vv
'-v', action='count' => args.v == 2
  • append: dla powtarzających się opcji, jak w./myscript.py --foo 1 --foo 2
'--foo', action='append' => args.foo == ['1', '2']
• wymagany : jeśli flaga jest wymagana lub argument pozycyjny nie jest wymagany.
• nargs : dla flagi do przechwytywania N argumentów
  ./myscript.py --foo a b => args.foo = ['a', 'b']
• opcje : w celu ograniczenia możliwych danych wejściowych (określ jako listę ciągów znaków lub ints jeśli type=int).

Zwróć uwagę na samouczek Argparse w Pythonie HOWTO . Zaczyna się od najbardziej podstawowych przykładów, takich jak ten:

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)

i przechodzi do mniej podstawowych.

Istnieje przykład z predefiniowanym wyborem opcji, na przykład pytanie:

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)

Oto, co wymyśliłem w moim projekcie edukacyjnym, głównie dzięki @DMH ...

Kod demonstracyjny:

import argparse

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-f', '--flag', action='store_true', default=False)  # can 'store_false' for no-xxx flags
    parser.add_argument('-r', '--reqd', required=True)
    parser.add_argument('-o', '--opt', default='fallback')
    parser.add_argument('arg', nargs='*') # use '+' for 1 or more args (instead of 0 or more)
    parsed = parser.parse_args()
    # NOTE: args with '-' have it replaced with '_'
    print('Result:',  vars(parsed))
    print('parsed.reqd:', parsed.reqd)

if __name__ == "__main__":
    main()

To mogło ewoluować i jest dostępne online: command-line.py

Skrypt do ćwiczenia tego kodu: Command-line-demo.sh

Możesz także użyć plac (otoki wokół argparse).

Jako bonus generuje dokładne instrukcje pomocy - patrz poniżej.

Przykładowy skrypt:

#!/usr/bin/env python3
def main(
    arg: ('Argument with two possible values', 'positional', None, None, ['A', 'B'])
):
    """General help for application"""
    if arg == 'A':
        print("Argument has value A")
    elif arg == 'B':
        print("Argument has value B")

if __name__ == '__main__':
    import plac
    plac.call(main)

Przykładowe dane wyjściowe:

Nie podano argumentów - example.py :

usage: example.py [-h] {A,B}
example.py: error: the following arguments are required: arg

Podano nieoczekiwany argument - example.py C :

usage: example.py [-h] {A,B}
example.py: error: argument arg: invalid choice: 'C' (choose from 'A', 'B')

Podano poprawny argument - example.py A :

Argument has value A

Pełne menu pomocy (generowane automatycznie) - example.py -h :

usage: example.py [-h] {A,B}

General help for application

positional arguments:
  {A,B}       Argument with two possible values

optional arguments:
  -h, --help  show this help message and exit

Krótkie wyjaśnienie:

Nazwa argumentu zwykle jest równa nazwie parametru ( arg).

Adnotacja krotkowa po argparametrze ma następujące znaczenie:

• Opis ( Argument with two possible values)
• Rodzaj argumentu - jeden z „flag”, „opcja” lub „pozycyjny” ( positional)
• Skrót ( None)
• Rodzaj wartości argumentu - np. float, string ( None)
• Ograniczony zestaw opcji ( ['A', 'B'])

Dokumentacja:

Aby dowiedzieć się więcej o korzystaniu z plac, sprawdź jego świetną dokumentację:

Plac: Łatwa analiza linii poleceń

Aby dodać do tego, co stwierdzili inni:

Zwykle lubię używać parametru „dest”, aby określić nazwę zmiennej, a następnie użyć „globals (). Update ()”, aby umieścić te zmienne w globalnej przestrzeni nazw.

Stosowanie:

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

Kod:

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

Naprawdę prostym sposobem użycia argparse i zmiany przełączników „-h” / „--help” w celu wyświetlenia własnych instrukcji pomocy dla kodu osobistego jest ustawienie domyślnej pomocy na False, można również dodać tyle dodatkowych .add_arguments, ile chcesz :

import argparse

parser = argparse.ArgumentParser(add_help=False)

parser.add_argument('-h', '--help', action='help',
                help='To run this script please provide two arguments')
parser.parse_args()

Uruchom: python test.py -h

Wynik:

usage: test.py [-h]

optional arguments:
  -h, --help  To run this script please provide two arguments

Najprostsza odpowiedź!

PS, ten, który napisał dokument o argparse, jest głupi

kod python:

import argparse
parser = argparse.ArgumentParser(description='')
parser.add_argument('--o_dct_fname',type=str)
parser.add_argument('--tp',type=str)
parser.add_argument('--new_res_set',type=int)
args = parser.parse_args()
o_dct_fname = args.o_dct_fname
tp = args.tp
new_res_set = args.new_res_set

uruchomiony kod

python produce_result.py --o_dct_fname o_dct --tp father_child --new_res_set 1