Какой самый простой, краткий и самый гибкий метод или библиотека для анализа аргументов командной строки Python?
Какой самый лучший способ разобрать аргументы командной строки?
Ответ 1
Этот ответ предлагает optparse, который подходит для более старых версий Python. Для Python 2.7 и выше argparse заменяет optparse. См. этот ответ для получения дополнительной информации.
Как указывали другие люди, вам лучше идти с optparse over getopt. getopt - это почти однозначное сопоставление стандартных функций библиотеки getopt (3) C и не очень простое в использовании.
optparse, будучи немного более подробным, гораздо лучше структурирован и проще продлить позже.
Здесь типичная строка для добавления опции в ваш синтаксический анализатор:
parser.add_option('-q', '--query',
action="store", dest="query",
help="query string", default="spam")
Это в значительной степени говорит само за себя; во время обработки он принимает -q или -query как опции, сохраняет аргумент в атрибуте, называемом query, и имеет значение по умолчанию, если вы его не укажете. Это также самодокументируется тем, что вы указываете аргумент help (который будет использоваться при запуске с помощью -h/- help) прямо там с опцией.
Обычно вы анализируете свои аргументы с помощью:
options, args = parser.parse_args()
По умолчанию будут проанализированы стандартные аргументы, переданные в script (sys.argv [1:])
options.query будет установлено значение, которое вы передали в script.
Вы создаете парсер просто, делая
parser = optparse.OptionParser()
Это все, что вам нужно. Здесь полный Python script, который показывает это:
import optparse
parser = optparse.OptionParser()
parser.add_option('-q', '--query',
action="store", dest="query",
help="query string", default="spam")
options, args = parser.parse_args()
print 'Query string:', options.query
5 строк питона, которые показывают вам основы.
Сохраните его в sample.py и запустите его один раз с помощью
python sample.py
и один раз с
python sample.py --query myquery
Кроме того, вы обнаружите, что optparse очень легко расширить. В одном из моих проектов я создал класс Command, который позволяет легко встраивать подкоманды в дереве команд. Он использует optparse для объединения команд вместе. Это не то, что я могу легко объяснить в нескольких строках, но не стесняйтесь просматривать в моем репозитории для основного класса, а также класс, который использует его и парсер параметров
Ответ 2
argparse это путь. Вот краткое описание того, как его использовать:
1) Инициализировать
import argparse
# Instantiate the parser
parser = argparse.ArgumentParser(description='Optional app description')
2) Добавить аргументы
# Required positional argument
parser.add_argument('pos_arg', type=int,
help='A required integer positional argument')
# Optional positional argument
parser.add_argument('opt_pos_arg', type=int, nargs='?',
help='An optional integer positional argument')
# Optional argument
parser.add_argument('--opt_arg', type=int,
help='An optional integer argument')
# Switch
parser.add_argument('--switch', action='store_true',
help='A boolean switch')
3) Разбор
args = parser.parse_args()
4) Доступ
print("Argument values:")
print(args.pos_arg)
print(args.opt_pos_arg)
print(args.opt_arg)
print(args.switch)
5) Проверить значения
if args.pos_arg > 10:
parser.error("pos_arg cannot be larger than 10")
Usage
UsageПравильное использование:
$ ./app 1 2 --opt_arg 3 --switch
Argument values:
1
2
3
True
Неверные аргументы:
$ ./app foo 2 --opt_arg 3 --switch
usage: convert [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
app: error: argument pos_arg: invalid int value: 'foo'
$ ./app 11 2 --opt_arg 3
Argument values:
11
2
3
False
usage: app [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
convert: error: pos_arg cannot be larger than 10
Полная помощь:
$ ./app -h
usage: app [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
Optional app description
positional arguments:
pos_arg A required integer positional argument
opt_pos_arg An optional integer positional argument
optional arguments:
-h, --help show this help message and exit
--opt_arg OPT_ARG An optional integer argument
--switch A boolean switch
Ответ 3
Использование docopt
С 2012 года появился очень простой, мощный и действительно классный модуль для анализа аргументов, который называется docopt. Вот пример, взятый из его документации:
"""Naval Fate.
Usage:
naval_fate.py ship new <name>...
naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
naval_fate.py ship shoot <x> <y>
naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
naval_fate.py (-h | --help)
naval_fate.py --version
Options:
-h --help Show this screen.
--version Show version.
--speed=<kn> Speed in knots [default: 10].
--moored Moored (anchored) mine.
--drifting Drifting mine.
"""
from docopt import docopt
if __name__ == '__main__':
arguments = docopt(__doc__, version='Naval Fate 2.0')
print(arguments)
Итак, вот и все: 2 строки кода плюс ваша строка документа, что очень важно, и ваши аргументы будут проанализированы и доступны в вашем объекте аргументов.
Использование python-fire
С 2017 года появился еще один классный модуль под названием python-fire. Он может генерировать интерфейс CLI для вашего кода, когда вы выполняете разбор нулевого аргумента. Вот простой пример из документации (эта небольшая программа предоставляет функцию double командной строке):
import fire
class Calculator(object):
def double(self, number):
return 2 * number
if __name__ == '__main__':
fire.Fire(Calculator)
Из командной строки вы можете запустить:
> calculator.py double 10
20
> calculator.py double --number=15
30
Ответ 4
По этим причинам новый хип-хоп путь - argparse. argparse> optparse> getopt
обновление: Начиная с py2.7 argparse является частью стандартной библиотеки, а optparse устарела.
Ответ 5
Я предпочитаю нажмите. Он абстрагирует параметры управления и позволяет "(...) создавать красивые интерфейсы командной строки с возможностью компоновки с минимальным количеством кода".
Вот пример использования:
import click
@click.command()
@click.option('--count', default=1, help='Number of greetings.')
@click.option('--name', prompt='Your name',
help='The person to greet.')
def hello(count, name):
"""Simple program that greets NAME for a total of COUNT times."""
for x in range(count):
click.echo('Hello %s!' % name)
if __name__ == '__main__':
hello()
Он также автоматически генерирует красиво отформатированные страницы справки:
$ python hello.py --help
Usage: hello.py [OPTIONS]
Simple program that greets NAME for a total of COUNT times.
Options:
--count INTEGER Number of greetings.
--name TEXT The person to greet.
--help Show this message and exit.
Ответ 6
Практически все используют getopt
Вот пример кода для документа:
import getopt, sys
def main():
try:
opts, args = getopt.getopt(sys.argv[1:], "ho:v", ["help", "output="])
except getopt.GetoptError:
# print help information and exit:
usage()
sys.exit(2)
output = None
verbose = False
for o, a in opts:
if o == "-v":
verbose = True
if o in ("-h", "--help"):
usage()
sys.exit()
if o in ("-o", "--output"):
output = a
Итак, одним словом, вот как это работает.
У вас есть два типа опций. Те, кто получает аргументы, и те, кто подобно переключателям.
sys.argv в значительной степени ваш char** argv в C. Как и в C, вы пропускаете первый элемент, который является именем вашей программы, и анализируйте только аргументы: sys.argv[1:]
Getopt.getopt будет анализировать его согласно правилу, которое вы даете в аргументе.
"ho:v" здесь описываются короткие аргументы: -ONELETTER. : означает, что -o принимает один аргумент.
Наконец ["help", "output="] описывает длинные аргументы (--MORETHANONELETTER).
= после вывода еще раз означает, что вывод принимает один аргумент.
В результате получается список пара (параметр, аргумент)
Если параметр не принимает никаких аргументов (например, --help здесь), часть arg представляет собой пустую строку.
Затем вы обычно хотите зациклиться на этом списке и проверить имя параметра, как в примере.
Надеюсь, это помогло вам.
Ответ 7
Используйте optparse, который поставляется со стандартной библиотекой. Например:
#!/usr/bin/env python
import optparse
def main():
p = optparse.OptionParser()
p.add_option('--person', '-p', default="world")
options, arguments = p.parse_args()
print 'Hello %s' % options.person
if __name__ == '__main__':
main()
Источник: Использование Python для создания инструментов командной строки UNIX
Однако, как и для Python 2.7 optparse устарел, см. Зачем использовать argparse, а не optparse?
Ответ 8
На всякий случай вам может понадобиться, это может помочь, если вам нужны аргументы unicode grab для Win32 (2K, XP и т.д.):
from ctypes import *
def wmain(argc, argv):
print argc
for i in argv:
print i
return 0
def startup():
size = c_int()
ptr = windll.shell32.CommandLineToArgvW(windll.kernel32.GetCommandLineW(), byref(size))
ref = c_wchar_p * size.value
raw = ref.from_address(ptr)
args = [arg for arg in raw]
windll.kernel32.LocalFree(ptr)
exit(wmain(len(args), args))
startup()
Ответ 9
Облегченный аргумент командной строки по умолчанию
Хотя argparse великолепен и является правильным ответом для полностью документированных переключателей командной строки и расширенных функций, вы можете использовать значения по умолчанию для аргументов функций, чтобы очень просто обрабатывать прямые позиционные аргументы.
import sys
def get_args(name='default', first='a', second=2):
return first, int(second)
first, second = get_args(*sys.argv)
print first, second
Аргумент 'name' фиксирует имя скрипта и не используется. Результат теста выглядит следующим образом:
> ./test.py
a 2
> ./test.py A
A 2
> ./test.py A 20
A 20
Для простых сценариев, где я просто хочу некоторые значения по умолчанию, я считаю, что этого вполне достаточно. Возможно, вы также захотите включить некоторое приведение типа в возвращаемые значения, иначе значения командной строки будут строками.
Ответ 10
Я предпочитаю optparse to getopt. Он очень декларативный: вы говорите ему имена параметров и эффектов, которые они должны иметь (например, устанавливая логическое поле), и он возвращает вам словарь, заполненный в соответствии с вашими спецификациями.
Ответ 11
Я думаю, что лучший способ для более крупных проектов - оппонент, но если вы ищете простой способ, возможно http://werkzeug.pocoo.org/documentation/script - это что-то для вас.
from werkzeug import script
# actions go here
def action_foo(name=""):
"""action foo does foo"""
pass
def action_bar(id=0, title="default title"):
"""action bar does bar"""
pass
if __name__ == '__main__':
script.run()
Таким образом, в основном каждая функция action_ * отображается в командной строке и хороша справочное сообщение генерируется бесплатно.
python foo.py
usage: foo.py <action> [<options>]
foo.py --help
actions:
bar:
action bar does bar
--id integer 0
--title string default title
foo:
action foo does foo
--name string
Ответ 12
Argparse-код может быть длиннее, чем фактический код реализации!
Проблема, которую я нахожу с большинством популярных вариантов разбора аргументов, заключается в том, что если ваши параметры являются лишь скромными, то код для их документирования становится непропорционально большим в той выгоде, которую они предоставляют.
Относительно новичком в сцене разбора аргументов (я думаю) является plac.
Он делает некоторые признанные компромиссы с argparse, но использует встроенную документацию и оборачивается просто вокруг функции функции типа main():
def main(excel_file_path: "Path to input training file.",
excel_sheet_name:"Name of the excel sheet containing training data including columns 'Label' and 'Description'.",
existing_model_path: "Path to an existing model to refine."=None,
batch_size_start: "The smallest size of any minibatch."=10.,
batch_size_stop: "The largest size of any minibatch."=250.,
batch_size_step: "The step for increase in minibatch size."=1.002,
batch_test_steps: "Flag. If True, show minibatch steps."=False):
"Train a Spacy (http://spacy.io/) text classification model with gold document and label data until the model nears convergence (LOSS < 0.5)."
pass # Implementation code goes here!
if __name__ == '__main__':
import plac; plac.call(main)
Ответ 13
consoleargs заслуживает упоминания здесь. Он очень прост в использовании. Проверьте это:
from consoleargs import command
@command
def main(url, name=None):
"""
:param url: Remote URL
:param name: File name
"""
print """Downloading url '%r' into file '%r'""" % (url, name)
if __name__ == '__main__':
main()
Теперь в консоли:
% python demo.py --help
Usage: demo.py URL [OPTIONS]
URL: Remote URL
Options:
--name -n File name
% python demo.py http://www.google.com/
Downloading url ''http://www.google.com/'' into file 'None'
% python demo.py http://www.google.com/ --name=index.html
Downloading url ''http://www.google.com/'' into file ''index.html''
Ответ 14
Вот метод, а не библиотека, которая, кажется, работает для меня.
Цели здесь должны быть краткими, каждый аргумент анализируется одной строкой, строка args для удобочитаемости, код прост и не зависит от каких-либо специальных модулей (только os + sys), предупреждает о отсутствующих или неизвестные аргументы изящно, используйте простой цикл /range () и работают через python 2.x и 3.x
Показаны два флажка переключения (-d, -v) и два значения, управляемые аргументами (-i xxx и -o xxx).
import os,sys
def HelpAndExit():
print("<<your help output goes here>>")
sys.exit(1)
def Fatal(msg):
sys.stderr.write("%s: %s\n" % (os.path.basename(sys.argv[0]), msg))
sys.exit(1)
def NextArg(i):
'''Return the next command line argument (if there is one)'''
if ((i+1) >= len(sys.argv)):
Fatal("'%s' expected an argument" % sys.argv[i])
return(1, sys.argv[i+1])
### MAIN
if __name__=='__main__':
verbose = 0
debug = 0
infile = "infile"
outfile = "outfile"
# Parse command line
skip = 0
for i in range(1, len(sys.argv)):
if not skip:
if sys.argv[i][:2] == "-d": debug ^= 1
elif sys.argv[i][:2] == "-v": verbose ^= 1
elif sys.argv[i][:2] == "-i": (skip,infile) = NextArg(i)
elif sys.argv[i][:2] == "-o": (skip,outfile) = NextArg(i)
elif sys.argv[i][:2] == "-h": HelpAndExit()
elif sys.argv[i][:1] == "-": Fatal("'%s' unknown argument" % sys.argv[i])
else: Fatal("'%s' unexpected" % sys.argv[i])
else: skip = 0
print("%d,%d,%s,%s" % (debug,verbose,infile,outfile))
Цель NextArg() - вернуть следующий аргумент при проверке отсутствующих данных, а "skip" пропускает цикл, когда используется NextArg(), сохраняя разметку флага до одного лайнера.
Ответ 15
Я расширил подход Erco, чтобы учесть необходимые позиционные аргументы и необязательные аргументы. Они должны предшествовать аргументам -d, -v и т.д.
Позиционные и необязательные аргументы могут быть получены с помощью PosArg (i) и OptArg (i, по умолчанию) соответственно. Когда необязательный аргумент найден, начальная позиция поиска опций (например, -i) перемещается на 1 вперед, чтобы избежать "неожиданного" фатального исхода.
import os,sys
def HelpAndExit():
print("<<your help output goes here>>")
sys.exit(1)
def Fatal(msg):
sys.stderr.write("%s: %s\n" % (os.path.basename(sys.argv[0]), msg))
sys.exit(1)
def NextArg(i):
'''Return the next command line argument (if there is one)'''
if ((i+1) >= len(sys.argv)):
Fatal("'%s' expected an argument" % sys.argv[i])
return(1, sys.argv[i+1])
def PosArg(i):
'''Return positional argument'''
if i >= len(sys.argv):
Fatal("'%s' expected an argument" % sys.argv[i])
return sys.argv[i]
def OptArg(i, default):
'''Return optional argument (if there is one)'''
if i >= len(sys.argv):
Fatal("'%s' expected an argument" % sys.argv[i])
if sys.argv[i][:1] != '-':
return True, sys.argv[i]
else:
return False, default
### MAIN
if __name__=='__main__':
verbose = 0
debug = 0
infile = "infile"
outfile = "outfile"
options_start = 3
# --- Parse two positional parameters ---
n1 = int(PosArg(1))
n2 = int(PosArg(2))
# --- Parse an optional parameters ---
present, a3 = OptArg(3,50)
n3 = int(a3)
options_start += int(present)
# --- Parse rest of command line ---
skip = 0
for i in range(options_start, len(sys.argv)):
if not skip:
if sys.argv[i][:2] == "-d": debug ^= 1
elif sys.argv[i][:2] == "-v": verbose ^= 1
elif sys.argv[i][:2] == "-i": (skip,infile) = NextArg(i)
elif sys.argv[i][:2] == "-o": (skip,outfile) = NextArg(i)
elif sys.argv[i][:2] == "-h": HelpAndExit()
elif sys.argv[i][:1] == "-": Fatal("'%s' unknown argument" % sys.argv[i])
else: Fatal("'%s' unexpected" % sys.argv[i])
else: skip = 0
print("Number 1 = %d" % n1)
print("Number 2 = %d" % n2)
print("Number 3 = %d" % n3)
print("Debug = %d" % debug)
print("verbose = %d" % verbose)
print("infile = %s" % infile)
print("outfile = %s" % outfile)