Разбор параметров командной строки в Python
Как вы, наверное, знаете, все программы можно условно разделить на консольные и использующие графический интерфейс (сервисы под Windows и демоны под Linux не будем брать в расчет). Параметры запуска, задаваемые через командную строку, чаще всего используют консольные программы, хотя программы с графическим интерфейсом тоже не брезгуют этой возможностью. Наверняка в жизни каждого программиста была ситуация, когда приходилось разбирать параметры командной строки, как правило, это не самая интересная часть программы, но без нее не обойтись. Эта статья посвящена тому, как Python облегчает жизнь программистам при решении этой задачи благодаря своей стандартной библиотеке argparse.
В дальнейшем все примеры я буду приводить с расчетом на Python 3.3, но практически все то же самое можно использовать и в Python 2.7, хотя для запуска на Python 2.7 примеры придется исправить, в основном добавить символ «u» перед началом строк.
Примеры без использования argparse
Путь для начала у нас есть простейший скрипт на Python. Для определенности назовем скрипт coolprogram.py, это будет классический Hello World, над которым мы будем работать в дальнейшем.
#!/usr/bin/python
# -*- coding: UTF-8 -*-
if __name__ == «__main__» :
print ( «Привет, мир!» )
Мы завершили эту сложнейшую программу и отдали ее заказчику, он доволен, но просит добавить в нее возможность указывать имя того, кого приветствуем, причем этот параметр может быть не обязательным. Т.е. программа может использоваться двумя путями:
$ python coolprogram.py Вася
Первое, что приходит на ум при решении такой задачи, просто воспользоваться переменной argv из модуля sys. Напомню, что sys.argv содержит список параметров, переданных программе через командную строку, причем нулевой элемент списка — это имя нашего скрипта. Т.е. если у нас есть следующий скрипт с именем params.py:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
if __name__ == «__main__» :
for param in sys . argv :
print ( param )
и мы запускаем его с помощью команды
то в консоль будет выведена единственная строка:
Если же мы добавим несколько параметров,
то эти параметры мы увидим в списке sys.argv, начиная с первого элемента:
Здесь можно обратить внимание на то, что ссылка на интерпретатор Python в список этих параметров не входит, хотя он также присутствует в строке вызова нашего скрипта.
Вернемся к нашей задаче. Погрузившись в код на неделю, мы могли бы выдать заказчику следующий скрипт:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
if __name__ == «__main__» :
if len ( sys . argv ) > 1 :
print ( «Привет, <>!» . format ( sys . argv [ 1 ] ) )
else :
print ( «Привет, мир!» )
Теперь, если программа вызывается с помощью команды
то результат будет прежний
а если мы добавим параметр:
то программа поприветствует некоего Васю:
Пока все легко и никаких проблем не возникает. Теперь предположим, что требования заказчика вновь изменились, и на этот раз он хочет, чтобы имя приветствуемого человека передавалось после именованного параметра —name или -n, причем нужно следить, что в командной строке передано только одно имя. С этого момента у нас начнется вермишель из конструкций if.
#!/usr/bin/python
# -*- coding: UTF-8 -*-
if __name__ == «__main__» :
if len ( sys . argv ) == 1 :
print ( «Привет, мир!» )
else :
if len ( sys . argv ) < 3 :
print ( «Ошибка. Слишком мало параметров.» )
sys . exit ( 1 )
if len ( sys . argv ) > 3 :
print ( «Ошибка. Слишком много параметров.» )
sys . exit ( 1 )
param_name = sys . argv [ 1 ]
param_value = sys . argv [ 2 ]
if ( param_name == «—name» or
param_name == «-n» ) :
print ( «Привет, <>!» . format ( param_value ) )
else :
print ( «Ошибка. Неизвестный параметр ‘<>‘» . format ( param_name ) )
sys . exit ( 1 )
Здесь мы проверяем ситуацию, что мы вообще не передали ни одного параметра, потом проверяем, что дополнительных параметров у нас ровно два, что они называются именно —name или -n, и, если нас все устраивает, выводим приветствие.
Как видите, код превратился в тихий ужас. Изменить логику работы в нем в дальнейшем будет очень сложно, а при увеличении количества параметров нужно будет срочно применять объектно-ориентированные меры по отделению логики работы программы от разбора командной строки. Разбор командной строки мы могли бы выделить в отдельный класс (или классы), но мы этого здесь делать не будем, поскольку все уже сделано в стандартной библиотеке Python, которая называется argparse.
Использование библиотеки argparse
Первый пример
Как как было сказано выше, стандартная библиотека argparse предназначена для облегчения разбора командной строки. На нее можно возложить проверку переданных параметров: их количество и обозначения, а уже после того, как эта проверка будет выполнена автоматически, использовать полученные параметры в логике своей программы.
Основой работы с командной строкой в библиотеке argparse является класс ArgumentParser. У его конструктора и методов довольно много параметров, все их рассматривать не будем, поэтому в дальнейшем рассмотрим работу этого класса на примерах, попутно обсуждая различные параметры.
Простейший принцип работы с argparse следующий:
- Создаем экземпляр класса ArgumentParser.
- Добавляем в него информацию об ожидаемых параметрах с помощью метода add_argument (по одному вызову на каждый параметр).
- Разбираем командную строку с помощью метода parse_args, передавая ему полученные параметры командной строки (кроме нулевого элемента списка sys.argv).
- Начинаем использовать полученные параметры.
Для начала перепишем программу coolprogram.py с единственным параметром так, чтобы она использовала библиотеку argparse. Напомню, что в данном случае мы ожидаем следующий синтаксис параметров:
Здесь [Имя] является необязательным параметром.
Наша программа с использованием argparse может выглядеть следующим образом:
На первый взгляд эта программа работает точно так же, как и раньше, хотя есть отличия, но мы их рассмотрим чуть позже. Пока разберемся с тем, что мы понаписали в программе.
Создание парсера вынесено в отдельную функцию, поскольку эта часть программы в будущем будет сильно изменяться и разрастаться. На строке 9 мы создали экземпляр класса ArgumentParser с параметрами по умолчанию. Что это за параметры, опять же, поговорим чуть позже.
На строке 10 мы добавили ожидаемый параметр в командной строке с помощью метода add_argument. При этом такой параметр будет считаться позиционным, т.е. он должен стоять именно на этом месте и у него не будет никаких предварительных обозначений (мы их добавим позже в виде ‘-n’ или ‘—name’). Если бы мы не добавили именованный параметр nargs=’?‘, то этот параметр был бы обязательным. nargs может принимать различные значения. Если бы мы ему присвоили целочисленное значение больше 0, то это бы означало, что мы ожидаем ровно такое же количество передаваемых параметров (точнее, считалось бы, что первый параметр ожидал бы список из N элементов, разделенных пробелами, этот случай мы рассмотрим позже). Также этот параметр может принимать значение ‘?’, ‘+’, ‘*’ и argparse.REMAINDER. Мы их не будем рассматривать, поскольку они важны в сочетании с необязательными именованными параметрами, которые могут располагаться как до, так и после нашего позиционного параметра. Тогда этот параметр будет показывать как интерпретировать список параметров, где будет заканчиваться один список параметров и начинаться другой.
Итак, мы создали парсер, после чего можно вызвать его метод parse_args для разбора командной строки. Если мы не укажем никакого параметра, это будет равносильно тому, что мы передадим в него все параметры из sys.argv кроме нулевого, который содержит имя нашей программы. т.е.
В качестве результата мы получим экземпляр класса Namespace, который будет содержать в качестве члена имя нашего параметра. Теперь можно раскомментировать строку 19 в приведенном выше примере, чтобы посмотреть, чему же равны наши параметры.
Если мы это сделаем и запустим программу с переданным параметром
Аргументы командной строки в Python
Практически все языки программирования поддерживают аргументы командной строки. Кроме того, у нас есть параметры командной строки для установки некоторых конкретных параметров программы.
Что такое аргументы командной строки в Python?
Аргументы командной строки Python – это входные параметры, передаваемые скрипту при их выполнении.
Есть много вариантов чтения аргументов командной строки в python. Три самых распространенных модуля:
Давайте рассмотрим простую программу, чтобы узнать, как читать и использовать аргументы командной строки в python.
Модуль sys
Модуль sys в Python хранит аргументы командной строки в списке, мы можем получить к нему доступ с помощью sys.argv. Это очень полезный и простой способ читать аргументы командной строки, как String. Давайте посмотрим на простой пример чтения и печати аргументов командной строки с использованием данного модуля.
import sys print(type(sys.argv)) print('The command line arguments are:') for i in sys.argv: print(i) Изображение ниже иллюстрирует результат выполнения примера выполнения вышеуказанной программы:
Модуль getopt
Модуль getopt очень похож по работе с функцией getopt() для анализа параметров командной строки.
Модуль полезен при анализе аргументов командной строки, где мы хотим, чтобы пользователь также вводил некоторые параметры. Давайте посмотрим на простой пример, чтобы понять это.
import getopt import sys argv = sys.argv[1:] try: opts, args = getopt.getopt(argv, 'hm:d', ['help', 'my_file=']) print(opts) print(args) except getopt.GetoptError: # Print a message or do something useful print('Something went wrong!') sys.exit(2) Приведенный выше пример очень прост, но мы можем легко расширить его для выполнения различных задач. Например, если передана опция справки, напечатайте какое-нибудь удобное сообщение и выйдите. Здесь модуль getopt автоматически проанализирует значение параметра и отобразит их. На изображении ниже показан пример выполнения.
Модуль argparse
Модуль argparse является предпочтительным способом анализа аргументов командной строки. Он предоставляет множество опций, таких как позиционные аргументы, значение по умолчанию для аргументов, справочное сообщение, указание типа данных и т.д. В самой простой форме мы можем использовать его, как показано ниже.
import argparse parser = argparse.ArgumentParser() parser.parse_args()
Ниже приведены результаты быстрого запуска вышеуказанного сценария:
Это все, что касается различных параметров чтения и анализа аргументов командной строки в python, вы должны решить, какой из них соответствует вашим конкретным требованиям, и затем использовать его.