Каков наилучший способ разбора аргументов командной строки? - PullRequest
Новая
       89

Каков наилучший способ разбора аргументов командной строки?

202 голосов
/ 21 августа 2008

Что такое самый простой , tersest и самый гибкий метод или библиотека для анализа аргументов командной строки Python?

Ответы [ 15 ]

172 голосов
/ 28 мая 2015

В других ответах упоминается, что argparse - это путь для нового Python, но не приводятся примеры использования. Для полноты, вот краткий обзор того, как использовать 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")

Использование

Правильное использование: 

$ ./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
163 голосов
/ 26 августа 2008

Этот ответ предполагает optparse, что подходит для более старых версий Python. Для Python 2.7 и выше argparse заменяет optparse. См. этот ответ для получения дополнительной информации.

Как отмечали другие люди, вам лучше использовать optparse вместо getopt. getopt в значительной степени является взаимно-однозначным отображением стандартных функций библиотеки getopt (3) C и не очень прост в использовании.

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

Вот типичная строка для добавления опции в ваш парсер: 

parser.add_option('-q', '--query',
            action="store", dest="query",
            help="query string", default="spam")

Это в значительной степени говорит само за себя; во время обработки он принимает -q или --query в качестве параметров, сохраняет аргумент в атрибуте с именем query и имеет значение по умолчанию, если вы его не указали. Он также самодокументирован, поскольку вы объявляете аргумент справки (который будет использоваться при запуске с -h / - help) прямо здесь с опцией.

Обычно вы анализируете свои аргументы с помощью: 

options, args = parser.parse_args()

По умолчанию это будет синтаксический анализ стандартных аргументов, передаваемых скрипту (sys.argv [1:])

options.query будет затем установлен на значение, которое вы передали в скрипт.

Вы создаете парсер, просто делая 

parser = optparse.OptionParser()

Это все основы, которые вам нужны. Вот полный скрипт Python, который показывает это: 

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 строк Python, которые показывают основы.

Сохраните его в sample.py и запустите один раз с 

python sample.py

и один раз с 

python sample.py --query myquery

Кроме того, вы обнаружите, что optparse очень легко расширить. В одном из моих проектов я создал класс Command, который позволяет вам легко вкладывать подкоманды в дерево команд. Он использует optparse для объединения команд. Это не то, что я могу легко объяснить в нескольких строках, но не стесняйтесь просматривать в моем репозитории для основного класса, а также класс, который его использует, и параметр parser

64 голосов
/ 04 мая 2013

Использование docopt

С 2012 года Python имеет очень простой, мощный и действительно классный модуль для анализа аргументов, который называется docopt . Он работает с Python 2.6 до 3.5 и не требует установки (просто скопируйте его). Вот пример, взятый из его документации: 

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

Удивительно, не правда ли?

36 голосов
/ 11 июня 2009

Новый модный путь - argparse по этим причинам. argparse> optparse> getopt

обновление: По состоянию на py2.7 argparse является частью стандартной библиотеки, а optparse устарело.

19 голосов
/ 21 ноября 2014

Я предпочитаю Нажмите . Он абстрагирует параметры управления и позволяет «(...) создавать красивые интерфейсы командной строки с возможностью компоновки с минимальным количеством кода».

Вот пример использования: 

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.
15 голосов
/ 21 августа 2008

Практически все используют 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 является пустой строкой. Затем вы обычно хотите зациклить этот список и проверить имя опции, как в примере.

Надеюсь, это вам помогло.

14 голосов
/ 21 августа 2008

Используйте 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?

6 голосов
/ 05 апреля 2017

Облегченный аргумент командной строки по умолчанию

Хотя 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

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

6 голосов
/ 21 августа 2008

На всякий случай может понадобиться, если вам нужно захватить аргументы юникода в 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()
4 голосов
/ 27 августа 2008

Я думаю, что лучший способ для крупных проектов - это optparse, но если вы ищете легкий путь, возможно, 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
Страница:
...