Como ler os argumentos de linha de comando / processo?
-
06-07-2019 - |
Pergunta
Eu sou originalmente um programador C. Já vi inúmeros truques e "hacks" para ler muitos argumentos diferentes.
Quais são algumas das maneiras programadores Python pode fazer isso?
Relacionados
- Qual é a melhor maneira de / argumentos de linha de comando de análise garra passado para um script Python?
- Implementação de um “[comando] [ação] [parâmetro ]”estilo interface de linha de comando?
- Como posso processar argumentos de linha de comando em Python?
- Como faço para formatar ajuda argumento posicional utilizando Python optparse?
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 comoSTORE_ACTIONS
ouCHECK_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)
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