Exemplo simples de argparse: 1 argumento, 3 resultados

A documentação para o módulo python argparse , embora excelente, tenho certeza, é demais para o meu pequeno cérebro iniciante entender agora. Não preciso fazer contas na linha de comando nem interferir com as linhas de formatação na tela ou alterar os caracteres das opções. Tudo o que eu quero fazer é "Se arg é A, faça isso, se B fizer isso, se nenhuma das opções acima mostrar ajuda e sair" .

Minha compreensão da pergunta original é dupla. Primeiro, em termos do exemplo de argumento mais simples possível, estou surpreso por não ter visto aqui. É claro que, para simplificar, também está tudo sobrecarregado com pouco poder, mas pode ajudar você a começar.

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("a")
args = parser.parse_args()

if args.a == 'magic.name':
    print 'You nailed it!'

Mas esse argumento posicional é agora necessário. Se você deixar de fora ao chamar este programa, receberá um erro sobre a falta de argumentos. Isso me leva à segunda parte da pergunta original. Matt Wilkie parece querer um único argumento opcional sem um rótulo nomeado (os rótulos --option). Minha sugestão seria modificar o código acima da seguinte maneira:

...
parser.add_argument("a", nargs='?', default="check_string_for_empty")
...
if args.a == 'check_string_for_empty':
    print 'I can tell that no argument was given and I can deal with that here.'
elif args.a == 'magic.name':
    print 'You nailed it!'
else:
    print args.a

Pode muito bem haver uma solução mais elegante, mas isso funciona e é minimalista.

Aqui está a maneira como eu faço isso argparse(com vários argumentos):

parser = argparse.ArgumentParser(description='Description of your program')
parser.add_argument('-f','--foo', help='Description for foo argument', required=True)
parser.add_argument('-b','--bar', help='Description for bar argument', required=True)
args = vars(parser.parse_args())

args será um dicionário que contém os argumentos:

if args['foo'] == 'Hello':
    # code here

if args['bar'] == 'World':
    # code here

No seu caso, basta adicionar apenas um argumento.

A argparsedocumentação é razoavelmente boa, mas deixa de fora alguns detalhes úteis que podem não ser óbvios. (@ Diego Navarro já mencionou um pouco disso, mas tentarei expandir um pouco sua resposta.) O uso básico é o seguinte:

parser = argparse.ArgumentParser()
parser.add_argument('-f', '--my-foo', default='foobar')
parser.add_argument('-b', '--bar-value', default=3.14)
args = parser.parse_args()

O objeto do qual você volta parse_args() é um objeto 'Namespace': um objeto cujas variáveis ​​de membro são nomeadas após os argumentos da linha de comando. O Namespaceobjetivo é como você acessa seus argumentos e os valores associados a eles:

args = parser.parse_args()
print args.my_foo
print args.bar_value

(Observe que argparsesubstitui '-' nos nomes dos argumentos por sublinhados ao nomear as variáveis.)

Em muitas situações, você pode querer usar argumentos simplesmente como sinalizadores que não têm valor. Você pode adicionar aqueles no argparse assim:

parser.add_argument('--foo', action='store_true')
parser.add_argument('--no-foo', action='store_false')

O exemplo acima criará variáveis ​​nomeadas 'foo' com o valor True e 'no_foo' com o valor False, respectivamente:

if (args.foo):
    print "foo is true"

if (args.no_foo is False):
    print "nofoo is false"

Observe também que você pode usar a opção "obrigatório" ao adicionar um argumento:

parser.add_argument('-o', '--output', required=True)

Dessa forma, se você omitir esse argumento na linha de comando argparse , ele faltará e interromperá a execução do seu script.

Por fim, observe que é possível criar uma estrutura de ditado para seus argumentos usando a varsfunção, se isso facilitar a vida para você.

args = parser.parse_args()
argsdict = vars(args)
print argsdict['my_foo']
print argsdict['bar_value']

Como você pode ver, vars retorna um ditado com seus nomes de argumento como chaves e seus valores como, er, valores.

Existem muitas outras opções e coisas que você pode fazer, mas isso deve abranger os cenários de uso comuns mais essenciais.

Matt está perguntando sobre parâmetros posicionais em argparse, e eu concordo que a documentação do Python está ausente nesse aspecto. Não há um exemplo completo e único nas ~ 20 páginas ímpares que mostram a análise e o uso de parâmetros posicionais .

Nenhuma das outras respostas aqui mostra um exemplo completo de parâmetros posicionais, então aqui está um exemplo completo:

# tested with python 2.7.1
import argparse

parser = argparse.ArgumentParser(description="An argparse example")

parser.add_argument('action', help='The action to take (e.g. install, remove, etc.)')
parser.add_argument('foo-bar', help='Hyphens are cumbersome in positional arguments')

args = parser.parse_args()

if args.action == "install":
    print("You asked for installation")
else:
    print("You asked for something other than installation")

# The following do not work:
# print(args.foo-bar)
# print(args.foo_bar)

# But this works:
print(getattr(args, 'foo-bar'))

O que me impressionou é que o argparse converterá o argumento nomeado "--foo-bar" em "foo_bar", mas um parâmetro posicional chamado "foo-bar" permanece como "foo-bar", tornando menos óbvio como use-o no seu programa.

Observe as duas linhas próximas ao final do meu exemplo - nenhuma delas funcionará para obter o valor do parâmetro posicional foo-bar. O primeiro está obviamente errado (é uma expressão aritmética args.foo menos barra), mas o segundo também não funciona:

AttributeError: 'Namespace' object has no attribute 'foo_bar'

Se você deseja usar o foo-baratributo, deve usá-lo getattr, como visto na última linha do meu exemplo. O que é louco é que, se você tentasse dest=foo_baralterar o nome da propriedade para algo mais fácil de acessar, receberia uma mensagem de erro realmente bizarra:

ValueError: dest supplied twice for positional argument

Veja como o exemplo acima é executado:

$ python test.py
usage: test.py [-h] action foo-bar
test.py: error: too few arguments

$ python test.py -h
usage: test.py [-h] action foo-bar

An argparse example

positional arguments:
  action      The action to take (e.g. install, remove, etc.)
  foo-bar     Hyphens are cumbersome in positional arguments

optional arguments:
  -h, --help  show this help message and exit

$ python test.py install foo
You asked for installation
foo

Mais uma introdução resumida, inspirada neste post .

import argparse

# define functions, classes, etc.

# executes when your script is called from the command-line
if __name__ == "__main__":

    parser = argparse.ArgumentParser()
    #
    # define each option with: parser.add_argument
    #
    args = parser.parse_args() # automatically looks at sys.argv
    #
    # access results with: args.argumentName
    #

Os argumentos são definidos com combinações do seguinte:

parser.add_argument( 'name', options... )              # positional argument
parser.add_argument( '-x', options... )                # single-char flag
parser.add_argument( '-x', '--long-name', options... ) # flag with long name

As opções comuns são:

• ajuda : descrição para este argumento quando--help é usado.
• padrão : valor padrão se o argumento for omitido.
• tipo : se você espera um floatou int(caso contrário, éstr ).
• dest : dê um nome diferente para uma bandeira (por exemplo '-x', '--long-name', dest='longName').
  Nota: por padrão, --long-nameé acessado comargs.long_name
• ação : para tratamento especial de certos argumentos
  • store_true, store_false: para args booleanos
    '--foo', action='store_true' => args.foo == True
  • store_const: para ser usado com a opçãoconst
'--foo', action='store_const', const=42 => args.foo == 42
  • count: para opções repetidas, como em./myscript.py -vv
'-v', action='count' => args.v == 2
  • append: para opções repetidas, como em./myscript.py --foo 1 --foo 2
'--foo', action='append' => args.foo == ['1', '2']
• requeridos : se um sinalizador é necessário ou um argumento posicional não é.
• nargs : para uma bandeira capturar N args
  ./myscript.py --foo a b => args.foo = ['a', 'b']
• opções : para restringir possíveis entradas (especifique como lista de strings, ou ints se type=int).

Observe o Tutorial Argparse nos HOWTOs do Python . Começa a partir dos exemplos mais básicos, como este:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
args = parser.parse_args()
print(args.square**2)

e progride para menos básicos.

Há um exemplo com escolha predefinida para uma opção, como o que é perguntado:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbosity", type=int, choices=[0, 1, 2],
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
    print("the square of {} equals {}".format(args.square, answer))
elif args.verbosity == 1:
    print("{}^2 == {}".format(args.square, answer))
else:
    print(answer)

Aqui está o que eu criei no meu projeto de aprendizagem, graças principalmente a @DMH ...

Código de demonstração:

import argparse

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-f', '--flag', action='store_true', default=False)  # can 'store_false' for no-xxx flags
    parser.add_argument('-r', '--reqd', required=True)
    parser.add_argument('-o', '--opt', default='fallback')
    parser.add_argument('arg', nargs='*') # use '+' for 1 or more args (instead of 0 or more)
    parsed = parser.parse_args()
    # NOTE: args with '-' have it replaced with '_'
    print('Result:',  vars(parsed))
    print('parsed.reqd:', parsed.reqd)

if __name__ == "__main__":
    main()

Isso pode ter evoluído e está disponível online: command-line.py

Script para treinar este código: command-line-demo.sh

Você também pode usar plac (um invólucro em torno deargparse ).

Como um bônus, ele gera instruções simples de ajuda - veja abaixo.

Script de exemplo:

#!/usr/bin/env python3
def main(
    arg: ('Argument with two possible values', 'positional', None, None, ['A', 'B'])
):
    """General help for application"""
    if arg == 'A':
        print("Argument has value A")
    elif arg == 'B':
        print("Argument has value B")

if __name__ == '__main__':
    import plac
    plac.call(main)

Exemplo de saída:

Nenhum argumento fornecido - example.py :

usage: example.py [-h] {A,B}
example.py: error: the following arguments are required: arg

Argumento inesperado fornecido - example.py C :

usage: example.py [-h] {A,B}
example.py: error: argument arg: invalid choice: 'C' (choose from 'A', 'B')

Argumento correto fornecido - example.py A :

Argument has value A

Menu de ajuda completo (gerado automaticamente) - example.py -h :

usage: example.py [-h] {A,B}

General help for application

positional arguments:
  {A,B}       Argument with two possible values

optional arguments:
  -h, --help  show this help message and exit

Breve explicação:

O nome do argumento geralmente é igual ao nome do parâmetro (arg ).

A anotação de tupla após o argparâmetro tem o seguinte significado:

• Descrição ( Argument with two possible values)
• Tipo de argumento - um de 'sinalizador', 'opção' ou 'posicional' ( positional)
• Abreviação ( None)
• Tipo de valor do argumento - por exemplo. flutuante, string ( None)
• Conjunto restrito de opções ( ['A', 'B'])

Documentação:

Para saber mais sobre o uso do plac, confira a excelente documentação:

Plac: Analisando a linha de comando da maneira mais fácil

Para adicionar ao que outros declararam:

Eu geralmente gosto de usar o parâmetro 'dest' para especificar um nome de variável e, em seguida, usar 'globals (). Update ()' para colocar essas variáveis ​​no espaço de nomes global.

Uso:

$ python script.py -i "Hello, World!"

Código:

...
parser.add_argument('-i', '--input', ..., dest='inputted_variable',...)
globals().update(vars(parser.parse_args()))
...
print(inputted_variable) # Prints "Hello, World!"

Uma maneira realmente simples de usar argparse e alterar as opções '-h' / '--help' para exibir suas próprias instruções de ajuda de código pessoal é definir a ajuda padrão como False; você também pode adicionar quantos .add_arguments adicionais desejar :

import argparse

parser = argparse.ArgumentParser(add_help=False)

parser.add_argument('-h', '--help', action='help',
                help='To run this script please provide two arguments')
parser.parse_args()

Execute: python test.py -h

Resultado:

usage: test.py [-h]

optional arguments:
  -h, --help  To run this script please provide two arguments

A resposta mais simples!

PS quem escreveu o documento de argparse é tolo

código python:

import argparse
parser = argparse.ArgumentParser(description='')
parser.add_argument('--o_dct_fname',type=str)
parser.add_argument('--tp',type=str)
parser.add_argument('--new_res_set',type=int)
args = parser.parse_args()
o_dct_fname = args.o_dct_fname
tp = args.tp
new_res_set = args.new_res_set

código em execução

python produce_result.py --o_dct_fname o_dct --tp father_child --new_res_set 1