Как читать / обрабатывать аргументы командной строки?

Я изначально программист на Си. Я видел множество трюков и «хаков», чтобы прочитать много разных аргументов.

Как программисты Python могут это сделать?

связанные с

• Каков наилучший способ получить / проанализировать аргументы командной строки, передаваемые скрипту Python?
• Реализовываете интерфейсы командной строки в стиле «[команда] [действие] [параметр]»?
• Как я могу обработать аргументы командной строки в Python?
• Как мне отформатировать позиционный аргумент, используя optparse в Python?

Каноническое решение в стандартной библиотеке argparse( документы ):

Вот пример:

from argparse import ArgumentParser

parser = ArgumentParser()
parser.add_argument("-f", "--file", dest="filename",
                    help="write report to FILE", metavar="FILE")
parser.add_argument("-q", "--quiet",
                    action="store_false", dest="verbose", default=True,
                    help="don't print status messages to stdout")

args = parser.parse_args()

argparse поддерживает (среди прочего):

• Несколько вариантов в любом порядке.
• Короткие и длинные варианты.
• Значения по умолчанию.
• Генерация сообщения об использовании.

import sys

print("\n".join(sys.argv))

sys.argv список, содержащий все аргументы, переданные сценарию в командной строке

В принципе,

import sys
print(sys.argv[1:])

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

(скопировано по ссылке)

• Модуль argparse может обрабатывать позиционные и необязательные аргументы, тогда как optparse может обрабатывать только необязательные аргументы

• argparse не является догматичным, как должен выглядеть ваш интерфейс командной строки - поддерживаются такие параметры, как -file или / file, а также обязательные параметры. Optparse отказывается поддерживать эти функции, предпочитая чистоту практичности

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

• argparse поддерживает действие, которое использует переменное число аргументов командной строки, в то время как optparse требует, чтобы точное количество аргументов (например, 1, 2 или 3) было известно заранее.

• argparse поддерживает парсеры, которые отправляют подкоманды, в то время как optparse требует установки allow_interspersed_argsи выполнения парсера вручную

И мой личный фаворит:

• argparse позволяет указывать параметры типа и действия add_argument() с помощью простых вызываемых элементов, в то время как optparse требует взлома таких атрибутов класса, как STORE_ACTIONSили, CHECK_METHODSдля правильной проверки аргументов.

Существует также argparseмодуль stdlib («улучшение» в optparseмодуле stdlib ). Пример из введения в argparse :

# script.py
import argparse

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        'integers', metavar='int', type=int, choices=range(10),
         nargs='+', help='an integer in the range 0..9')
    parser.add_argument(
        '--sum', dest='accumulate', action='store_const', const=sum,
        default=max, help='sum the integers (default: find the max)')

    args = parser.parse_args()
    print(args.accumulate(args.integers))

Применение:

$ script.py 1 2 3 4
4

$ script.py --sum 1 2 3 4
10

Один из способов сделать это - использовать sys.argv. Это напечатает имя скрипта в качестве первого аргумента и все остальные параметры, которые вы передаете ему.

import sys

for arg in sys.argv:
    print arg

Библиотека Docopt действительно гладкая. Он создает аргумент dict из строки использования для вашего приложения.

Например, из документа 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)

Если вам нужно что-то быстрое и не очень гибкое

main.py:

import sys

first_name = sys.argv[1]
last_name = sys.argv[2]
print("Hello " + first_name + " " + last_name)

Тогда беги python main.py James Smith

произвести следующий вывод:

Привет Джеймс Смит

#set default args as -h , if no args:
if len(sys.argv) == 1: sys.argv[1:] = ["-h"]

Я сам использую optparse, но мне действительно нравится направление, в котором движется Саймон Виллисон со своей недавно представленной библиотекой optfunc . Работает:

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

Так, например, это определение функции:

def geocode(s, api_key='', geocoder='google', list_geocoders=False):

превращается в этот необязательный текст справки:

    Options:
      -h, --help            show this help message and exit
      -l, --list-geocoders
      -a API_KEY, --api-key=API_KEY
      -g GEOCODER, --geocoder=GEOCODER

Мне нравится getopt из stdlib, например:

try:
    opts, args = getopt.getopt(sys.argv[1:], 'h', ['help'])
except getopt.GetoptError, err: 
    usage(err)

for opt, arg in opts:
    if opt in ('-h', '--help'): 
        usage()

if len(args) != 1:
    usage("specify thing...")

В последнее время я добавлял к этому что-то похожее, чтобы сделать вещи менее многословными (например, сделать «-h» неявным).

Pocoo в щелчке более интуитивный, требует меньше шаблонного, и, по крайней мере , как мощные , как argparse.

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

Как вы можете видеть, optparse «Модуль optparse устарел и не будет дальше разрабатываться; разработка продолжится с модулем argparse ».

import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
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)')

args = parser.parse_args()
print(args.accumulate(args.integers))

Assuming the Python code above is saved into a file called prog.py
$ python prog.py -h

Ref-link: https://docs.python.org/3.3/library/argparse.html

Вас может заинтересовать небольшой модуль Python, который я написал, чтобы сделать обработку аргументов командной строки еще проще (с открытым исходным кодом и бесплатное использование) - Commando

Я рекомендую смотреть на docopt как на простую альтернативу этим другим.

docopt - это новый проект, который работает, анализируя ваше сообщение об использовании --help, а не требует, чтобы вы все реализовали самостоятельно. Вы просто должны поместить свое сообщение об использовании в формате POSIX.

Еще один вариант это Argh . Он основан на argparse и позволяет писать такие вещи, как:

import argh

# declaring:

def echo(text):
    "Returns given word as is."
    return text

def greet(name, greeting='Hello'):
    "Greets the user with given name. The greeting is customizable."
    return greeting + ', ' + name

# assembling:

parser = argh.ArghParser()
parser.add_commands([echo, greet])

# dispatching:

if __name__ == '__main__':
    parser.dispatch()

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

Мое решение - entrypoint2 . Пример:

from entrypoint2 import entrypoint
@entrypoint
def add(file, quiet=True): 
    ''' This function writes report.

    :param file: write report to FILE
    :param quiet: don't print status messages to stdout
    '''
    print file,quiet

текст справки:

usage: report.py [-h] [-q] [--debug] file

This function writes report.

positional arguments:
  file         write report to FILE

optional arguments:
  -h, --help   show this help message and exit
  -q, --quiet  don't print status messages to stdout
  --debug      set logging level to DEBUG