Como ler / processar argumentos de linha de comando?

Eu sou originalmente um programador C. Eu já vi vários truques e "hacks" para ler muitos argumentos diferentes.

Quais são algumas das maneiras pelas quais os programadores de Python podem fazer isso?

Relacionado

• Qual é a melhor maneira de capturar / analisar argumentos da linha de comando passados ​​para um script Python?
• Implementando interfaces de linha de comando no estilo “[comando] [ação] [parâmetro]”?
• Como processar argumentos de linha de comando no Python?
• Como formatar argumentos posicionais ajuda a usar a opção optparse do Python?

A solução canônica na biblioteca padrão é argparse( docs ):

Aqui está um exemplo:

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 suporta (entre outras coisas):

• Várias opções em qualquer ordem.
• Opções curtas e longas.
• Valores padrão.
• Geração de uma mensagem de ajuda de uso.

import sys

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

sys.argv é uma lista que contém todos os argumentos passados ​​para o script na linha de comando.

Basicamente,

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

Apenas por aí evangelizando por argparse, o que é melhor para esses motivos .. essencialmente:

(copiado do link)

• O módulo argparse pode manipular argumentos posicionais e opcionais, enquanto o optparse pode manipular apenas argumentos opcionais

• argparse não é dogmático sobre como deve ser sua interface de linha de comando - opções como -file ou / file são suportadas, assim como as opções necessárias. A Optparse se recusa a oferecer suporte a esses recursos, preferindo pureza a praticidade

• argparse produz mensagens de uso mais informativas, incluindo o uso da linha de comando determinado a partir de seus argumentos, e ajuda mensagens para argumentos posicionais e opcionais. O módulo optparse exige que você escreva sua própria cadeia de uso e não tem como exibir ajuda para argumentos posicionais.

• argparse suporta ações que consomem um número variável de argumentos da linha de comando, enquanto o optparse exige que o número exato de argumentos (por exemplo, 1, 2 ou 3) seja conhecido antecipadamente

• O argparse suporta analisadores que despacham para subcomandos, enquanto o optparse requer a configuração allow_interspersed_argse a execução do despacho do analisador manualmente

E meu favorito pessoal:

• argparse permite que os parâmetros de tipo e ação add_argument() sejam especificados com chamadas simples, enquanto o optparse requer atributos de classe de hackers como STORE_ACTIONSou CHECK_METHODSpara obter uma verificação de argumento adequada

Há também argparse módulo stdlib (um "aprimoramento" no optparsemódulo stdlib ). Exemplo da introdução ao 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))

Uso:

$ script.py 1 2 3 4
4

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

Uma maneira de fazer isso é usando sys.argv. Isso imprimirá o nome do script como o primeiro argumento e todos os outros parâmetros que você passar para ele.

import sys

for arg in sys.argv:
    print arg

A biblioteca docopt é realmente boa. Ele cria um argumento de argumento a partir da cadeia de uso do seu aplicativo.

Por exemplo, do documento 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)

Se você precisar de algo rápido e não muito flexível

main.py:

import sys

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

Então corra python main.py James Smith

para produzir a seguinte saída:

Olá James Smith

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

Eu mesmo uso o optparse, mas gosto muito da direção que Simon Willison está tomando com sua recentemente introduzida biblioteca optfunc . Funciona por:

"inspecionando uma definição de função (incluindo seus argumentos e seus valores padrão) e usando isso para construir um analisador de argumentos de linha de comando."

Então, por exemplo, esta definição de função:

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

é transformado neste texto de ajuda optparse:

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

Eu gosto do getopt do stdlib, por exemplo:

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

Ultimamente, tenho envolvido algo semelhante a isso para tornar as coisas menos detalhadas (por exemplo, tornando implícito "-h").

De Pocoo clique é mais intuitivo, requer menos clichê e é pelo menos tão poderoso quanto o argparse.

A única fraqueza que encontrei até agora é que você não pode fazer muita personalização para ajudar as páginas, mas isso geralmente não é um requisito e o docopt parece ser a escolha certa .

Como você pode ver optparse "O módulo optparse foi descontinuado e não será desenvolvido mais; o desenvolvimento continuará com o módulo 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

Você pode estar interessado em um pequeno módulo Python que escrevi para facilitar ainda mais o manuseio de argumentos de linha de comando (código aberto e livre para usar) - Comando

Eu recomendo olhar docopt como uma alternativa simples para esses outros.

O docopt é um novo projeto que funciona analisando sua mensagem de uso --help, em vez de exigir que você implemente tudo sozinho. Você apenas precisa colocar sua mensagem de uso no formato POSIX.

Ainda outra opção é argh . Ele se baseia no argparse e permite que você escreva coisas como:

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

Ele gera automaticamente ajuda e assim por diante, e você pode usar decoradores para fornecer orientações extras sobre como a análise de argumentos deve funcionar.

Minha solução é entrypoint2 . Exemplo:

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

Texto de ajuda:

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