Aprendendo Python: módulo argparse

Se você estiver envolvido no processamento e análise de dados usando o Python, mais cedo ou mais tarde precisará ir além do Jupyter Notebook, convertendo seu código em scripts que podem ser executados usando a linha de comando. É aqui que o módulo argparse é útil. Para iniciantes, acostumados ao Jupyter Notebook, essa etapa significa a necessidade de sair da zona de conforto e mudar para um novo ambiente. O material, cuja tradução publicamos hoje, foi escrito para facilitar essa transição.


Módulo Argparse

Módulo Argparse

O módulo argparse pode ser comparado com as forças da natureza que ergueram picos de montanhas acima das nuvens. Graças a este módulo em scripts, torna-se possível trabalhar com algo que, sem seu uso, estaria oculto no código desses scripts.

Deve-se notar que argparse é o módulo de biblioteca padrão Python recomendado para trabalhar com argumentos de linha de comando. Como não consegui encontrar um bom guia de discussão para iniciantes, resolvi escrever esse guia pessoalmente.

Vida além do caderno Jupyter

Quando me deparei com argparse no script Python que eu precisava para um projeto que fiz no meu tempo livre, pensei: “O que é essa construção misteriosa?” Depois disso, transferi rapidamente o código para o Jupyter Notebook, mas esse movimento acabou sendo irracional.

Eu precisava ser capaz de executar o script e não trabalhar com ele usando o Jupyter Notebook. Um script independente que usasse o módulo argparse seria muito mais fácil de usar, trabalhar nele seria mais fácil do que confiar nos recursos do Jupyter Notebook. No entanto, eu estava com pressa e, quando olhei para a documentação do argparse, não pude entender imediatamente sua essência; portanto, não usei a versão original do script.

Desde então, descobri o argparse e gostei muito deste módulo. Agora eu considero isso absolutamente vital. No entanto, dominar não é tão difícil.

Por que precisamos do módulo argparse?

O módulo argparse permite analisar os argumentos passados ​​para o script quando ele é executado na linha de comando e possibilita o uso desses argumentos no script. Ou seja, estamos falando do fato de que este módulo permite que o script forneça alguns dados no momento de seu lançamento, e o script poderá usar esses dados durante a execução de seu código. O módulo argparse é uma ferramenta com a qual você pode estabelecer comunicação entre o autor do programa e aquele que o utiliza, por exemplo, entre você quando você escreve um script hoje e quando você o inicia amanhã, passando algo para ele.

Usar argparse significa que, se necessário, altere o comportamento do script ou, se necessário, transfira alguns dados para ele; se forem fornecidos pelo autor do script, o usuário não precisará editar o código do programa. Como resultado, os scripts ganham um certo nível de flexibilidade.

Exemplo

Suponha que você queira escrever um script para converter arquivos de vídeo em imagens regulares usando a biblioteca OpenCV . Para que o script resolva esse problema, ele precisa saber o local onde os arquivos de vídeo estão armazenados e o local em que você precisa colocar a imagem final. Ou seja, ele precisa de informações sobre duas pastas, os caminhos para os quais, o que não é muito conveniente, podem ser codificados no código do script ou, o que é muito melhor, você pode permitir que o usuário especifique o script inserindo-os como argumentos de linha de comando ao executar o script. Para equipar o script com essa oportunidade, o módulo argparse é útil para nós. Aqui está a aparência da seção do script (vamos chamar de script videos.py ), na qual os argumentos da linha de comando são analisados:

 # videos.py import argparse parser = argparse.ArgumentParser(description='Videos to images') parser.add_argument('indir', type=str, help='Input dir for videos') parser.add_argument('outdir', type=str, help='Output dir for image') args = parser.parse_args() print(args.indir) 

Aqui, no início do arquivo, o módulo argparse é importado. Em seguida, usando a construção argparse.ArgumentParser() , um objeto parser é criado com sua descrição. Em seguida, usando o método parser.add_argument() , a variável parser.add_argument() é indir , na qual está planejado gravar o caminho para a pasta com arquivos de vídeo. Ao mesmo tempo, é indicado que ele possui um tipo de string e as informações de referência sobre ele também são definidas. Depois disso, da mesma maneira, é outdir variável outdir , na qual o caminho para a pasta na qual o script terá que colocar as imagens criadas com base nos arquivos de vídeo será obtido. Na próxima etapa, o resultado da análise dos argumentos da linha de comandos entra na variável args . O que é passado para o script na inicialização agora estará disponível como propriedades indir e outdir do objeto args . Agora você pode trabalhar com esses valores. Nesse caso, simplesmente imprimimos no console o que é passado para o script no argumento indir .

Veja como executar esse script na linha de comando:

 python videos.py /videos /images 

Observe que as linhas /videos e /images não precisam ser citadas. Um script lançado dessa maneira produzirá a linha /videos para o terminal, confirmando a possibilidade de usar os argumentos passados ​​a ele em seu código. Essa é a mágica do argparse em ação.


A mágica de analisar argumentos de linha de comando

Detalhes Argparse

Acabamos de ver um exemplo simples de argparse. Agora vamos discutir alguns detalhes sobre o argparse.

▍ Argumentos posicionais

A construção do formulário parser.add_argument('indir', type=str, help='Input dir for videos') partir do script videos.py como objetivo criar um argumento posicional. Ao chamar um script, a ordem na qual esses argumentos são especificados é importante. Portanto, o primeiro argumento passado para o script se torna o primeiro argumento posicional, o segundo argumento se torna o segundo argumento posicional.

O que acontece se o script for executado sem argumentos, executando o comando python videos.py no terminal?

Nesse caso, a seguinte mensagem de erro será exibida:

 videos.py: error: the following arguments are required: indir, outdir 

Como resultado, verifica-se que, para executar um script que fornece o uso de argumentos posicionais, esses argumentos sempre devem ser especificados quando são executados.

Argumentos opcionais

O que acontece quando nosso script é executado com o comando python videos.py --help ?

Em resposta, as informações de ajuda serão exibidas. Esta é exatamente a informação sobre argumentos posicionais que indicamos ao descrever as variáveis ​​correspondentes:

 usage: videos.py [-h] indir outdir Videos to images positional arguments: indir       Input dir for videos outdir      Output dir for image optional arguments: -h, --help  show this help message and exit 

O script nos contou muitas coisas interessantes sobre o que ele espera do usuário, e a help é um exemplo de argumento opcional. Observe que --help (ou -h ) é o único argumento opcional padrão que podemos usar ao trabalhar com argparse, mas se você precisar de outros argumentos opcionais, poderá criar você mesmo.

Argumentos opcionais são criados da mesma maneira que argumentos posicionais. A principal diferença entre os comandos para criá-los é que, ao especificar os nomes de tais argumentos, esses nomes começam com uma sequência de caracteres -- ou, para formas curtas de argumentos, com um caractere - . Por exemplo, um argumento opcional pode ser criado assim:

 parser.add_argument('-m', '--my_optional') 

Aqui está um exemplo de como criar e usar argumentos opcionais. Observe que, ao descrever o argumento opcional aqui, especificamos seu tipo como int . Ou seja, é um número inteiro. Em uma situação semelhante, você pode usar outros tipos de Python.

 # my_example.py import argparse parser = argparse.ArgumentParser(description='My example explanation') parser.add_argument(   '--my_optional',   type=int,   default=2,   help='provide an integer (default: 2)' ) my_namespace = parser.parse_args() print(my_namespace.my_optional) 

O argumento descrito como --my_optional está disponível no programa como uma propriedade do objeto my_namespace chamado my_optional .

Argumentos opcionais podem ser atribuídos aos valores que eles terão por padrão. No nosso caso, se nenhum valor for fornecido para o argumento my_example quando o script for chamado, o número 2 será gravado nele, o qual será gerado no console. Para definir o valor desse argumento durante a execução do script, você pode usar a seguinte construção:

 python my_example.py  --my_optional=3 

Para que mais o argparse pode ser usado?

O módulo argparse pode ser usado para desenvolver aplicativos Python planejados para serem empacotados em contêineres do Docker. Portanto, por exemplo, se ao iniciar um aplicativo empacotado em um contêiner, ele precisa passar argumentos de linha de comando para ele, ele pode ser descrito no estágio de montagem do contêiner no Dockerfile usando a instrução RUN . Você pode usar as instruções CMD ou ENTRYPOINT para executar scripts durante a ENTRYPOINT contêiner. Detalhes sobre os Dockerfiles podem ser encontrados aqui .

Sumário

Examinamos as maneiras básicas de trabalhar com o módulo argparse, usando as quais você pode equipar seus scripts com a capacidade de aceitar e processar argumentos de linha de comando. Note-se que os recursos argparse não terminam aí. Por exemplo, o uso do parâmetro nargs ao descrever argumentos permite trabalhar com listas de argumentos e o parâmetro options permite especificar conjuntos de valores que os argumentos podem usar. De fato, agora, tendo dominado os principais recursos do argparse, você, sem muita dificuldade, pode estudar esse módulo mais profundamente, usando a documentação para ele.

Se você está acostumado a trabalhar com o Jupyter Notebook e deseja se afastar dessa prática, aqui estão os materiais para trabalhar com variáveis ​​de ambiente. Aqui está o material da ferramenta repo2docker , que permite converter repositórios do Jupyter Notebook em imagens do Docker.

Caros leitores! Como você trabalha com argumentos de linha de comando em scripts Python?