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

import sys

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

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

по сути,

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

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

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

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

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

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

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

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

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

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

появилась argparse модуль stdlib ("impovement" на 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

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

import sys

for arg in sys.argv:
    print arg

на docopt библиотека действительно ловкач. Он создает аргумент 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)

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

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

превращается в эту справку optparse текст:

    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" неявным).

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

Pocoo это клик более интуитивно понятен, требует меньше шаблонности и, по крайней мере, так же силен, как argparse.

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

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

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

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

еще один вариант черт. Он основан на 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-синтаксический анализ.

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

мое решение-это 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