Підручник Argparse

автор:

Tshepang Mbambo

Цей підручник призначений для ознайомлення з argparse, рекомендованим модулем аналізу командного рядка в стандартній бібліотеці Python.

Примітка

There are two other modules that fulfill the same task, namely getopt (an equivalent for getopt() from the C language) and the deprecated optparse. Note also that argparse is based on optparse, and therefore very similar in terms of usage.

Концепції

Давайте покажемо тип функціональності, який ми збираємося досліджувати в цьому вступному посібнику, використовуючи команду ls:

$ ls
cpython  devguide  prog.py  pypy  rm-unused-function.patch
$ ls pypy
ctypes_configure  demo  dotviewer  include  lib_pypy  lib-python ...
$ ls -l
total 20
drwxr-xr-x 19 wena wena 4096 Feb 18 18:51 cpython
drwxr-xr-x  4 wena wena 4096 Feb  8 12:04 devguide
-rwxr-xr-x  1 wena wena  535 Feb 19 00:05 prog.py
drwxr-xr-x 14 wena wena 4096 Feb  7 00:59 pypy
-rw-r--r--  1 wena wena  741 Feb 18 01:01 rm-unused-function.patch
$ ls --help
Usage: ls [OPTION]... [FILE]...
List information about the FILEs (the current directory by default).
Sort entries alphabetically if none of -cftuvSUX nor --sort is specified.
...

Кілька понять, які ми можемо вивчити з чотирьох команд:

• Команда ls корисна, якщо її запускати без жодних опцій. За замовчуванням відображається вміст поточного каталогу.

• Якщо ми хочемо вийти за межі того, що він надає за замовчуванням, ми розповідаємо про це трохи більше. У цьому випадку ми хочемо, щоб він відображав інший каталог, pypy. Ми вказали так званий позиційний аргумент. Це названо так, тому що програма повинна знати, що робити зі значенням, виключно на основі того, де воно з’являється в командному рядку. Ця концепція більш актуальна для такої команди, як cp, основним використанням якої є cp SRC DEST. Перша позиція — це те, що ви хочете скопіювати, а друга позиція — це куди ви хочете це скопіювати.

• Тепер, скажімо, ми хочемо змінити поведінку програми. У нашому прикладі ми показуємо більше інформації для кожного файлу, а не просто показуємо імена файлів. -l у цьому випадку відомий як необов’язковий аргумент.

• Це фрагмент довідкового тексту. Це дуже корисно, оскільки ви можете натрапити на програму, якою ніколи раніше не користувалися, і зрозуміти, як вона працює, просто прочитавши довідковий текст.

Основи

Почнемо з дуже простого прикладу, який (майже) нічого не робить:

import argparse
parser = argparse.ArgumentParser()
parser.parse_args()

Нижче наведено результат виконання коду:

$ python prog.py
$ python prog.py --help
usage: prog.py [-h]

options:
  -h, --help  show this help message and exit
$ python prog.py --verbose
usage: prog.py [-h]
prog.py: error: unrecognized arguments: --verbose
$ python prog.py foo
usage: prog.py [-h]
prog.py: error: unrecognized arguments: foo

Ось що відбувається:

• Запуск сценарію без будь-яких параметрів призводить до того, що стандартний вивід нічого не відображає. Не дуже корисно.

• Другий починає відображати корисність модуля argparse. Ми майже нічого не зробили, але вже отримуємо гарне довідкове повідомлення.

• Опція --help, яку також можна скоротити до -h, є єдиною опцією, яку ми отримуємо безкоштовно (тобто її не потрібно вказувати). Вказівка будь-чого іншого призводить до помилки. Але навіть тоді ми отримуємо корисне повідомлення про використання, також безкоштовно.

Представлення позиційних аргументів

Приклад:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("echo")
args = parser.parse_args()
print(args.echo)

І запуск коду:

$ python prog.py
usage: prog.py [-h] echo
prog.py: error: the following arguments are required: echo
$ python prog.py --help
usage: prog.py [-h] echo

positional arguments:
  echo

options:
  -h, --help  show this help message and exit
$ python prog.py foo
foo

Ось що відбувається:

• We’ve added the add_argument() method, which is what we use to specify which command-line options the program is willing to accept. In this case, I’ve named it echo so that it’s in line with its function.

• Для виклику нашої програми тепер потрібно вказати опцію.

• The parse_args() method actually returns some data from the options specified, in this case, echo.

• Змінна є певною формою «магії», яку argparse виконує безкоштовно (тобто не потрібно вказувати, у якій змінній це значення зберігається). Ви також помітите, що його назва відповідає рядковому аргументу, наданому методу, echo.

Зауважте, однак, що, незважаючи на те, що екран довідки виглядає гарно і все таке, наразі він не такий корисний, як міг би бути. Наприклад, ми бачимо, що ми отримали echo як позиційний аргумент, але ми не знаємо, що він робить, окрім здогадок або читання вихідного коду. Отже, давайте зробимо це трохи кориснішим:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("echo", help="echo the string you use here")
args = parser.parse_args()
print(args.echo)

І отримуємо:

$ python prog.py -h
usage: prog.py [-h] echo

positional arguments:
  echo        echo the string you use here

options:
  -h, --help  show this help message and exit

А тепер як щодо того, щоб зробити щось ще корисніше:

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

Нижче наведено результат виконання коду:

$ python prog.py 4
Traceback (most recent call last):
  File "prog.py", line 5, in <module>
    print(args.square**2)
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'

Це пішло не так добре. Це тому, що argparse розглядає надані нами параметри як рядки, якщо ми не вкажемо інше. Отже, давайте скажемо argparse розглядати цей вхід як ціле число:

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

Нижче наведено результат виконання коду:

$ python prog.py 4
16
$ python prog.py four
usage: prog.py [-h] square
prog.py: error: argument square: invalid int value: 'four'

Це пройшло добре. Програма тепер навіть допомагає завершити роботу, якщо неправильно введено неправильні дані, перш ніж продовжити.

Представляємо додаткові аргументи

Досі ми гралися з позиційними аргументами. Давайте розглянемо, як додати необов’язкові:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--verbosity", help="increase output verbosity")
args = parser.parse_args()
if args.verbosity:
    print("verbosity turned on")

І вихід:

$ python prog.py --verbosity 1
verbosity turned on
$ python prog.py
$ python prog.py --help
usage: prog.py [-h] [--verbosity VERBOSITY]

options:
  -h, --help            show this help message and exit
  --verbosity VERBOSITY
                        increase output verbosity
$ python prog.py --verbosity
usage: prog.py [-h] [--verbosity VERBOSITY]
prog.py: error: argument --verbosity: expected one argument

Ось що відбувається:

• Програма написана таким чином, щоб щось відображати, коли вказано --verbosity, і нічого не відображати, якщо ні.

• To show that the option is actually optional, there is no error when running the program without it. Note that by default, if an optional argument isn’t used, the relevant variable, in this case args.verbosity, is given None as a value, which is the reason it fails the truth test of the if statement.

• Довідкове повідомлення дещо інше.

• При використанні опції --verbosity необхідно також вказати певне значення, будь-яке значення.

Наведений вище приклад приймає довільні цілі значення для --verbosity, але для нашої простої програми насправді корисними є лише два значення, True або False. Давайте відповідно змінимо код:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--verbose", help="increase output verbosity",
                    action="store_true")
args = parser.parse_args()
if args.verbose:
    print("verbosity turned on")

І вихід:

$ python prog.py --verbose
verbosity turned on
$ python prog.py --verbose 1
usage: prog.py [-h] [--verbose]
prog.py: error: unrecognized arguments: 1
$ python prog.py --help
usage: prog.py [-h] [--verbose]

options:
  -h, --help  show this help message and exit
  --verbose   increase output verbosity

Ось що відбувається:

• The option is now more of a flag than something that requires a value. We even changed the name of the option to match that idea. Note that we now specify a new keyword, action, and give it the value "store_true". This means that, if the option is specified, assign the value True to args.verbose. Not specifying it implies False.

• Він скаржиться, коли ви вказуєте значення, у справжньому дусі того, чим насправді є прапори.

• Зверніть увагу на інший текст довідки.

Короткі варіанти

Якщо ви знайомі з використанням командного рядка, ви помітите, що я ще не торкався теми коротких версій параметрів. Це досить просто:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbose", help="increase output verbosity",
                    action="store_true")
args = parser.parse_args()
if args.verbose:
    print("verbosity turned on")

І ось:

$ python prog.py -v
verbosity turned on
$ python prog.py --help
usage: prog.py [-h] [-v]

options:
  -h, --help     show this help message and exit
  -v, --verbose  increase output verbosity

Зверніть увагу, що нова здатність також відображається в тексті довідки.

Поєднання позиційних і необов’язкових аргументів

Наша програма постійно ускладнюється:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbose", action="store_true",
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbose:
    print(f"the square of {args.square} equals {answer}")
else:
    print(answer)

А тепер вихід:

$ python prog.py
usage: prog.py [-h] [-v] square
prog.py: error: the following arguments are required: square
$ python prog.py 4
16
$ python prog.py 4 --verbose
the square of 4 equals 16
$ python prog.py --verbose 4
the square of 4 equals 16

• Ми повернули позиційний аргумент, тому скарга.

• Зауважте, що порядок не має значення.

Як щодо того, щоб ми повернули цій нашій програмі можливість мати кілька значень докладності та фактично отримати їх використання:

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,
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
    print(f"the square of {args.square} equals {answer}")
elif args.verbosity == 1:
    print(f"{args.square}^2 == {answer}")
else:
    print(answer)

І вихід:

$ python prog.py 4
16
$ python prog.py 4 -v
usage: prog.py [-h] [-v VERBOSITY] square
prog.py: error: argument -v/--verbosity: expected one argument
$ python prog.py 4 -v 1
4^2 == 16
$ python prog.py 4 -v 2
the square of 4 equals 16
$ python prog.py 4 -v 3
16

Усі вони виглядають добре, крім останнього, який виявляє помилку в нашій програмі. Давайте виправимо це, обмеживши значення, які може приймати параметр --verbosity:

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(f"the square of {args.square} equals {answer}")
elif args.verbosity == 1:
    print(f"{args.square}^2 == {answer}")
else:
    print(answer)

І вихід:

$ python prog.py 4 -v 3
usage: prog.py [-h] [-v {0,1,2}] square
prog.py: error: argument -v/--verbosity: invalid choice: 3 (choose from 0, 1, 2)
$ python prog.py 4 -h
usage: prog.py [-h] [-v {0,1,2}] square

positional arguments:
  square                display a square of a given number

options:
  -h, --help            show this help message and exit
  -v {0,1,2}, --verbosity {0,1,2}
                        increase output verbosity

Зауважте, що зміна також відображається як у повідомленні про помилку, так і в рядку довідки.

Тепер давайте використаємо інший підхід гри з багатослівністю, який є досить поширеним. Це також відповідає тому, як виконуваний файл CPython обробляє власний аргумент багатослівності (перевірте вихід python --help):

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

Ми запровадили ще одну дію, «підрахунок», щоб підрахувати кількість повторень певних параметрів.

$ python prog.py 4
16
$ python prog.py 4 -v
4^2 == 16
$ python prog.py 4 -vv
the square of 4 equals 16
$ python prog.py 4 --verbosity --verbosity
the square of 4 equals 16
$ python prog.py 4 -v 1
usage: prog.py [-h] [-v] square
prog.py: error: unrecognized arguments: 1
$ python prog.py 4 -h
usage: prog.py [-h] [-v] square

positional arguments:
  square           display a square of a given number

options:
  -h, --help       show this help message and exit
  -v, --verbosity  increase output verbosity
$ python prog.py 4 -vvv
16

• Так, тепер це більше позначка (схожа на action="store_true") у попередній версії нашого сценарію. Це має пояснити скаргу.

• Він також поводиться подібно до дії «store_true».

• Тепер ось демонстрація того, що дає дія «підрахунок». Ви, напевно, бачили таке використання раніше.

• І якщо ви не вкажете прапорець -v, цей прапорець вважатиметься таким, що має значення None.

• Як і слід було очікувати, вказавши довгу форму прапора, ми повинні отримати той самий результат.

• На жаль, результати нашої довідки не надто інформативні щодо нових можливостей, які отримав наш сценарій, але це завжди можна виправити, покращивши документацію для нашого сценарію (наприклад, за допомогою аргументу ключового слова help).

• Цей останній вихід виявляє помилку в нашій програмі.

Виправимо:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbosity", action="count",
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2

# bugfix: replace == with >=
if args.verbosity >= 2:
    print(f"the square of {args.square} equals {answer}")
elif args.verbosity >= 1:
    print(f"{args.square}^2 == {answer}")
else:
    print(answer)

І ось що це дає:

$ python prog.py 4 -vvv
the square of 4 equals 16
$ python prog.py 4 -vvvv
the square of 4 equals 16
$ python prog.py 4
Traceback (most recent call last):
  File "prog.py", line 11, in <module>
    if args.verbosity >= 2:
TypeError: '>=' not supported between instances of 'NoneType' and 'int'

• Перший вихід пройшов добре та виправляє помилку, яку ми мали раніше. Тобто ми хочемо, щоб будь-яке значення >= 2 було якомога детальнішим.

• Третій вихід не дуже хороший.

Давайте виправимо цю помилку:

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

Ми щойно представили ще одне ключове слово, default. Ми встановили для нього значення 0, щоб зробити його порівнянним з іншими значеннями int. Пам’ятайте, що за замовчуванням, якщо необов’язковий аргумент не вказано, він отримує значення None, яке не можна порівняти зі значенням int (отже, виняток TypeError).

і:

$ python prog.py 4
16

Ви можете зайти досить далеко лише з тим, що ми навчилися досі, і ми лише подряпали поверхню. Модуль argparse дуже потужний, і ми вивчимо його трохи більше, перш ніж закінчити цей підручник.

Ставши трохи більш просунутим

Що, якби ми захотіли розширити нашу крихітну програму для виконання інших ступенів, а не лише квадратів:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
parser.add_argument("-v", "--verbosity", action="count", default=0)
args = parser.parse_args()
answer = args.x**args.y
if args.verbosity >= 2:
    print(f"{args.x} to the power {args.y} equals {answer}")
elif args.verbosity >= 1:
    print(f"{args.x}^{args.y} == {answer}")
else:
    print(answer)

Вихід:

$ python prog.py
usage: prog.py [-h] [-v] x y
prog.py: error: the following arguments are required: x, y
$ python prog.py -h
usage: prog.py [-h] [-v] x y

positional arguments:
  x                the base
  y                the exponent

options:
  -h, --help       show this help message and exit
  -v, --verbosity
$ python prog.py 4 2 -v
4^2 == 16

Зверніть увагу, що досі ми використовували рівень докладності, щоб змінити текст, який відображається. Натомість у наступному прикладі використовується рівень детальності для відображення більше тексту:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
parser.add_argument("-v", "--verbosity", action="count", default=0)
args = parser.parse_args()
answer = args.x**args.y
if args.verbosity >= 2:
    print(f"Running '{__file__}'")
if args.verbosity >= 1:
    print(f"{args.x}^{args.y} == ", end="")
print(answer)

Вихід:

$ python prog.py 4 2
16
$ python prog.py 4 2 -v
4^2 == 16
$ python prog.py 4 2 -vv
Running 'prog.py'
4^2 == 16

Specifying ambiguous arguments

When there is ambiguity in deciding whether an argument is positional or for an argument, -- can be used to tell parse_args() that everything after that is a positional argument:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-n', nargs='+')
>>> parser.add_argument('args', nargs='*')

>>> # ambiguous, so parse_args assumes it's an option
>>> parser.parse_args(['-f'])
usage: PROG [-h] [-n N [N ...]] [args ...]
PROG: error: unrecognized arguments: -f

>>> parser.parse_args(['--', '-f'])
Namespace(args=['-f'], n=None)

>>> # ambiguous, so the -n option greedily accepts arguments
>>> parser.parse_args(['-n', '1', '2', '3'])
Namespace(args=[], n=['1', '2', '3'])

>>> parser.parse_args(['-n', '1', '--', '2', '3'])
Namespace(args=['2', '3'], n=['1'])

Конфліктні варіанти

So far, we have been working with two methods of an argparse.ArgumentParser instance. Let’s introduce a third one, add_mutually_exclusive_group(). It allows for us to specify options that conflict with each other. Let’s also change the rest of the program so that the new functionality makes more sense: we’ll introduce the --quiet option, which will be the opposite of the --verbose one:

import argparse

parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument("-v", "--verbose", action="store_true")
group.add_argument("-q", "--quiet", action="store_true")
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
args = parser.parse_args()
answer = args.x**args.y

if args.quiet:
    print(answer)
elif args.verbose:
    print(f"{args.x} to the power {args.y} equals {answer}")
else:
    print(f"{args.x}^{args.y} == {answer}")

Наша програма стала простішою, і ми втратили деякі функції заради демонстрації. У будь-якому випадку, ось результат:

$ python prog.py 4 2
4^2 == 16
$ python prog.py 4 2 -q
16
$ python prog.py 4 2 -v
4 to the power 2 equals 16
$ python prog.py 4 2 -vq
usage: prog.py [-h] [-v | -q] x y
prog.py: error: argument -q/--quiet: not allowed with argument -v/--verbose
$ python prog.py 4 2 -v --quiet
usage: prog.py [-h] [-v | -q] x y
prog.py: error: argument -q/--quiet: not allowed with argument -v/--verbose

Це повинно бути легко слідкувати. Я додав цей останній вихід, щоб ви могли бачити, яку гнучкість ви отримуєте, тобто змішування параметрів довгої форми з опціями короткої.

Перш ніж завершити, ви, ймовірно, захочете повідомити своїм користувачам головну мету вашої програми, на випадок, якщо вони не знають:

import argparse

parser = argparse.ArgumentParser(description="calculate X to the power of Y")
group = parser.add_mutually_exclusive_group()
group.add_argument("-v", "--verbose", action="store_true")
group.add_argument("-q", "--quiet", action="store_true")
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
args = parser.parse_args()
answer = args.x**args.y

if args.quiet:
    print(answer)
elif args.verbose:
    print(f"{args.x} to the power {args.y} equals {answer}")
else:
    print(f"{args.x}^{args.y} == {answer}")

Зверніть увагу на невелику різницю в тексті використання. Зверніть увагу на [-v | -q], який говорить нам, що ми можемо використовувати -v або -q, але не обидва одночасно:

$ python prog.py --help
usage: prog.py [-h] [-v | -q] x y

calculate X to the power of Y

positional arguments:
  x              the base
  y              the exponent

options:
  -h, --help     show this help message and exit
  -v, --verbose
  -q, --quiet

How to translate the argparse output

The output of the argparse module such as its help text and error messages are all made translatable using the gettext module. This allows applications to easily localize messages produced by argparse. See also Інтернаціоналізація ваших програм і модулів.

For instance, in this argparse output:

$ python prog.py --help
usage: prog.py [-h] [-v | -q] x y

calculate X to the power of Y

positional arguments:
  x              the base
  y              the exponent

options:
  -h, --help     show this help message and exit
  -v, --verbose
  -q, --quiet

The strings usage:, positional arguments:, options: and show this help message and exit are all translatable.

In order to translate these strings, they must first be extracted into a .po file. For example, using Babel, run this command:

$ pybabel extract -o messages.po /usr/lib/python3.12/argparse.py

This command will extract all translatable strings from the argparse module and output them into a file named messages.po. This command assumes that your Python installation is in /usr/lib.

You can find out the location of the argparse module on your system using this script:

import argparse
print(argparse.__file__)

Once the messages in the .po file are translated and the translations are installed using gettext, argparse will be able to display the translated messages.

To translate your own strings in the argparse output, use gettext.

Custom type converters

The argparse module allows you to specify custom type converters for your command-line arguments. This allows you to modify user input before it’s stored in the argparse.Namespace. This can be useful when you need to pre-process the input before it is used in your program.

When using a custom type converter, you can use any callable that takes a single string argument (the argument value) and returns the converted value. However, if you need to handle more complex scenarios, you can use a custom action class with the action parameter instead.

For example, let’s say you want to handle arguments with different prefixes and process them accordingly:

import argparse

parser = argparse.ArgumentParser(prefix_chars='-+')

parser.add_argument('-a', metavar='<value>', action='append',
                    type=lambda x: ('-', x))
parser.add_argument('+a', metavar='<value>', action='append',
                    type=lambda x: ('+', x))

args = parser.parse_args()
print(args)

Вихід:

$ python prog.py -a value1 +a value2
Namespace(a=[('-', 'value1'), ('+', 'value2')])

In this example, we:

• Created a parser with custom prefix characters using the prefix_chars parameter.

• Defined two arguments, -a and +a, which used the type parameter to create custom type converters to store the value in a tuple with the prefix.

Without the custom type converters, the arguments would have treated the -a and +a as the same argument, which would have been undesirable. By using custom type converters, we were able to differentiate between the two arguments.

Висновок

Модуль argparse пропонує набагато більше, ніж показано тут. Його документи досить докладні та ретельні та повні прикладів. Пройшовши цей підручник, ви повинні легко засвоїти їх, не відчуваючи себе приголомшеними.