Аргументы командной строки в python

Базовые концепции модуля click.

Создание команды.

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

Функция становится инструментом командной строки, если она декорируется с помощью . В самом простом случае, если просто украсить функцию этим декоратором, то она превратится в вызываемый скрипт:

# hello.py
import click

@click.command()
def hello():
    click.echo('Hello World!')

if __name__ == '__main__'
    hello()

Происходит то, что декоратор преобразует функцию в команду, которая затем может быть вызвана:

$ python hello.py
# Hello World!

# И соответствующая страница помощи
$ python hello.py --help
# Usage: hello.py 
# 
# Options:
#   --help  Show this message and exit.

Функция

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

Это означает, что функция применяет некоторое исправления ошибок в случае, если кодировка терминала настроена неправильно.

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

Вложенные команды.

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

import click

# создаем группу команд `cli`
@click.group()
def test():
pass

# обратите внимание на название
# декораторов для вложенных команд

# присоединяем команду `initdb`
@test.command()
def initdb():
click.echo(‘Initialized the database’)

# присоединяем команду `dropdb`
@test.command()
def dropdb():
click.echo(‘Dropped the database’)

if __name__ == ‘__main__’
test()

В примере выше, декоратор расположен над основной функцией/командой и создает объект с именем этой функции , которому можно дать несколько подкоманд. Подкоманды украшаются декораторами , в примере, это декоратор с именем .

Отложенная регистрация подкоманд.

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

import click

# создаем команду, с именем `initdb`
@click.command()
def initdb():
    click.echo('Initialized the database')

# создаем команду, с именем `dropdb`
@click.command()
def dropdb():
    click.echo('Dropped the database')

# создаем группу команд, с именем `cli`
@click.group()
def test():
    pass

# добавляем `initdb` и `dropdb` как подкоманды сценария `test`
test.add_command(initdb)
test.add_command(dropdb)

if __name__ == '__main__'
    test()

Добавление параметров командной строки.

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

# hello.py
import click

@click.command()
@click.option('--count', default=1, help='number of greetings')
@click.argument('name', help='You name')
def hello(count, name):
    """
    This script prints "Hello <NAME>!" COUNT times.

    - <NAME> is your name.
    """
    for x in range(count):
        click.echo(f"Hello {name}!")

if __name__ == '__main__'
    hello()

Запускаем сценарий:

$ python hello.py --count=3 John
# Hello John!
# Hello John!
# Hello John!

Теперь с опцией :

$ python hello.py --help
# Usage: hello.py  NAME
# 
#   This script prints "Hello <NAME>!" COUNT times.
# 
#   - <NAME> is your name.
# 
# Options:
#   --count INTEGER  number of greetings
#   --help           Show this message and exit.

Добавьте параметр option-add_argument

name or flags : Есть два вида параметров, необязательные параметры и позиционные параметры.

1. Добавить необязательные параметры

1. Добавить позиционные параметры

Когда parse_args () работает, он будет использовать «-» для аутентификации необязательных параметров по умолчанию, а остальные — позиционные параметры.

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

1. store_const: значение сохраняется в const:

1. store_true и store_false: значение сохраняется как True или False

1. append: сохранить как список, может иметь несколько параметров

1. append_const: сохранен в виде списка, будет добавлен в соответствии с параметрами ключа const:

1. count: количество вхождений статистического параметра

1. help: справочная информация
2. версия: версия

metaver: Имя параметра отображается в справочной информацииnargs: Количество параметров

1. Значением может быть целое число N (N), * (любое число может быть 0), + (один или несколько), немного похожее на регулярное выражение

1. Когда значение равно?, Сначала получите параметры из командной строки, если после -y не добавлено ни одного параметра, то значение берется из const, если параметра нет, -y берется из значения по умолчанию

const : Сохранить константу

default : Значение по умолчанию

type : Тип параметра, по умолчанию str

choices : Установите диапазон значений параметров. Если тип в выборе не является строкой, не забудьте указать тип

required : Требуется ли эта опция, по умолчанию установлено значение Truedest : Имя параметра

Справка

Каждый раз, когда мы создаем новый скрипт, мы знаем, какие аргументы передать и что они делают. Но как насчет пользователя, который ничего не знает о нашем скрипте? Как он узнает, какие аргументы передать, в каком порядке и что они делают?

Здесь на помощь приходит еще один атрибут в функции add_argument:

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('blog', default="JournalDev", help="Best blog name here.")
args = parser.parse_args()

if args.blog == 'JournalDev':
    print('You made it!')
else:
    print("Didn't make it!")

Теперь, когда мы запускаем наш скрипт как (-h для справки):

python argparse_positional_help.py -h

Получаем такой вывод:

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

Модуль sys

Это базовый модуль, который с самого начала поставлялся с Python. Он использует подход, очень похожий на библиотеку C, с использованием argc и argv для доступа к аргументам. Модуль sys реализует аргументы командной строки в простой структуре списка с именем sys.argv.

Каждый элемент списка представляет собой единственный аргумент. Первый элемент в списке sys.argv – это имя скрипта Python. Остальные элементы списка, от sys.argv до sys.argv , являются аргументами командной строки с 2 по n. В качестве разделителя между аргументами используется пробел. Значения аргументов, содержащие пробел, должны быть заключены в кавычки, чтобы их правильно проанализировал sys.

Эквивалент argc – это просто количество элементов в списке. Чтобы получить это значение, используйте оператор len(). Позже мы покажем это на примере кода.

Печать первого аргумента CLI

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

import sys

print ("The script has the name %s" % (sys.argv)

Сохраните этот код в файле с именем arguments-program-name.py, а затем вызовите его, как показано ниже. Результат выглядит следующим образом и содержит имя файла, включая его полный путь:

$ python arguments-program-name.py
The script has the name arguments-program-name.py
$ python /home/user/arguments-program-name.py
The script has the name /home/user/arguments-program-name.py

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

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

Во втором примере мы просто подсчитываем количество аргументов командной строки с помощью встроенного метода len(). sys.argv – это список, который мы должны изучить. В приведенном ниже коде мы получаем количество аргументов и затем вычитаем 1, потому что один из этих аргументов (т.е. первый) всегда устанавливается как имя файла, что не всегда полезно для нас. Таким образом, фактическое количество аргументов, переданных пользователем, равно len (sys.argv) – 1.

import sys

# Count the arguments
arguments = len(sys.argv) - 1
print ("The script is called with %i arguments" % (arguments))

Сохраните и назовите этот файл arguments-count.py. Ниже приведены некоторые примеры вызова этого сценария. Это включает три разных сценария:

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

$ python arguments-count.py
The script is called with 0 arguments
$ python arguments-count.py --help me
The script is called with 2 arguments
$ python arguments-count.py --option "long string"
The script is called with 2 arguments

Итерация по аргументам

В нашем третьем примере выводятся все аргументы, отправленные скрипту Python, за исключением самого имени программы. Поэтому мы перебираем аргументы командной строки, начиная со второго элемента списка. Напомним, что это индекс 1, поскольку списки в Python основаны на 0.

import sys

# Count the arguments
arguments = len(sys.argv) - 1

# Output argument-wise
position = 1
while (arguments >= position):
    print ("Parameter %i: %s" % (position, sys.argv))
    position = position + 1

Ниже мы вызываем наш код, который был сохранен в файле arguments-output.py. Как и в предыдущем примере, на выходе показаны три разных вызова:

• Звонок без аргументов.
• Вызов с двумя аргументами.
• Вызов с двумя аргументами, где второй аргумент – строка в кавычках, содержащая пробел.

$ python arguments-output.py
$ python arguments-output.py --help me
Parameter 1: --help
Parameter 2: me
$ python arguments-output.py --option "long string"
Parameter 1: --option
Parameter 2: long string

Помните, что смысл показа строки в кавычках заключается в том, что параметры обычно разделяются пробелом, если только они не заключены в кавычки.

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:

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

$ ./args.py -h
usage: args.py   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   two three
args.py: error: argument -1/--one: expected one argument

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

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

Как реализовать библиотеку argparse для создания интерфейса командной строки?

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

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

 
# importing argparse module 
import argparse 
parser = argparse.ArgumentParser() 
 
# creating two variables using the add_argument method 
parser.add_argument("num1", help = "first number") 
parser.add_argument("num2", help = "second number") 
parser.add_argument("operation", help = "operation") 

Мы импортировали модуль argparse и создали простой парсер, который будет использоваться во всей программе. Мы вызвали метод add_argument() и передали два аргумента – num1 и help. Мы сохранили приведенный выше код в файле с именем code.py.

Чтобы запустить эту программу, мы открываем интерфейс командной строки и запускаем указанный выше файл.

Команда:

 
C:\Users\DEVANSH SHARMA\PycharmProjects\Elasticsearch>python code.py 

Когда мы нажимаем Enter, он покажет следующий результат.

Выход:

usage: code.py  num1 num2 operation 
code.py: error: the following arguments are required: num1, num2, operation 

Как мы видим, это показывает ошибку, потому что мы не передали требуемый аргумент.

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

Команда:

 
C:\Users\DEVANSH SHARMA\PycharmProjects\Elasticsearch>python code.py -h 

Выход:

usage: code.py  num1 num2 operation 
 
positional arguments: 
  num1        first number 
  num2        second number 
  operation   operation 
 
optional arguments: 
  -h, --help  show this help message and exit 

Мы получаем весь список аргументов, который мы определили в нашей программе Python. Теперь мы напечатаем оба аргумента и операцию, добавив следующую операцию. Когда мы выполняем .parse_args(), мы получаем объект пространства имен, содержащий простое свойство каждого входного аргумента, полученного из командной строки.

 
args = parser.parse_args() 
 
print(args.num1) 
print(args.num2) 
print(args.operation) 

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

 
n1 = int(args.num1) 
n2 = int(args.num2) 

Чтобы сложить эти два числа, мы определяем операцию добавления в нашем коде.

 
result = n1 + n2 
print("The Result is : ",result) 

C:\Users\DEVANSH SHARMA\PycharmProjects\Elasticsearch>python code.py 20 30 add 
20 
30 
add 
The Result is :  50 

Пример – 1: простая программа-калькулятор с использованием argparse

 
# importing argparse module 
import argparse 
parser = argparse.ArgumentParser() 
 
# creating two variables using the add_argument method 
parser.add_argument("num1", help = "first number") 
parser.add_argument("num2", help = "second number") 
parser.add_argument("operation", help = "operation") 
 
 
args = parser.parse_args() 
 
print(args.num1) 
print(args.num2) 
print(args.operation) 
 
n1 = int(args.num1) 
n2 = int(args.num2) 
 
 
if args.operation == "add": 
    result = n1 + n2 
    print("The Result is : ",result) 
 
elif args.operation == "sub": 
    result = n1 - n2 
 
elif args.operation == "mul": 
    result = n1 * n2 
elif args.operation == "div": 
    result = n1 / n2 
else: 
    print("Unmatched Argument") 
 
print("result is : ",result) 

Выход:

Знакомство с необязательными аргументами¶

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

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

И вывод:

$ python3 prog.py --verbosity 1
verbosity turned on
$ python3 prog.py
$ python3 prog.py --help
usage: prog.py  

optional arguments:
  -h, --help            show this help message and exit
  --verbosity VERBOSITY
                        increase output verbosity
$ python3 prog.py --verbosity
usage: prog.py  
prog.py: error: argument --verbosity: expected one argument

Вот что происходит:

Программа написана таким образом, чтобы отображать что-то, когда указан
, и ничего не отображать, когда не указан.
Чтобы показать, что эта опция на самом деле является необязательной, при
запуске программы без неё не будет ошибок

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

Давайте соответствующим образом изменим
код:

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

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

И вывод:

$ python3 prog.py --verbose
verbosity turned on
$ python3 prog.py --verbose 1
usage: prog.py  
prog.py: error: unrecognized arguments: 1
$ python3 prog.py --help
usage: prog.py  

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

Вот что происходит:

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

Обратите
внимание, что теперь мы указываем новое ключевое слово и
присваиваем ему значение. Это означает, что, если опция
указана, присвоить значение

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

Пример

Допустим, у вас есть директория с видео и вы хотите преобразовать эти видео в картинки, используя OpenCV. Используйте для того, чтобы пользователь мог самостоятельно выбрать папку исходников и папку для сохранения. Вот как это будет выглядеть:

Для начала импортируем саму библиотеку. Затем создаём парсер с описанием и переменную indir при помощи метода . Типом переменной указываем str (строковый тип данных), добавляем вспомогательное сообщение — описание переменной. Ту же последовательность действий выполняем для outdir. Затем переменной args присваиваются значения считанных (parsed) аргументов.

Теперь можем выполнить эту команду из командной строки:

Заметьте, что значения аргументов не нужно заключать в кавычки.

При корректной работе вывод в терминал должен быть таким: . 

Мы только что увидели, что можем использовать переменную в нашей программе где угодно. Разве это не круто?

Теперь вы постигли магию argparse!

Как они это делают?

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_*().

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

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

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

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

из скрипта

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

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

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

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

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

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

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

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

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

Обратите внимание на то, что. (или

(или

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

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

, или, для кратких форм аргументов, с символа

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

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

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

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

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

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

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

с именем

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

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

Шаг аргументов

Способ получения аргументов от программы Python осуществляется благодаря функции “argv” в модуле “sys”.

Эта функция собирает все аргументы и возвращает их в виде списка.

Здесь мы видим программу, которая собирает параметры и печатает их на экране:

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

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

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

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

Для этого мы сделаем цикл “for”, который будет проходить через все аргументы (sys.argv), и мы будем складывать их по одному, чтобы получить общее количество.

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

Сначала в первом аргументе мы передаем слово “sum” или “multiply”, а в остальных аргументах – числа, которые мы собираемся сложить или умножить.

Программа будет выглядеть следующим образом:

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

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

Простой пример

Вот несколько простых примеров, и постараюсь быть вернымИмейте предварительное понимание. Для более подробных примеров, пожалуйста, обратитесь к:

Пример 1. Добавьте параметр позиции: квадрат, тип которого：

Формат программы, сгенерированной приведенным выше кодом, следующий:, Таким образом, конкретное использование должно быть похоже на:

Примечание：Тип параметра по умолчанию — строка (), способный передатьПараметр указывает тип параметра.

Пример 2. Добавьте необязательный параметр: -v / — verbose:

Формат программы, сгенерированной приведенным выше кодом, следующий:, Необязательные параметрыПосле него необходимо добавить значение (любого типа). Следовательно, конкретное использование должно быть похоже на:

Обычно необязательный параметр программы представлен логическим типом значения:，. Можно передать в методеДобавить параметры к параметрамСделайте обозначение.

Пример 3. Добавьте в программу параметр позиции: квадрат, тип; Заодно добавьте необязательный параметр логического типа: -v / — verbose:

Формат программы, сгенерированной приведенным выше кодом, следующий:, Таким образом, конкретное использование должно быть похоже на:

Примечание：Указывает, что, когда указан необязательный параметр, его значение, Если не указано, то。Напротив, когда параметр не указан, его значение равно, Когда отображается указанный параметр, его значение。

Создайте парсер-ArgumentParser

Создайте экземпляр ArgumentParser, параметры ArgumentParser являются ключевыми параметрами.prog : Имя файла, по умолчанию sys.argv , используется для описания имени программы в справочной информации.usage : Строка, описывающая назначение программыdescription : Информация отображается перед справочной информациейepilog : Информация отображается после справочной информацииparents : Список объектов ArgumentParser, опция их аргументов будет включена в новый объект ArgumentParser. (Похоже на наследование)formatter_class : Формат вывода справочной информации, ради красоты …prefix_chars : Префикс параметра, по умолчанию ‘-’ (желательно не измененный)

fromfile_prefix_chars : Префиксный символ, помещенный перед именем файла

Когда параметров слишком много, вы можете поместить параметры в файл для чтения, в примере parser.parse_args () будет читать из файла args.txt Эквивалент conflict_handler : Стратегия разрешения конфликтов. По умолчанию ошибки будут возникать в конфликтах (желательно без изменений)

add_help: для добавления опции -h / -help (по умолчанию True), требуется общая справочная информация. Когда установлено значение False, справочная информация больше не отображает информацию -h -helpargument_default:-( По умолчанию: Нет) Установите значение по умолчанию для глобальной опции, обычно каждая опция устанавливается отдельно, в основном бесполезно

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

Заполнение объекта 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(), если это не так.

Зачем нужен модуль argparse?

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

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

Жизнь за пределами Jupyter Notebook

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

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

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