Noções básicas de análise de argumentos de linha de comando em Python

Os aplicativos de linha de comando são um dos tipos de aplicativos mais antigos e mais usados. Se você for um usuário experiente de Linux, dificilmente terá usado ferramentas GUI em vez de ferramentas de linha de comando para fazer a mesma tarefa. Por exemplo, Anaconda, o gerenciador de pacotes para python, tem ferramentas de linha de comando chamadas Conda e uma ferramenta GUI chamada anaconda navigator.

O que torna o aplicativo de linha de comando popular entre os desenvolvedores é que ele consome poucos recursos em comparação com sua contraparte GUI e oferece melhor desempenho.

Python é uma linguagem simples e poderosa para construir aplicativos de linha de comando. Ele fornece toneladas de bibliotecas já escritas por muitos programadores excelentes, tornando nossa tarefa mais fácil, pois não precisamos reescrever o mesmo código.

Neste tutorial, apresentarei a biblioteca Argparse do python para você, que pode analisar argumentos dos aplicativos de linha de comando. Isso é útil para construir ótimas interfaces de linha de comando. Para seguir este tutorial, é recomendado ter a versão mais recente do python instalada. Também temos um tutorial passo a passo sobre como atualizar o python para a versão mais recente no Linux.

Introdução

A análise de argumentos é um conceito importante que devemos usar para construir interfaces de linha de comando poderosas e fáceis de usar. Se você já usou aplicativos de linha de comando anteriormente, deve ter notado que podemos adicionar argumentos aos aplicativos de linha de comando para configurar as opções da ferramenta.

Por exemplo, se você usou o ls comando no Linux, que é usado para listar os itens do diretório de trabalho atual, você deve ter visto uma saída semelhante, conforme mostrado na imagem abaixo.

Como você pode ver na imagem, ela lista os itens do diretório atual. Também podemos usar o ls comando de forma mais benéfica, dando-lhe um argumento como fiz no seguinte comando.

ls -a

Agora, ao digitar este comando no terminal, ele irá listar todos os itens presentes no diretório de trabalho atual, incluindo os itens ocultos. Como você pode ver, ao fornecer argumentos no comando, podemos facilmente especificar opções para o comando de uma forma amigável. É aqui que os argumentos entram em jogo. Eles tornam os aplicativos de linha de comando mais úteis e amigáveis.

Você pode estar se perguntando quando e como adicionar argumentos de linha de comando em seus aplicativos. Imagine que você está construindo um aplicativo que precisa de uma entrada do usuário do nome do arquivo que o aplicativo irá processar.

Podemos fazer isso de duas maneiras:

• solicitando que o usuário adicione o nome do arquivo ou
• fornecendo ao usuário para adicionar o nome do arquivo como um argumento para o comando.

O primeiro truque é bom, mas o segundo é mais útil porque o usuário pode dar todas as opções em um comando, o que o torna mais amigável.

Python inclui uma ótima biblioteca chamada "argparse", que é útil para criar e analisar argumentos de linha de comando e pode construir interfaces de linha de comando poderosas para os usuários com muita facilidade. Vamos dar um mergulho profundo na biblioteca argparse do python.

Biblioteca Argparse

O argparse biblioteca é uma maneira fácil e útil de analisar argumentos ao construir aplicativos de linha de comando em python. Embora existam outros argumentos de análise de bibliotecas como optparse, getopt, etc., a argparse biblioteca é oficialmente a maneira recomendada para analisar argumentos de linha de comando.

Também está disponível na biblioteca padrão do python, portanto, não precisamos de nenhuma configuração manual. O argparse biblioteca foi construída usando o optparse biblioteca de python, mas argparse é mais útil e amigável para desenvolvedores do que o optparse biblioteca.

Demonstração Prática de Argparse

Vamos ver uma demonstração prática de como usar a biblioteca argparse para criar uma interface de linha de comando simples. Este programa aceitará um caminho e verificará se o caminho existe ou não e se existe, em seguida, imprimirá se é um arquivo ou um diretório.

import os import argparse parser = argparse.ArgumentParser ('description = "Path Existence Checker") analisador.add_argument ("- path", help = "insira um caminho para verificar se existe") args = parser.parse_args () input_path = args.caminho se os.caminho.isdir (input_path): print ("O caminho existe e é um diretório") elif os.caminho.isfile (input_path): print ("O caminho existe e é um arquivo") else: print ("O caminho não existe")

Ao executar o programa acima, podemos verificar se o caminho existe ou não.

Você também pode usar o -h argumento com o programa, que é o argumento padrão para exibir mensagens de ajuda.

Deixe-me explicar como o programa acima funciona. Nas duas primeiras linhas, importamos os módulos que vamos exigir no programa. O os módulo foi importado para verificar se o caminho existe ou não, e é um arquivo ou diretório. Se você quiser aprender mais sobre o os módulo, você pode consultar nosso guia sobre como trabalhar com sistema operacional em python.Na próxima linha, importamos a biblioteca argparse necessária para criar e analisar argumentos. Na terceira linha, criamos um objeto analisador usando a classe ArgumentParser da biblioteca argparse. Esta classe também aceita uma descrição de parâmetro opcional, que será exibida na mensagem de ajuda.Na próxima linha, criamos um argumento chamado path usando o método add_argument () do objeto analisador e fornecemos os detalhes no parâmetro de ajuda que será mostrado na mensagem de ajuda como vimos na saída anterior.Em seguida, analisamos os argumentos usando o método parse_args () do objeto analisador e acessamos o caminho de entrada do usuário como um argumento. Pegamos o caminho que o usuário inseriu no argumento e o usamos com o módulo os para verificar se é um arquivo ou pasta. Se não estiver entre os dois, irá imprimir que o caminho não existe.

Costumização

Vamos ver algumas das personalizações que podemos fazer em nossa interface de linha de comando com a ajuda da biblioteca argparse.

Ajuda de uso personalizado

Quando executamos o programa de demonstração que criamos anteriormente com o -h parâmetro, obtemos a ajuda do programa como a saída que a biblioteca argparse gerou. Se você notar a mensagem de ajuda, há uma ajuda de uso na linha superior que nos mostra como usá-la.Em nosso programa de demonstração, temos a ajuda de uso padrão. Ainda podemos personalizá-lo facilmente usando o parâmetro de uso ao criar o objeto analisador usando a classe ArgumentParser (). Veja o código abaixo, que deve ser modificado em nosso programa de demonstração.

parser = argparse.ArgumentParser (description = "Path Existence Checker", usage = "cla.caminho py ")

Aqui está o resultado:

Como podemos ver na saída, a ajuda de uso foi alterada para aquela que especificamos no parâmetro de uso da classe ArgumentParser ().

Customizando Argumentos

Também podemos usar a biblioteca Argparse para personalizar os argumentos como se os argumentos serão necessários ou não, dando a um argumento um valor padrão.

Adicionando valor padrão

Podemos dar aos argumentos um valor padrão usando o parâmetro padrão para o add_argument () método. Por exemplo, veja o código abaixo.

import os import argparse parser = argparse.ArgumentParser (description = "Path Existence Checker", usage = "cla.caminho py ") analisador.add_argument ("- path", help = "insira um caminho para verificar se existe", default = "nome do arquivo.txt ") args = parser.parse_args () input_path = args.caminho se input_path == Nenhum: exit () elif os.caminho.isdir (input_path): print ("O caminho existe e é um diretório") elif os.caminho.isfile (input_path): print ("O caminho existe e é um arquivo") else: print ("O caminho não existe")

Ao executar o programa acima sem nenhum argumento, obteremos a saída abaixo. Conforme mostrado na saída, o programa verifica o caminho nome do arquivo.TXT, que definimos no parâmetro padrão.

Definição de requisitos de argumentos

Também podemos usar a biblioteca Argparse para definir os requisitos do argumento, i.e., se os argumentos serão necessários ou não. Para fazer isso, precisamos usar o parâmetro obrigatório, conforme mostrado no código abaixo.

import os import argparse parser = argparse.ArgumentParser (description = "Path Existence Checker", usage = "cla.caminho py ") analisador.add_argument ("- path", help = "insira um caminho para verificar se existe", default = "nome do arquivo.txt ", obrigatório = Verdadeiro) args = analisador.parse_args () input_path = args.caminho se input_path == Nenhum: exit () elif os.caminho.isdir (input_path): print ("O caminho existe e é um diretório") elif os.caminho.isfile (input_path): print ("O caminho existe e é um arquivo") else: print ("O caminho não existe")

Ao executar o código acima sem nenhum argumento, você obterá um erro dizendo que os seguintes argumentos são necessários.

Tipo de Argumento

Também podemos definir o tipo de dados usado no argumento. Por exemplo, se precisarmos do caminho, devemos fornecer um tipo de dados de string. Se um usuário inserir um tipo de dados que não seja uma string, o Argparser irá transformá-lo em uma string. Para definir o tipo padrão de um argumento, execute o código abaixo.

import os import argparse parser = argparse.ArgumentParser (description = "Path Existence Checker", usage = "cla.caminho py ") analisador.add_argument ("- path", help = "insira um caminho para verificar se existe", type = str) args = parser.parse_args () input_path = args.caminho se input_path == Nenhum: exit () elif os.caminho.isdir (input_path): print ("O caminho existe e é um diretório") elif os.caminho.isfile (input_path): print ("O caminho existe e é um arquivo") else: print ("O caminho não existe")

Resultado:

Conclusão

Este é apenas o básico para analisar argumentos usando a biblioteca Argparse. Depois de passar por este tutorial, é recomendável ler a documentação oficial para explorar mais truques de uso desta biblioteca. Você também pode querer ver a postagem sobre o uso de registro em python, que é muito útil para escrever grandes aplicativos e fácil depuração.