Como ler os argumentos de linha de comando / processo?

StackOverflow https://stackoverflow.com/questions/1009860

Foi útil?

Solução

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

suportes argparse (entre outras coisas):

  • Várias opções em qualquer ordem.
  • curto e longo opções.
  • Os valores padrão.
  • Geração de uma mensagem de uso ajuda.

Outras dicas

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 indo em torno de evangelização para argparse que é melhor para estas razões .. essencialmente:

(copiado do link)

  • módulo argparse pode lidar com posicional e argumentos opcionais, enquanto optparse só pode tratar opcional argumentos

  • argparse não é sobre dogmática o que sua interface de linha de comando deve ser semelhante - opções como -file ou / arquivo são suportados, como são opções necessárias. Optparse se recusa a suporte a esses recursos, preferindo pureza mais praticidade

  • argparse produz mais mensagens de uso informativos, incluindo uso de linha de comando determinados a partir de seus argumentos e mensagens de ajuda para tanto posicional e opcional argumentos. O módulo optparse requer que você escreva seu próprio uso corda, e não tem nenhuma maneira de exibição ajuda para os argumentos posicionais.

  • suportes argparse ação que consumir um número variável de args de linha de comando, enquanto optparse requer que o número exato de argumentos (por exemplo, 1, 2, ou 3) ser conhecido com antecedência

  • suporta analisadores argparse que despachar a sub-comandos, enquanto optparse requer configuração allow_interspersed_args e fazer a analisador expedição manualmente

E o meu favorito:

  • argparse permite que o tipo e parâmetros de ação para add_argument() a ser especificado com simples chamáveis, enquanto optparse exige atributos classe hacker como STORE_ACTIONS ou CHECK_METHODS para obter verificação argumento adequada

Há também argparse stdlib módulo (um "impovement" módulo optparse do stdlib) . Exemplo de a introdução de 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. Isto irá imprimir o nome do script como o primeiro argumento e todos os outros parâmetros que você passa para ele. 

import sys

for arg in sys.argv:
    print arg

O docopt biblioteca é realmente liso. Ele constrói um dict argumento a partir da cadeia de uso para a sua aplicação.

Por exemplo, a partir do readme 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)

Se você precisa 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)

python main.py James Smith Em seguida, execute

para produzir o seguinte resultado:

Olá James Smith 

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

Eu uso optparse mim, mas realmente gosto da direção Simon Willison está tomando com sua recentemente introduzido optfunc biblioteca. Ele funciona por:

"introspecção uma função definição (incluindo os seus argumentos e seus valores padrão) e usando que para a construção de uma linha de comando analisador de argumento. "

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

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

é transformado em este texto 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 de getopt de 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 sido embrulho algo semelhante a este para tornar as coisas menos detalhada. (Por exemplo, tornando "-h" implícita)

Como você pode ver optparse "O módulo optparse está obsoleta com e não serão mais desenvolvidos, o desenvolvimento vai continuar com a argparse módulo. "

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

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

Você pode estar interessado em um pequeno módulo Python Eu escrevi para fazer manipulação de argumentos de linha de comando ainda mais fácil (código aberto e livre para usar) - Comando

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

docopt é um novo projeto que obras de analisar a sua mensagem de uso --help em vez de exigir que você implementar tudo sozinho. Você apenas tem que colocar a sua mensagem de uso no formato POSIX.

No entanto, outra opção é argh . Baseia-se na argparse, e permite escrever 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 irá gerar automaticamente ajuda e assim por diante, e você pode usar decoradores para fornecer orientação adicional sobre como o arg-análise deve funcionar. 

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

A 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
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top