Análise de argumentos em Python

Se você está planejando um projeto de ciência de dados ou de machine learning, não é raro começar o desenvolvimento em um Jupyter Notebook. Ele traz interatividade, permite executar módulos rapidamente e muito mais. Há muitos motivos para escolher o Jupyter Notebook como sua ferramenta principal, especialmente para ciência de dados e machine learning. No entanto, este tutorial não vai se aprofundar nesse aspecto.

Considere que você precisa executar um script Python como um job em lote para ingestão de dados no seu projeto de ciência de dados. Ou que precisa rodar um script Python para fazer o deploy de um modelo de machine learning em um servidor remoto. Em casos assim, apenas executar python your_script.py pode não ser suficiente. Talvez você precise passar mais opções ou argumentos junto com python your_script.py. Você provavelmente já está familiarizado com o uso de argumentos extras ao rodar comandos (como ps, ls etc.) em um terminal Linux.

Neste tutorial, você vai aprender a analisar argumentos adicionais e opções da linha de comando que são passados junto com um script Python. Aqui vai um resumo do que veremos hoje:

• Uma introdução básica à análise de argumentos
• Análise de argumentos em Python
  • Usando sys.argv
  • Usando getopt
  • Usando argparse

Observação: este tutorial pressupõe familiaridade básica com Python.

O que é análise de argumentos?

Se você usa Linux, aposto que isso já é familiar. Para obter um resumo dos arquivos e pastas presentes em um diretório, o comando ls é frequentemente utilizado. Uma saída típica do comando ls é assim:

No entanto, você pode fornecer várias opções ao comando ls, como -l, por exemplo. Veja como fica a saída:

Ao passar a opção -l, você obteve mais informações. Agora, há uma pequena diferença entre uma opção e um argumento nesse contexto. Para remover um arquivo ou pasta do diretório atual, usa-se o comando rm. Suponha que você tenha um arquivo de texto chamado demo.txt e executou rm demo.txt para removê-lo. Nesse caso, demo.txt é o argumento aplicado ao comando rm. Se você não passar nenhum argumento para o rm, verá um erro como este:

Então, qual é a diferença entre uma opção e um argumento? Ela agora está bem clara. Opções são opcionais, enquanto argumentos (geralmente) são necessários. Não é essencial passar nada para o comando ls para que ele produza alguma saída.

Quando você digita ls -l ou rm demo.txt, o sistema operacional faz a análise desse comando de uma forma específica por baixo dos panos. Esse mecanismo é definido pelos desenvolvedores do sistema operacional e é conhecido como parsing (análise).

Se quiser conhecer melhor os comandos Linux e as diferentes opções e argumentos que eles suportam, a leitura do livro Unix Concepts and Applications é altamente recomendada.

Essa foi uma introdução básica à análise de argumentos. Quase todas as linguagens de programação oferecem suporte a isso. Python não é exceção. Há três formas bem comuns de fazer análise de argumentos em Python:

• sys.argv
• getopt
• argparse

Agora vamos ver cada uma dessas opções e como usá-las para analisar argumentos (e opções). Vamos em ordem cronológica.

Análise de argumentos usando sys.argv

Vamos começar simples. Neste primeiro exemplo, você vai criar um arquivo Python chamado demo1.py. Seu programa vai aceitar um número arbitrário de argumentos passados pela linha de comando (ou terminal) durante a execução. O programa imprimirá os argumentos recebidos e o total de argumentos.

Por exemplo, se você executar python demo1.py abc 123, o programa exibirá:

Number of arguments: 3
Argument(s) passed: ['demo1.py', 'abc', '123']

Repare que o primeiro argumento é sempre o nome do arquivo Python. Mas o código pode ser ajustado para não incluí-lo.

Agora vamos ao código:

import sys

print('Number of arguments: {}'.format(len(sys.argv)))
print('Argument(s) passed: {}'.format(str(sys.argv)))

Primeiro, você importou o módulo padrão do Python sys. Em seguida, utilizou o submódulo argv, que retorna a lista de argumentos passados a um script Python, em que argv[0] contém o nome do script. Se você executar sys.argv em uma célula de código como a seguir, verá a lista de arquivos de configuração responsáveis por fazer o kernel do IPython funcionar corretamente. É melhor não mexer neles.

sys.argv

['/home/nbuser/anaconda3_501/lib/python3.6/site-packages/ipykernel/__main__.py',
 '-f',
 '/home/nbuser/.local/share/jupyter/runtime/kernel-dabba4f7-e3e0-4c39-99d2-261ba835c53f.json']

Agora vamos ver como usar o módulo getopt para analisar argumentos (e opções).

Análise de argumentos usando getopt

Em comparação com o sys.argv, o módulo getopt oferece muito mais flexibilidade. Vamos primeiro pensar em um cenário de exemplo e escrever o código de acordo.

Digamos que você lançou um script Python ainda sem documentação. Mesmo assim, você quer fornecer um retorno útil quando o usuário executá-lo de forma incorreta. Seu script faz a tarefa simples de somar dois números e exibir o resultado. A única exigência é que o usuário passe as entradas como argumentos na linha de comando junto com o script Python.

Falando de forma mais prática, o script deveria ser executado assim:

python add_numbers.py -a 3 -b 8

A saída deve ser 11. Aqui, -a e -b são as opções, e 3 e 8 são os argumentos fornecidos ao script. As opções não apenas melhoram a legibilidade, como também ajudam a definir o fluxo de avaliação (pense se, em vez de somar, você estivesse dividindo). Vamos ao código:

import getopt
import sys

# Obtenha os argumentos da linha de comando, exceto o nome do arquivo
argv = sys.argv[1:]
sum = 0

try:
    # Defina os parâmetros do getopt
    opts, args = getopt.getopt(argv, 'a:b:', ['foperand', 'soperand'])
    # Verifique se o tamanho de options é 2 (pode ser aprimorado)
    if len(opts) == 0 and len(opts) > 2:
      print ('usage: add.py -a <first_operand> -b <second_operand>')
    else:
      # Percorra as opções e obtenha os respectivos valores
      for opt, arg in opts:
         sum += int(arg)
      print('Sum is {}'.format(sum))

except getopt.GetoptError:
    # Imprima algo útil
    print ('usage: add.py -a <first_operand> -b <second_operand>')
    sys.exit(2)

A ideia é primeiro obter todos os argumentos com sys.argv e então processá-los. Vamos à linha mais importante do código: opts, args = getopt.getopt(argv, 'a:b:', ['foperand', 'soperand'])

A assinatura do método getopt() é:

getopt.getopt(args, shortopts, longopts=[])

• args é a lista de argumentos obtida da linha de comando.
• shortopts é onde você especifica as letras das opções. Se você fornece a:, significa que seu script deve receber a opção a seguida de um valor como argumento. Tecnicamente, você pode usar quantas opções quiser aqui. Ao passar essas opções na linha de comando, elas devem vir precedidas de '-'.
• longopts é onde você pode especificar as versões estendidas de shortopts. Elas devem vir precedidas de '--'.

Você definiu shortopts como a:b:, o que indica que seu script aceitará duas opções em forma de letra: 'a' e 'b'. Ao usar ':' você informa explicitamente que essas opções serão seguidas de argumentos.

Você definiu longopts como ['foperand', 'soperand'], dizendo ao código para aceitar f_operand e s_operand no lugar de a e b como opções. Porém, elas devem sempre ser precedidas de --.

O módulo getopt também fornece a exceção GetoptError para você exibir mensagens úteis e orientar o usuário sobre como usar seu script. Por isso, você encapsulou a parte funcional em um bloco try e definiu o bloco except de forma apropriada.

Veja como executar o script Python:

Observação: o script acima não foi configurado para lidar com longopts. Isso é algo que você pode testar como exercício.

Agora vamos ver como usar o argparse para análise de argumentos.

Análise de argumentos usando argparse

Com base nas duas opções anteriores, dá para perceber que elas não são muito legíveis. Quando você vir o argparse em ação, vai concordar que as duas opções anteriores também ficam devendo em flexibilidade. Para entender o uso de argparse, vamos começar com um trecho de código que implementa o cenário visto na seção anterior.

import argparse

# Construa o parser de argumentos
ap = argparse.ArgumentParser()

# Adicione os argumentos ao parser
ap.add_argument("-a", "--foperand", required=True,
   help="first operand")
ap.add_argument("-b", "--soperand", required=True,
   help="second operand")
args = vars(ap.parse_args())

# Calcule a soma
print("Sum is {}".format(int(args['foperand']) + int(args['soperand'])))

Primeiro, argparse, assim como os outros módulos discutidos, faz parte da instalação padrão do Python. Você começa instanciando o objeto argparse. E o restante fica muito mais simples de escrever. Veja, por exemplo, a linha:

ap.add_argument("-a", "--foperand", required=True, help="first operand")

Aqui você adicionou o argumento que espera receber junto com a execução do script Python. Você forneceu a versão curta e a estendida do argumento. Ao especificar required=True, você exige explicitamente que o usuário forneça esse argumento. Por fim, incluiu uma descrição do argumento, que será mostrada ao usuário caso ele não execute o script corretamente.

A definição do segundo argumento segue a mesma lógica. Você acessa os argumentos informados especificando seus respectivos índices.

O trecho acima mostra como é fácil e flexível definir a análise de argumentos de linha de comando com argparse. Veja como você pode testar o script:

Perceba como tudo ficou mais simples com argparse.

E agora?

Obrigado por acompanhar o tutorial até o fim. Agora você está equipado com módulos nativos do Python capazes de analisar argumentos fornecidos pela linha de comando junto com seu script. Como exercício, personalize seus projetos de machine learning e ciência de dados para facilitar a análise de argumentos e transformá-los em utilitários de script úteis. E não apenas em ML ou ciência de dados — use onde fizer sentido. Por hoje é isso. Se você quer aprimorar suas habilidades em Python, vale conhecer o curso Python Data Science Toolbox (Part 1) da DataCamp.