如何读取/处理命令行参数？

我原本是C程序员。我看到了许多花招和“技巧”来阅读许多不同的论点。

Python程序员可以通过哪些方式做到这一点？

有关

• 获取/解析传递给Python脚本的命令行参数的最佳方法是什么？
• 实现“ [命令] [动作] [参数]”样式的命令行界面？
• 如何在Python中处理命令行参数？
• 如何使用Python的optparse格式化位置参数帮助？

标准库中的规范解决方案是argparse（docs）：

这是一个例子：

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支持消耗可变数量的命令行args的操作，而optparse要求事先知道确切数量的参数（例如1、2或3）

• argparse支持分派到子命令allow_interspersed_args的解析器，而optparse需要手动设置 和执行解析器分派

和我个人最喜欢的：

• argparse允许add_argument() 使用简单的可调用对象来指定类型和操作参数，而optparse则需要侵入类属性，例如 STORE_ACTIONS或CHECK_METHODS进行正确的参数检查。

还有argparsestdlib模块（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自述文件：

"""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，但真的很喜欢Simon Willison在他最近引入的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

我喜欢stdlib中的getopt，例如：

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