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

Question

Изначально я программист на языке Си.Я видел множество трюков и "взломов" для чтения множества различных аргументов.

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

Похожие

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

Answer 1

Каноническим решением в стандартной библиотеке является 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 поддержка (среди прочего):

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

Answer 2

import sys

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

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

В основном,

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

Answer 3

Просто ходил повсюду, проповедуя евангелие для 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 чтобы получить правильную проверку аргументов

Answer 4

Существует также argparse модуль stdlib ("обеднение" в stdlib optparse модуль).Пример из введение в 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

Answer 5

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

import sys

for arg in sys.argv:
    print arg

Answer 6

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

Например, из docopt readme:

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

Answer 7

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

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

чтобы получить следующий результат:

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

Answer 8

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

Answer 9

Я сам использую optparse, но мне действительно нравится направление, в котором Саймон Уиллисон использует свой недавно представленный дополнительная функция библиотека.Это работает с помощью:

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

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

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

преобразуется в этот текст справки optparse:

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

Answer 10

Мне нравится 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" неявным).

Answer 11

Как вы можете видеть optparse ( выборочный анализ ) "Модуль optparse устарел и не будет разрабатываться в дальнейшем;разработка будет продолжена с argparse ( аргумент ) модуль".

Answer 12

Покоо щелчок является более интуитивно понятным, требует меньше шаблонности и, по крайней мере, столь же мощным, как argparse.

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

Answer 13

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

Answer 14

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

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

Answer 15

Еще одним вариантом является аргх.Он основан на 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()

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

Answer 16

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

Answer 17

Мое решение таково точка входа 2.Пример:

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