Поскольку Python является таким популярным языком программирования, а также поддерживает большинство операционных систем, он стал широко использоваться для создания инструментов командной строки для многих целей. Эти инструменты могут варьироваться от простых приложений CLI до более сложных, таких как инструмент AWS awscli.
Такие сложные инструменты, как этот, обычно управляются пользователем с помощью аргументов командной строки, что позволяет пользователю использовать определенные команды, устанавливать параметры и многое другое. Например, эти параметры могут указывать инструменту на вывод дополнительной информации, чтение данных из указанного источника или отправку вывода в определенное место.
- Подобно Unix: – за которым следует буква, например -h, или – за которым следует слово, например –help
- Windows:/, за которым следует буква или слово, например /help.
Эти разные подходы существуют по историческим причинам. Многие программы в Unix-подобных системах поддерживают как одинарное, так и двойное тире. Обозначение одинарного тире в основном используется с однобуквенными параметрами, а двойное тире представляет собой более читаемый список параметров, что особенно полезно для сложных параметров, которые должны быть более явными.
Python для начинающих / Урок 8. Запуск программ с несколькими аргументами
Примечание. В этой статье мы сосредоточимся исключительно на Unix-подобном формате – и -.
Имейте в виду, что и имя, и значение аргумента специфичны для программы – нет общего определения, кроме нескольких общих соглашений, таких как –help для получения дополнительной информации об использовании инструмента. Как разработчик сценария Python вы решаете, какие аргументы предоставить вызывающей стороне и что они будут делать. Это требует правильной оценки.
По мере роста вашего списка доступных аргументов ваш код станет более сложным в попытках их точного анализа. К счастью, в Python есть ряд библиотек, которые помогут вам в этом. Мы рассмотрим несколько наиболее распространенных решений, от «сделай сам» с sys.argv до подхода «сделай за тебя» с argparse.
Обработка аргументов командной строки
Python 3 поддерживает несколько различных способов обработки аргументов командной строки. Встроенный способ – использовать модуль sys. С точки зрения имен и использования, он имеет прямое отношение к библиотеке C (libc). Второй способ – это модуль getopt, который обрабатывает как короткие, так и длинные параметры, включая оценку значений параметров.
Кроме того, существуют два других общих метода. Это модуль argparse, производный от модуля optparse, доступного до Python 2.7. Другой метод – использование модуля docopt, доступного на GitHub.
У каждого из этих способов есть свои плюсы и минусы, поэтому стоит оценить каждый, чтобы увидеть, какой из них лучше всего соответствует вашим потребностям.
Модуль sys
Это базовый модуль, который с самого начала поставлялся с Python. Он использует подход, очень похожий на библиотеку C, с использованием argc и argv для доступа к аргументам. Модуль sys реализует аргументы командной строки в простой структуре списка с именем sys.argv.
Как передавать параметры в Python-скрипты | Базовый курс. Программирование на Python.
Каждый элемент списка представляет собой единственный аргумент. Первый элемент в списке sys.argv [0] – это имя скрипта Python. Остальные элементы списка, от sys.argv [1] до sys.argv [n], являются аргументами командной строки с 2 по n. В качестве разделителя между аргументами используется пробел. Значения аргументов, содержащие пробел, должны быть заключены в кавычки, чтобы их правильно проанализировал sys.
Эквивалент argc – это просто количество элементов в списке. Чтобы получить это значение, используйте оператор len(). Позже мы покажем это на примере кода.
Печать первого аргумента CLI
В этом первом примере наш сценарий определит способ его вызова. Эта информация хранится в первом аргументе командной строки с индексом 0. В приведенном ниже коде показано, как получить имя сценария в Python.
import sys print («The script has the name %s» % (sys.argv[0])
Сохраните этот код в файле с именем 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))
- Вызов без дополнительных аргументов командной строки.
- Вызов с двумя аргументами.
- Вызов с двумя аргументами, где второй – строка в кавычках, содержащая пробел.
$ 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 = position + 1
- Звонок без аргументов.
- Вызов с двумя аргументами.
- Вызов с двумя аргументами, где второй аргумент – строка в кавычках, содержащая пробел.
$ 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
Помните, что смысл показа строки в кавычках заключается в том, что параметры обычно разделяются пробелом, если только они не заключены в кавычки.
Модуль getopt
Как вы могли заметить ранее, модуль sys разбивает строку командной строки только на отдельные фасеты. Модуль getopt в Python идет немного дальше и расширяет разделение входной строки проверкой параметров. Основанный на функции C getopt, он позволяет использовать как короткие, так и длинные варианты, включая присвоение значений.
На практике для правильной обработки входных данных требуется модуль sys. Для этого необходимо заранее загрузить как модуль sys, так и модуль getopt. Затем из списка входных параметров мы удаляем первый элемент списка (см. код ниже) и сохраняем оставшийся список аргументов командной строки в переменной с именем arguments_list.
# Include standard modules import getopt, sys # Get full command-line arguments full_cmd_arguments = sys.argv # Keep all but the first argument_list = full_cmd_arguments[1:] print argument_list
Аргументы в списке аргументов теперь можно анализировать с помощью метода getopts(). Но перед этим нам нужно сообщить getopts() о том, какие параметры допустимы. Они определены так:
short_options = «ho:v» long_options = [«help», «output=», «verbose»]
Это означает, что эти аргументы мы считаем действительными, а также некоторую дополнительную информацию:
—————————————— long argument short argument with value —————————————— —help -h no —output -o yes —verbose -v no ——————————————
Вы могли заметить, что после опции o short ставится двоеточие (:). Это сообщает getopt, что этой опции следует присвоить значение.
Теперь это позволяет нам обрабатывать список аргументов. Для метода getopt() необходимо настроить три параметра – список фактических аргументов из argv, а также допустимые короткие и длинные параметры (показаны в предыдущем фрагменте кода).
Сам вызов метода хранится в инструкции try-catch, чтобы скрыть ошибки во время оценки. Исключение возникает, если обнаруживается аргумент, который не является частью списка, как определено ранее. Скрипт в Python выведет сообщение об ошибке на экран и выйдет с кодом ошибки 2.
try: arguments, values = getopt.getopt(argument_list, short_options, long_options) except getopt.error as err: # Output error, and return with an error code print (str(err)) sys.exit(2)
Наконец, аргументы с соответствующими значениями сохраняются в двух переменных с именами arguments и values. Теперь вы можете легко оценить эти переменные в своем коде. Мы можем использовать цикл for для перебора списка распознанных аргументов, одна запись за другой.
# Evaluate given options for current_argument, current_value in arguments: if current_argument in («-v», «—verbose»): print («Enabling verbose mode») elif current_argument in («-h», «—help»): print («Displaying help») elif current_argument in («-o», «—output»): print ((«Enabling special output mode (%s)») % (current_value))
Ниже вы можете увидеть результат выполнения этого кода. Мы покажем, как программа реагирует как на допустимые, так и на недопустимые программные аргументы:
$ python arguments-getopt.py -h Displaying help $ python arguments-getopt.py —help Displaying help $ python arguments-getopt.py —output=green —help -v Enabling special output mode (green) Displaying help Enabling verbose mode $ python arguments-getopt.py -verbose option -e not recognized
Последний вызов нашей программы поначалу может показаться немного запутанным. Чтобы понять это, вам нужно знать, что сокращенные параметры (иногда также называемые флагами) могут использоваться вместе с одним тире.
Это позволяет вашему инструменту легче воспринимать множество вариантов. Например, вызов аргументов arguments-getopt.py-vh аналогичен вызову аргументов arguments-getopt.py-v-h. Таким образом, в последнем вызове выше модуль getopt подумал, что пользователь пытается передать -e в качестве опции, что недопустимо.
Модуль argparse
Модуль argparse доступен начиная с Python 3.2 и является расширением модуля optparse, существующим до Python 2.7. Документация Python содержит описание API и руководство, в котором подробно рассматриваются все методы.
Модуль предлагает интерфейс командной строки со стандартизованным выводом, тогда как первые два решения оставляют большую часть работы в ваших руках. argparse позволяет проверять фиксированные и необязательные аргументы с проверкой имени в коротком или длинном стиле. В качестве необязательного аргумента по умолчанию он включает -h вместе с его длинной версией –help. Этот аргумент сопровождается справочным сообщением по умолчанию, описывающим принятые аргументы.
В приведенном ниже коде показана инициализация парсера, а в выходных данных ниже показан основной вызов, за которым следует справочное сообщение. В отличие от вызовов Python, которые мы использовали в предыдущих примерах, не забывайте использовать Python 3 с этими примерами.
# Include standard modules import argparse # Initiate the parser parser = argparse.ArgumentParser() parser.parse_args()
$ python3 arguments-argparse-basic.py $ python3 arguments-argparse-basic.py -h usage: arguments-argparse-basic.py [-h] optional arguments: -h, —help show this help message and exit $ python3 arguments-argparse-basic.py —verbose usage: arguments-argparse-basic.py [-h] arguments-argparse-basic.py: error: unrecognized arguments: —verbose
На следующем этапе мы добавим настраиваемое описание в справочное сообщение для наших пользователей.
Инициализация парсера таким образом позволяет добавить дополнительный текст. В приведенном ниже коде описание хранится в текстовой переменной, которая явно передается классу argparse в качестве параметра описания. Вызов этого кода ниже, вы можете увидеть, как выглядит результат.
# Include standard modules import argparse # Define the program description text = ‘This is a test program. It demonstrates how to use the argparse module with a program description.’ # Initiate the parser with a description parser = argparse.ArgumentParser(description=text) parser.parse_args()
$ python3 arguments-argparse-description.py —help usage: arguments-argparse-description.py [-h] This is a test program. It demonstrates how to use the argparse module with a program description. optional arguments: -h, —help show this help message and exit
- Имя параметра: –version.
- Текст справки для параметра: help = “показать версию программы”.
- Действие (без дополнительного значения): action = “store_true”.
Исходный код для этого показан ниже. Считывание аргументов в переменную args выполняется с помощью метода parse_args() из объекта анализатора. Обратите внимание, что вы отправляете как краткую, так и полную версию за один вызов. Наконец, вы проверяете, установлены ли атрибуты args.V или args.version, и выводите сообщение о версии.
# Include standard modules import argparse # Initiate the parser parser = argparse.ArgumentParser() parser.add_argument(«-V», «—version», help=»show program version», action=»store_true») # Read arguments from the command line args = parser.parse_args() # Check for —version or -V if args.version: print(«This is myprogram version 0.1»)
$ python3 arguments-argparse-optional.py -V This is myprogram version 0.1 $ python3 arguments-argparse-optional.py —version This is myprogram version 0.1
Аргумент –version не требует указания значения в командной строке.
Вот почему мы устанавливаем аргумент действия равным store_true. В других случаях вам может потребоваться дополнительное присвоенное значение, например, если вы укажете определенный объем, высоту или ширину. Это показано в следующем примере. Обратите внимание, что по умолчанию все аргументы интерпретируются, как строки.
# Include standard modules import argparse # Initiate the parser parser = argparse.ArgumentParser() # Add long and short argument parser.add_argument(«—width», «-w», help=»set output width») # Read arguments from the command line args = parser.parse_args() # Check for —width if args.width: print(«Set output width to %s» % args.width)
Здесь мы показываем, что происходит при отправке разных значений аргументов. Сюда входят как краткая, так и полная версия, а также справочное сообщение.
$ python3 arguments-argparse-optional2.py -w 10 Set output width to 10 $ python3 arguments-argparse-optional2.py —width 10 Set output width to 10 $ python3 arguments-argparse-optional2.py -h usage: arguments-argparse-optional2.py [-h] [—width WIDTH] optional arguments: -h, —help show this help message and exit —width WIDTH, -w WIDTH set output width
Заключение
В этой статье мы показали множество различных методов для получения аргументов командной строки в Python, включая использование sys, getopt и argparse.
Эти модули различаются по функциональности, некоторые из них предоставляют гораздо больше, чем другие. sys полностью гибок, тогда как для getopt и argparse требуется некоторая структура. Напротив, они покрывают большую часть сложной работы, которую система оставляет на ваше усмотрение. Проработав предоставленные примеры, вы сможете определить, какой модуль лучше всего подходит для вашего проекта.
Источник: tonais.ru
Изучаем Python: модуль argparse
Если вы занимаетесь обработкой и анализом данных с использованием Python, то вам, рано или поздно, придётся выйти за пределы Jupyter Notebook, преобразовав свой код в скрипты, которые можно запускать средствами командной строки. Здесь вам и пригодится модуль argparse. Для новичков, привыкших к Jupyter Notebook, такой шаг означает необходимость покинуть зону комфорта и перейти в новую среду. Материал, перевод которого мы публикуем сегодня, написан для того, чтобы облегчить подобный переход.
Модуль argparse
Модуль argparse
Модуль argparse можно сравнить с силами природы, которые воздвигли горные пики, возвышающиеся над облаками. Благодаря этому модулю в скриптах становится возможным работа с тем, что, без его использования, было бы скрыто от кода этих скриптов.
Надо отметить, что argparse является рекомендуемым к использованию модулем стандартной библиотеки Python, предназначенным для работы с аргументами командной строки. Мне не удалось найти хорошее руководство по argparse для начинающих, поэтому я и решил написать такое руководство сам.
Жизнь за пределами Jupyter Notebook
Когда я впервые столкнулся с argparse в Python-скрипте, который нужен был мне для проекта, которым я занимался в свободное время, я подумал: «А это что ещё за таинственная конструкция?». После этого я быстро перенёс код в Jupyter Notebook, но такой ход оказался нерациональным.
Мне нужно было, чтобы у меня была возможность просто запустить скрипт, а не работать с ним средствами Jupyter Notebook. Автономным скриптом, в котором использовался модуль argparse, было бы гораздо легче пользоваться, работать над ним было бы проще, чем полагаясь на возможности Jupyter Notebook. Однако тогда я спешил, и, когда взглянул на документацию по argparse, не смог сходу ухватить её суть, поэтому и не стал пользоваться исходной версией скрипта.
С тех пор я разобрался с argparse и этот модуль мне очень понравился. Теперь я считаю его прямо-таки жизненно необходимым. При этом освоить его не так уж и сложно.
Зачем нужен модуль argparse?
Модуль argparse позволяет разбирать аргументы, передаваемые скрипту при его запуске из командной строки, и даёт возможность пользоваться этими аргументами в скрипте. То есть речь идёт о том, что этот модуль позволяет предоставлять скрипту некие данные в момент его запуска, а этими данными скрипт сможет воспользоваться во время выполнения его кода. Модуль argparse — это средство, с помощью которого можно наладить общение между автором программы и тем, кто ей пользуется, например — между вами, когда вы сегодня пишете скрипт, и вами же, когда вы завтра его запускаете, что-то ему передавая.
Использование argparse означает, что, при необходимости изменить поведение скрипта или при необходимости передачи ему неких данных, если это предусмотрено автором скрипта, пользователю не нужно редактировать программный код. В результате скрипты обретают определённый уровень гибкости.
Пример
Предположим, вы хотите написать скрипт для преобразования видеофайлов в обычные изображения с использованием библиотеки OpenCV. Для того чтобы скрипт мог бы решить эту задачу, ему нужно знать место, где хранятся видеофайлы, и место, в которое нужно поместить готовые изображения. То есть, ему требуются сведения о двух папках, пути к которым, что не очень удобно, можно жёстко задать в коде скрипта, или, что уже куда лучше, можно позволить задавать пользователю скрипта, вводя их в качестве аргументов командной строки при запуске скрипта. Для того чтобы оснастить скрипт такой возможностью, нам и пригодится модуль argparse. Вот как может выглядеть раздел скрипта (назовём этот скрипт videos.py ), в котором осуществляется разбор аргументов командной строки:
# videos.py import argparse parser = argparse.ArgumentParser(description=’Videos to images’) parser.add_argument(‘indir’, type=str, help=’Input dir for videos’) parser.add_argument(‘outdir’, type=str, help=’Output dir for image’) args = parser.parse_args() print(args.indir)
Здесь, в начале файла, импортируется модуль argparse. Затем, с использованием конструкции argparse.ArgumentParser() , создаётся объект parser с указанием его описания.
Далее, с помощью метода parser.add_argument() , описывается переменная indir , в которую планируется записать путь к папке с видеофайлами. При этом указывается то, что она имеет строковой тип, а также задаётся справочная информация о ней. После этого, точно так же, создаётся переменная outdir , в которую попадёт путь к папке, в которую скрипт должен будет поместить изображения, созданные на основе видеофайлов. На следующем шаге работы в переменную args попадает результат разбора аргументов командной строки. То, что передано скрипту при запуске, теперь будет доступно в виде свойств indir и outdir объекта args . Теперь с этими значениями можно работать. В данном случае мы просто выводим в консоль то, что передано скрипту в аргументе indir .
Вот как запустить этот скрипт из командной строки:
python videos.py /videos /images
Обратите внимание на то, что строки /videos и /images не нужно заключать в кавычки. Скрипт, запущенный таким образом, выведет в терминал строку /videos , чем подтвердит возможность использования переданных ему аргументов в своём коде. Это — магия argparse в действии.
Магия разбора аргументов командной строки
Подробности об argparse
Только что мы рассмотрели простой пример работы с argparse. Теперь давайте обсудим некоторые подробности, касающиеся argparse.
▍Позиционные аргументы
Конструкция вида 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
В результате оказывается, что для того, чтобы запустить скрипт, в котором предусмотрено использование позиционных аргументов, такие аргументы всегда нужно указывать при его запуске.
▍Необязательные аргументы
Что произойдёт при запуске нашего скрипта командой 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
Для чего ещё можно использовать argparse?
Модуль argparse можно использовать при разработке Python-приложений, которые планируется упаковывать в контейнеры Docker. Так, например, если при запуске приложения, упакованного в контейнер, ему нужно передать аргументы командной строки, то описать это, на этапе сборки контейнера, можно в Dockerfile с помощью инструкции RUN . Для запуска скриптов во время выполнения контейнера можно пользоваться инструкциями CMD или ENTRYPOINT . Подробности о файлах Dockerfile вы можете найти здесь.
Итоги
Как добавить аргументы командной строки в скрипт Python
Е сли вы разработали сценарий Python или приложение, предназначенное для запуска в основном в эмуляторах терминала или даже в приложениях с графическим интерфейсом пользователя, добавление аргументов командной строки может улучшить его удобство использования, читаемость кода, структуру приложения и общее удобство использования приложения для конечных пользователей. Эти аргументы командной строки также называются «параметрами» или «переключателями» и работают аналогично аргументам, которые вы обычно видите в сценариях bash и других программах на C/C ++.
Чтобы добавить аргументы в сценарии Python, вам нужно будет использовать встроенный модуль с именем «argparse». Как следует из названия, он анализирует аргументы командной строки, используемые при запуске скрипта или приложения Python. Эти проанализированные аргументы также проверяются модулем «argparse», чтобы убедиться, что они имеют правильный «тип». Ошибки возникают, если в аргументах есть недопустимые значения.
Использование модуля argparse можно лучше понять на примерах. Ниже приведены несколько примеров кода, которые помогут вам начать работу с модулем argparse.
Пример 1: Создание аргумента и сообщения справки
Рассмотрим пример кода ниже:
import argparse parser = argparse.ArgumentParser(description=’A test program.’) args = parser.parse_args()
Первый оператор импортирует модуль «argparse». Затем создается новый экземпляр объекта «ArgumentParser», и в качестве аргумента предоставляется краткое описание программы. Объект ArgumentParser необходим для преобразования значений аргументов командной строки в типы данных, понятные Python. Это выполняется методом parse_args объекта ArgumentParser, как показано в последнем операторе.
Предполагая, что вы сохранили пример кода, указанный выше, в файле с именем «test.py», выполнение приведенных ниже команд приведет к появлению справочных сообщений, связанных с программой.
$ ./test.py -h $ ./test.py —help
Вы должны получить примерно такой результат:
usage: test.py [-h] A test program. optional arguments: -h, —help show this help message and exit
Обратите внимание, что в упомянутый выше пример кода не добавлена логика для обработки проанализированных аргументов и преобразования их в объекты. Следовательно, справочные сообщения для отдельных аргументов в выводе не отображаются. Как только вы добавите логику для обработки значений анализируемых аргументов в вашу программу, в справочных сообщениях начнется отображение описания отдельных аргументов.
Читать Как получить текущую дату и время в JavaScript?
Пример 2: Обработка строкового аргумента
Чтобы добавить аргументы, приемлемые для вашего скрипта python, вам необходимо использовать метод «add_argument». Взгляните на следующий код:
import argparse parser = argparse.ArgumentParser(description=’A test program.’) parser.add_argument(«print_string», help=»Prints the supplied argument.») args = parser.parse_args() print(args.print_string)
Был добавлен новый оператор, показывающий использование метода «add_argument». Любой аргумент, добавленный при запуске скрипта, будет обрабатываться ArgumentParser как объект «print_string».
Обратите внимание, что по умолчанию метод add_argument обрабатывает значения, полученные из аргументов, как строки, поэтому вам не нужно явно указывать «тип» в этом случае. Значение по умолчанию «Нет» также присваивается добавленным аргументам, если оно не отменено.
Еще раз взгляните на справочное сообщение:
usage: test.py [-h] [print_string] A test program. positional arguments: print_string Prints the supplied argument. optional arguments: -h, —help show this help message and exit
Одна из строк вывода говорит «позиционные аргументы». Поскольку ключевое слово для аргумента не определено, в настоящее время аргумент рассматривается как «позиционный аргумент», где порядок и позиция предоставленного аргумента имеют прямое влияние на программу. Позиционные аргументы также являются обязательными, если вы не измените их поведение вручную.
Чтобы определить и проанализировать необязательные аргументы, вы можете использовать «-» (двойное тире) и изменить их значения по умолчанию, используя аргумент «default».
import argparse parser = argparse.ArgumentParser(description=’A test program.’) parser.add_argument(«—print_string», help=»Prints the supplied argument.», default=”A random string.”) args = parser.parse_args() print(args.print_string)
Теперь, когда вы запускаете скрипт test.py без аргументов, вы должны получить «случайную строку». как выход. Вы также можете дополнительно использовать ключевое слово «–print_string» для печати любой строки по вашему выбору.
$ ./test.py —print_string AndreyEx.ru
AndreyEx.ru
Обратите внимание, что вы можете сделать необязательный аргумент обязательным, используя дополнительный аргумент «required = True».
Наконец, вы также можете определить сокращенные версии аргумента, используя «-» (одиночное тире), чтобы уменьшить многословие.
import argparse parser = argparse.ArgumentParser(description=’A test program.’) parser.add_argument(“-p”, «—print_string», help=»Prints the supplied argument.», default=”A random string.”) args = parser.parse_args() print(args.print_string)
Выполнение следующей команды должно дать тот же результат, что и выше:
$ ./test.py -p AndreyEx.ru
Пример 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)
Читать 5 лучших PHP-фреймворков в 2020 году
Попробуйте выполнить следующую команду:
$ ./test.py -p AndreyEx.ru
Вы должны получить такую ошибку:
usage: test.py [-h] [-p PRINT_STRING] test.py: error: argument -p/—print_string: invalid int value: ‘AndreyEx.ru’
Предоставление целочисленного значения даст вам правильный результат:
$ ./test.py -p 1000
1000
Пример 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”
Вы должны получить примерно такой результат:
Вывод
Модуль «argparse» довольно обширен с множеством опций для настройки поведения приложений командной строки и анализа значений, вводимых пользователем. Эти примеры касаются только базового использования модуля «argparse». Для сложных и сложных приложений вам могут потребоваться разные реализации.
Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.
Источник: andreyex.ru