Как добавить аргументы командной строки в скрипт Python

Cmd.cmdloop(intro=none):

Метод Cmd.cmdloop() неоднократно выдает приглашение командной строки, принимает ввод, анализирует начальный префикс полученного ввода и отправляет методы действия, передавая им остаток строки в качестве аргумента.

Необязательный аргумент-это баннер или строка ввода, которая должна быть выдана перед первым приглашением. Он переопределяет атрибут Cmd.intro.

Если импортирован модуль readline, то ввод автоматически унаследует редактирование списка истории в стиле bash. Например, клавиша Ctrl-P прокручивает назад к последней команде, Ctrl-N переходит к следующей, Ctrl-F перемещает курсор вправо, Ctrl-B перемещает курсор влево и т. д.).

Конец файла при вводе передается обратно как строка ‘EOF’.

Экземпляр интерпретатора распознает имя команды foo тогда и только тогда, когда у него есть метод .do_foo(). Как особый случай, строка, начинающаяся с символа ‘?’ отправляется методу do_help().

Метод Cmd.cmdloop() возвращает, когда метод Cmd.postcmd() возвращает значение True. Аргумент stop для метода Cmd.postcmd() – это возвращаемое значение команды из соответствующего метода .do_*().

Cmd.intro:

Атрибут Cmd.intro – это строка, которую нужно оформить как заставку или баннер. Может быть отменено путем передачи аргумента методу Cmd.cmdloop().

‘count’ — счётчик количества экземпляров опции

Изменим наш код:

parser.add_argument('-1', '--one', action='count', help='This will be option One')

И вызовем его с одним ключём:

$ ./args.py -1
Namespace(one=1)

Или двумя:

$ ./args.py -11
Namespace(one=2)

Пример использования — указать уровень «подробности» режима verbosity, когда можно указать -v, -vv или -vvv.

‘store_const’ — сохраняет значение, заданное ключём const;

Изменим наш код:

parser.add_argument(‘-1’, ‘—one’, action=’store_const’, const=’1′, help=’This will be option One’)

$ ./args.py --one
Namespace(one='1')

Удобно использовать для передачи различных флагов.

Например:

#!/usr/bin/env python

import argparse

parser = argparse.ArgumentParser()

parser.add_argument('-1', '--one', action='store_const', const='1', help='This will be option One')

print parser.parse_args()

if parser.parse_args().one == '1':
        print 'That's it!'
else:
        print 'Here is nothing :-('

Вызовем скрипт с опцией –one:

$ ./args.py --one
Namespace(one='1')
That's it!

И без неё:

$ ./args.py
Namespace(one=None)
Here is nothing :-(

‘store_true’ или ‘store_false’ — сохраняет значение true или false

Похож по действию на store_const, с той разницей что хранит только True или False.

Изменим код:

parser.add_argument('-1', '--one', action='store_true', help='This will be option One')

Результат:

$ ./args.py -1
Namespace(one=True)

Тогда как вызов без опции –one задаст значение False:

$ ./args.py
Namespace(one=False)

И наоборот:

parser.add_argument('-1', '--one', action='store_false', help='This will be option One')

$ ./args.py -1
Namespace(one=False)

И без опции:

$ ./args.py
Namespace(one=True)

Соответственно — можем использовать код:

#!/usr/bin/env python

import argparse

parser = argparse.ArgumentParser()

parser.add_argument('-1', '--one', action='store_true', help='This will be option One')

print parser.parse_args()

res = parser.parse_args()

if res.one:
        print 'First is True!'
else:
        print 'First is nothing :-('

Обратите внимание, что тут мы создали объект res, который является экземпляром класса argparse с вызовом метода ArgumentParser — просто, что бы не писать лишний текст.

Результат выполнения:

$ ./args.py -1
Namespace(one=True)
First is True!

И без опции:

$ ./args.py
Namespace(one=False)
First is nothing :-(

‘store’ — сохраняет значение, переданное опции (действие по-умолчанию)

Т.е., опции обязательно передать аргумент, который будет сохранён как её значение.

Например:

#!/usr/bin/env python

import argparse

parser = argparse.ArgumentParser()

parser.add_argument('-1', '--one', help='This will be option One')

print parser.parse_args()

Будет аналогичен такому коду:

parser.add_argument('-1', '--one', action='store', help='This will be option One')

Результат выполнения:

$ ./args.py --one first_argument
Namespace(one='first_argument')

▍необязательные аргументы

Что произойдёт при запуске нашего скрипта командой

python videos.py --help

В ответ будет выведена справочная информация о нём. Это — именно те сведения о позиционных аргументах, которые мы указывали при описании соответствующих переменных:

usage: videos.py [-h] indir outdir

Videos to images

positional arguments:
  indir       Input dir for videos
  outdir      Output dir for image

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

Скрипт сообщил нам много интересного о том, чего он ждёт от пользователя, а

help

— это пример необязательного аргумента (optional argument). Обратите внимание на то, что

--help

(или

-h

) — это единственный стандартный необязательный аргумент, которым мы можем пользоваться при работе с argparse, но, если вам нужны и другие необязательные аргументы, их можно создавать и самостоятельно.

Необязательные аргументы создают так же, как и позиционные. Основная разница между командами их создания заключается в том, что при указании имён таких аргументов эти имена начинаются с последовательности символов –, или, для кратких форм аргументов, с символа -. Например, необязательный аргумент можно создать так:

parser.add_argument('-m', '--my_optional')

Вот пример того, как создавать и использовать необязательные аргументы. Обратите внимание на то, что мы, описывая здесь необязательный аргумент, указали его тип как

int

. То есть он представляет собой целое число. В подобной ситуации можно использовать и другие типы Python.

# my_example.py
import argparse
parser = argparse.ArgumentParser(description='My example explanation')
parser.add_argument(
    '--my_optional',
    type=int,
    default=2,
    help='provide an integer (default: 2)'
)
my_namespace = parser.parse_args()
print(my_namespace.my_optional)

Аргумент, описанный как

--my_optional

, доступен в программе в виде свойства объекта

my_namespace

с именем

my_optional

Необязательным аргументам можно назначать значения, которые они будут иметь по умолчанию. В нашем случае, если при вызове скрипта аргументу my_example не будет задано никакого значения, в него будет записано число 2, которое и будет выведено в консоль. Для того чтобы задать значение этого аргумента во время запуска скрипта можно воспользоваться такой конструкцией:

python my_example.py  --my_optional=3

▍позиционные аргументы

Конструкция вида

parser.add_argument('indir', type=str, help='Input dir for videos')

из скрипта

videos.py

предназначена для создания позиционного аргумента (positional argument). При вызове скрипта важен порядок указания таких аргументов. Так, первый аргумент, переданный скрипту, становится первым позиционным аргументом, второй аргумент — вторым позиционным аргументом.

Что произойдёт в том случае, если скрипт запустить вообще без аргументов, выполнив в терминале команду python videos.py?

В таком случае будет выведено сообщение об ошибке следующего вида:

videos.py: error: the following arguments are required: indir, outdir

В результате оказывается, что для того, чтобы запустить скрипт, в котором предусмотрено использование позиционных аргументов, такие аргументы всегда нужно указывать при его запуске.

Add_argument — action

Рассмотрим допустимые действия для опций.

Add_argument — choices

Т.к. мы кратко рассмотрели const  и default  выше — то пропустим их, и перейдём к слудющему ключу — choices.

Изменим пример:

parser.add_argument('-1', '--one', choices=['1', '2', '3'], help='This will be option One')

В результате — аргумент к опции должен быть только из предложенного списка:

$ ./args.py -1 one two three
usage: args.py [-h] [-1 {1,2,3}]
args.py: error: argument -1/--one: invalid choice: 'one' (choose from 1, 2, 3)

Правильный выбор:

$ ./args.py -1 1
Namespace(one='1')
1

Add_argument — dest

Замена имени переменной. По-умолчанию — имя переменной формируется из «длинного имени» опции (если есть, в нашем примере это –one), или из «короткого» (если нет «длинного», в нашем примере это -1):

parser.add_argument('-1', '--one', help='This will be option One')

$ ./args.py -1 one
Namespace(one='one')

parser.add_argument('-1', help='This will be option One')

$ ./args.py -1 one
Namespace(1='one')

Зададим другое имя:

parser.add_argument('-1', '--one', dest='firstvar', help='This will be option One')

Результат:

$ ./args.py -1 one
Namespace(firstvar='one')

Что бы проверить, что скрипт вызван хотя бы с одной опцией — можно использовать такой способ:

#!/usr/bin/env python

import argparse
import sys

parser = argparse.ArgumentParser()

parser.add_argument('-1', '--one', dest='firstvar', help='This will be option One')

if len(sys.argv) == 1:
        print 'nERROR! You must specify at least one option.n'
        parser.print_help()

И вызовем скрипт без опций:

$ ./args.py

ERROR! You must specify at least one option.

usage: args.py [-h] [-1 FIRSTVAR]

optional arguments:
  -h, --help            show this help message and exit
  -1 FIRSTVAR, --one FIRSTVAR
                        This will be option One

На этом, пожалуй, всё.

Ссылки по теме:

Add_argument — name или flags

Опции, задаваемые со знаком «-» будут считаться опциональными, тогда как заданные просто в виде “имя” — обязательными.

Например:

#!/usr/bin/env python

import argparse

parser = argparse.ArgumentParser()

parser.add_argument('-1', '--one', help='This will be option One')
parser.add_argument('two', help='This will be option two')
parser.add_argument('three', help='This will be option three')

print parser.parse_args()

Обратите внимание — тут мы добавили функцию print(), для вывода «пространства имён» опций.

Вызовем скрипт с опцией –help:

$ ./args.py -h
usage: args.py [-h] [-1 ONE] two three

positional arguments:
  two                This will be option two
  three              This will be option three

optional arguments:
  -h, --help         show this help message and exit
  -1 ONE, --one ONE  This will be option One

Теперь — попробуем запустить скрипт с указанием всех опций:

$ ./args.py  -1 first one two
Namespace(one='first', three='two', two='one')

Т.к. для опции -1 не указано действие — будет выполнено действие по-умолчанию action=’store’. Для позиционных опций не требуется указание аргументов, т.к. его значение само по себе будет явятся аргументом.

Например — вызов опции –one (или -1) без указания аргумента вызовет ошибку:

$ ./args.py one two -1
usage: args.py [-h] [-1 ONE] two three
args.py: error: argument -1/--one: expected one argument

При этом — к вызову обязательны все позиционные опции, иначе будет ошибка:

$ ./args.py one -1 first
usage: args.py [-h] [-1 ONE] two three
args.py: error: too few arguments

Add_argument — nargs

Ключ nargs поддерживает такие значения:

• N — количество аргументов к опции;
• ? — если присутствует один аргумент — он будет сохранён, иначе — будет использовано значение из ключа default;
• * — все переданные аргументы будут сохранены в один список;
• — то же, что и * — но если нет хотя бы одного аргумента — будет выдано сообщение об ошибке;

Add_argument — required

Указание является ли опция обязательной:

parser.add_argument('-1', '--one', required=True, help='This will be option One')

$ ./args.py
usage: args.py [-h] -1 ONE
args.py: error: argument -1/--one is required

$ ./args.py -1 1
Namespace(one='1')
1

Cmd.cmdqueue:

Атрибут Cmd.cmdqueue представляет собой список строк ввода в очереди.

Список Cmd.cmdqueue проверяется в методом Cmd.cmdloop(), когда требуется новый ввод. Если он непустой, то его элементы будут обрабатываться по порядку, как если бы они были введены в командной строке.

Cmd.default(line):

Метод Cmd.default() будет вызываться в строке ввода, когда префикс команды не распознается. Если этот метод не переопределен, то он выводит сообщение об ошибке и возвращает результат.

Cmd.doc_header:

Атрибут Cmd.doc_header представляет собой заголовок , который нужно выдать, если вывод справки содержит раздел для документированных команд.

Cmd.emptyline():

Метод Cmd.emptyline() вызывается, когда в ответ на приглашение вводится пустая строка. Если этот метод не отменен, то он повторяет последнюю введенную непустую команду.

Cmd.identchars:

Атрибут Cmd.identchars представляет собой строку символов, принятых для префикса команды.

Cmd.lastcmd:

Атрибут Cmd.lastcmd представляет собой последний непустой префикс команды, который был замечен.

Cmd.misc_header:

Атрибут Cmd.misc_header представляет собой заголовок , который нужно выдать, если вывод справки содержит раздел для различных разделов справки (то есть существуют методы .help_*() без соответствующих методов .do_*()).

Cmd.onecmd(str):

Метод Cmd.onecmd() интерпретирует аргумент str, как если бы он был введен в ответ на запрос.

Это поведение можно изменить, но обычно в этом нет необходимости. Смотрите полезные хуки выполнения в методах Cmd.precmd() и Cmd.postcmd().

Возвращаемое значение – это флаг, указывающий, следует ли прекратить интерпретацию команд интерпретатором. Если для команды str существует метод .do_*(), то возвращается значение этого метода, в противном случае возвращается значение из метода .default().

Cmd.postcmd(stop, line):

Метод Cmd.postcmd() представляет собой перехватчик, выполняемый сразу после завершения отправки команды. Этот метод является заглушкой в ​​cmd.Cmd. Он существует для переопределения в подклассах.

Аргумент line – это командная строка, которая была выполнена, а аргумент stop – флаг, указывающий, будет ли выполнение прекращено после вызова postcmd(). Это будет возвращаемое значение метода Cmd.onecmd().

Возвращаемое значение этого метода будет использоваться в качестве нового значения для внутреннего флага, который соответствует stop; Возвращаемое значение False приведет к продолжению интерпретации.

Cmd.postloop():

Метод Cmd.postloop() представляет собой хук и выполняется один раз, когда метод Cmd.cmdloop() собирается вернуть результат. Этот метод является заглушкой в ​​cmd.Cmd. Он существует для переопределения в подклассах

Cmd.precmd(line):

Метод Cmd.precmd() представляет собой хук, выполняемый непосредственно перед командной строкой line, но после того, как приглашение ввода будет сгенерировано и выдано.

Этот метод является заглушкой в ​​cmd.Cmd. Он существует для переопределения в подклассах. Возвращаемое значение используется как команда, которая будет выполняться методом Cmd.onecmd(). Реализация метода Cmd.precmd() может переписать команду или просто вернуть строку line без изменений.

Cmd.preloop():

Метод Cmd.preloop() представляет собой перехватчик, выполняется один раз при вызове Cmd.cmdloop(). Этот метод является заглушкой в ​​cmd.Cmd. Он существует для переопределения в подклассах

Cmd.prompt:

Атрибут Cmd.prompt представляет собой приглашение, выводимое для запроса ввода данных.

Cmd.undoc_header:

Атрибут Cmd.undoc_header представляет собой заголовок, который нужно выдать, если в выводе справки есть раздел для недокументированных команд (то есть есть методы do_*() без соответствующих методов .help_*()).

Cmd.use_rawinput:

Атрибут Cmd.use_rawinput представляет собой флаг, по умолчанию имеющий значение True.

Это означает, что при импорте модуля readline в системах, поддерживающих его, интерпретатор автоматически будет поддерживать Emacs-подобное редактирование строк и нажатия клавиш истории команд.

Nargs с «*» аргументов:

Изменим пример:

parser.add_argument('-1', '--one', nargs='*', help='This will be option One')

При вызове без аргументов опции — создаст пустой список:

$ ./args.py -1 one two three
Namespace(one=['one', 'two', 'three'])

При вызове с любым количеством аргументов — добавит их все в один список:

$ ./args.py -1 one two three
Namespace(one=['one', 'two', 'three'])

Далее со списком можно выполнять любые стандартные операции:

#!/usr/bin/env python

import argparse

parser = argparse.ArgumentParser()

parser.add_argument('-1', '--one', nargs='*', help='This will be option One')

print parser.parse_args()

res = parser.parse_args()

for i in res.one:
        print i

И результат:

$ ./args.py -1 one two three
Namespace(one=['one', 'two', 'three'])
one
two
three

Nargs с «?» аргументов:

parser.add_argument('-1', '--one', nargs='?', help='This will be option One')

$ ./args.py -1 first
Namespace(one='first')

Или передать имя файла:

$ ./args.py -1 file.txt
Namespace(one='file.txt')

При вызове без аргумента — значение переменной будет задано как None:

$ ./args.py -1
Namespace(one=None)

Изменить это можно с помощью ключей const и default.

Немного изменим наш код:

parser.add_argument('-1', '--one', nargs='?', const='const-one', default='default-one', help='This will be option One')
parser.add_argument('-2', '--two', nargs='?', const='const-two', default='default-two', help='This will be option Two')

И результаты:

$ ./args.py -1 -2
Namespace(one='const-one', two='const-two')

$ ./args.py -1 first -2
Namespace(one='first', two='const-two')

$ ./args.py -1 first -2 second
Namespace(one='first', two='second')

Nargs с « » аргументов:

Требуется наличие хотя бы одного аргумента к опции.

Напрмиер:

parser.add_argument('-1', '--one', nargs=' ', help='This will be option One')

Вызов без аргумента:

$ ./args.py -1
usage: args.py [-h] [-1 ONE [ONE ...]]
args.py: error: argument -1/--one: expected at least one argument

С одним аргументом:

$ ./args.py -1 one
Namespace(one=['one'])

Несколькими:

$ ./args.py -1 one two three
Namespace(one=['one', 'two', 'three'])

Nargs с n-аргументов:

Пример кода:

parser.add_argument('-1', '--one', nargs=2, help='This will be option One')

Обратите внимание, что тут 2 указывается без кавычек — иначе интерпретатор будет рассматривать значение как string (строку), что вызовет ошибку.

Если вызвать без указания аргументов к опции -1 — будет выдано сообщение об ошибке:

$ ./args.py -1
usage: args.py [-h] [-1 ONE ONE]
args.py: error: argument -1/--one: expected 2 argument(s)

Вызываем с двумя аргументами — и получаем список:

$ ./args.py -1 one two
Namespace(one=['one', 'two'])

Python: обработка аргументов из командной строки

Базовый пример с докоптом

docopt получается аргумент командной строки при разборе на голове. Вместо разбора аргументов, вы просто пишете строку использования для вашей программы, и docopt разбирает строку использования и использует его для извлечения аргументов командной строки.

 """
Usage:
    script_name.py [-a] [-b] <path>

Options:
    -a            Print all the things.
    -b            Get more bees into the path.
"""
from docopt import docopt


if __name__ == "__main__":
    args = docopt(__doc__)
    import pprint; pprint.pprint(args)

 

Образцы прогонов:

 $ python script_name.py
Usage:
    script_name.py [-a] [-b] <path>
$ python script_name.py something
{'-a': False,
 '-b': False,
 '<path>': 'something'}
$ python script_name.py something -a
{'-a': True,
 '-b': False,
 '<path>': 'something'}
$ python script_name.py -b something -a
{'-a': True,
 '-b': True,
 '<path>': 'something'} 

Для чего ещё можно использовать argparse?

Модуль argparse можно использовать при разработке Python-приложений, которые планируется упаковывать в контейнеры Docker. Так, например, если при запуске приложения, упакованного в контейнер, ему нужно передать аргументы командной строки, то описать это, на этапе сборки контейнера, можно в Dockerfile с помощью инструкции

RUN

. Для запуска скриптов во время выполнения контейнера можно пользоваться инструкциями

CMD

или

ENTRYPOINT

. Подробности о файлах Dockerfile вы можете найти

Добавление аргументов.

Заполнение объекта ArgumentParser информацией об аргументах программы осуществляется путем вызова метода parser.add_argument(). Как правило, эти вызовы говорят ArgumentParser, как взять строки из командной строки и превратить их в объекты. Эта информация хранится и используется при вызове метода parser.parse_args().

Например:

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

Позже, вызов метода parser.parse_args() вернет объект с двумя атрибутами: integers и accumulate. Атрибут integers будет представлять собой список из одного или нескольких int, а атрибут accumulate будет либо функцией sum(), если в командной строке указан параметр –sum, либо функцией max(), если это не так.

Жизнь за пределами jupyter notebook

Когда я впервые столкнулся с argparse в Python-скрипте, который нужен был мне для проекта, которым я занимался в свободное время, я подумал: «А это что ещё за таинственная конструкция?». После этого я быстро перенёс код в Jupyter Notebook, но такой ход оказался нерациональным.

Мне нужно было, чтобы у меня была возможность просто запустить скрипт, а не работать с ним средствами Jupyter Notebook. Автономным скриптом, в котором использовался модуль argparse, было бы гораздо легче пользоваться, работать над ним было бы проще, чем полагаясь на возможности Jupyter Notebook.

С тех пор я разобрался с argparse и этот модуль мне очень понравился. Теперь я считаю его прямо-таки жизненно необходимым. При этом освоить его не так уж и сложно.

Исключение getopt.getopterror

Эта проблема возникает, когда в списке аргументов обнаруживается нераспознанная опция или если для опции, требующей аргумента, ничего не указано.

Аргументом исключения является строка, указывающая причину ошибки. Атрибуты msg и opt дают сообщение об ошибке и соответствующую опцию.

Метод getopt.getopt

Этот метод анализирует параметры командной строки и список параметров. Ниже приведен простой синтаксис этого метода:

getopt.getopt(args, options, [long_options])

Вот детали параметров –

• args – это список аргументов для анализа.

• options – это строка букв опций, которую сценарий хочет распознать, с опциями, которые требуют аргумента, должны сопровождаться двоеточием (:).

• long_options – это необязательный параметр, и, если он указан, должен быть списком строк с именами длинных опций, которые должны поддерживаться. За длинными параметрами, которые требуют аргумента, должен следовать знак равенства (‘=’). Чтобы принимать только длинные опции, опции должны быть пустой строкой.

• Этот метод возвращает значение, состоящее из двух элементов: первый представляет собой список пар (опция, значение) . Второй – это список аргументов программы, оставшихся после удаления списка опций.

• Каждая возвращенная пара опций и значений имеет опцию в качестве первого элемента, с префиксом дефиса для коротких опций (например, «-x») или двух дефисов для длинных опций (например, «–long-option»).

Модуль argparse

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

Надо отметить, что argparse является рекомендуемым к использованию модулем стандартной библиотеки Python, предназначенным для работы с аргументами командной строки. Мне не удалось найти хорошее руководство по argparse для начинающих, поэтому я и решил написать такое руководство сам.

Подробности об argparse

Только что мы рассмотрели простой пример работы с argparse. Теперь давайте обсудим некоторые подробности, касающиеся argparse.

Привет, мир в argparse

Следующая программа говорит привет пользователю. Он принимает один позиционный аргумент, имя пользователя, а также может быть сказано приветствие.

Пример 3: обработка целочисленного аргумента

Чтобы обрабатывать аргументы, которым требуются целочисленные значения, вам необходимо установить ключевое слово «type» на «int», чтобы разрешить проверку и выдавать ошибки в случае, если условие не выполняется.

import argparse

parser = argparse.ArgumentParser(description='A test program.')

parser.add_argument("-p", "--print_string", help="Prints the supplied argument.", type=int)

args = parser.parse_args()

print(args.print_string)

Попробуйте выполнить следующую команду:

Пример 4: обработка переключателей true и false

Вы можете передавать аргументы без каких-либо значений, чтобы рассматривать их как флаги True и False, используя аргумент «action».

import argparse

parser = argparse.ArgumentParser(description='A test program.')

parser.add_argument("-p", "--print_string", help="Prints the supplied argument.", action="store_true")

args = parser.parse_args()

print(args.print_string)

Выполните команду ниже, чтобы получить на выходе простое «Истина»:

$ ./test.py -p

Если вы запустите сценарий без аргумента «-p», вместо него будет присвоено значение «Ложь». Значение «store_true» ключевого слова «action» присваивает значение «True» переменной «print_string» всякий раз, когда аргумент «-p» явно указан, в противном случае переменной присваивается значение «False».

Пример 5. обработка значений аргументов как списка

Если вы хотите получить сразу несколько значений и сохранить их в списке, вам необходимо указать ключевое слово nargs в следующем формате:

import argparse

parser = argparse.ArgumentParser(description='A test program.')

parser.add_argument("-p", "--print_string", help="Prints the supplied argument.", nargs='*')

args = parser.parse_args()

print(args.print_string)

Выполните следующую команду, чтобы проверить приведенный выше код:

$ ./test.py -p “a” “b”

Вы должны получить примерно такой результат:

Разбор аргументов командной строки

Python предоставил модуль getopt, который поможет вам разобрать параметры командной строки и аргументы. Этот модуль предоставляет две функции и исключение для включения анализа аргументов командной строки.

Разбор аргументов.

Объект ArgumentParser анализирует аргументы с помощью метода parser.parse_args(). Это позволит проверить командную строку на ошибки, преобразовать каждый аргумент в соответствующий тип и затем вызвать соответствующее действие.

В большинстве случаев это означает, что простой объект пространства имен будет создан из атрибутов, проанализированных из командной строки:

В сценарии метод parser.parse_args() обычно вызывается без аргументов, а объект ArgumentParser автоматически определяет аргументы командной строки из функции sys.argv.

Следующий код представляет собой программу Python, которая читает список целых чисел из командной строки и производит либо сумму, либо вычисляет максимум:

# prog.pyimportargparseparser=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))

Предположим, что приведенный выше код Python сохранен в файл с именем prog.py и может быть запущен в командной строке и предоставляет полезные справочные сообщения:

При запуске с соответствующими аргументами он выводит либо сумму, либо максимум целых чисел, прочитанных из командной строки:

Если будут переданы недопустимые аргументы, то программа выдаст ошибку:

Расширенный пример с docopt и docopt_dispatch

Как docopt, с [docopt_dispatch] вы ремесло ваш –help в __doc__ переменной вашей точки входа модуля. Там, вы вызываете dispatch с доком строкой в качестве аргумента, так что он может запустить анализатор над ним.

Это делается вместо того, чтобы вручную обрабатывать аргументы (которые обычно заканчиваются структурой if / else с высокой цикломатикой), вы оставляете это для диспетчеризации, давая только то, как вы хотите обработать набор аргументов.

Это то , что dispatch.on декоратор для: вы даете ему аргумент или последовательность аргументов , которые должны вызвать функцию, и эта функция будет выполняться со значениями соответствия в качестве параметров.

"""Run something in development or production mode.

Usage: run.py --development <host> <port>
       run.py --production <host> <port>
       run.py items add <item>
       run.py items delete <item>

"""
from docopt_dispatch import dispatch

@dispatch.on('--development')
def development(host, port, **kwargs):
    print('in *development* mode')

@dispatch.on('--production')
def development(host, port, **kwargs):
    print('in *production* mode')

@dispatch.on('items', 'add')
def items_add(item, **kwargs):
    print('adding item...')

@dispatch.on('items', 'delete')
def items_delete(item, **kwargs):
    print('deleting item...')

if __name__ == '__main__':
    dispatch(__doc__)

Создание парсера.

Первым шагом в использовании модуля argparse является получение объекта ArgumentParser путем создания экземпляра класса argparse.ArgumentParser():

Объект ArgumentParser будет содержать всю информацию, необходимую для синтаксического анализа командной строки на типы данных Python.

Вывод

Модуль «argparse» довольно обширен с множеством опций для настройки поведения приложений командной строки и анализа значений, вводимых пользователем. Эти примеры касаются только базового использования модуля «argparse». Для сложных и сложных приложений вам могут потребоваться разные реализации.

Итоги

Мы рассмотрели базовые способы работы с модулем argparse, используя которые, вы можете оснастить свои скрипты возможностью принимать и обрабатывать аргументы командной строки. При этом надо отметить, что возможности argparse на этом не заканчиваются.

позволяет работать со списками аргументов, а параметр

позволяет задавать наборы значений, которые могут принимать аргументы. На самом деле, теперь, освоив основные возможности argparse, вы, без особых сложностей, сможете изучить этот модуль более глубоко, используя

к нему.

Если вы привыкли работать с Jupyter Notebook и хотите отойти от этой практики, то вот и вот — материалы по работе с переменными окружениями. Вот материал, посвящённый средству, repo2docker, позволяющему преобразовывать репозитории Jupyter Notebook в образы Docker.

Уважаемые читатели! Как вы работаете с аргументами командной строки в Python-скриптах?

Похожее:

windows – batch file to check 64bit or 32bit OS – Stack Overflow c# – Как парсить аргументы командной строки? – Stack Overflow на русском Tp link адаптер wi fi как настроить Подключение Wi-Fi роутера к компьютеру через кабель