Tutorial de análise de linha de comando python

Os argumentos da Linha de Comando de Comando foi anteriormente incluída na Biblioteca Python padrão “Argparse”. Ao permitir que os valores de entrada do usuário sejam de alguma forma analisados ​​e depois usados, "argparse". Oferece flexibilidade e reutiliza seu código no lugar de definir manualmente variáveis ​​como parte do código.

Exemplo 1

Implementaremos o código seguinte para mostrar a estrutura e o uso de uma biblioteca Argparse.

importar argparse
analisador = argparse.ArgumentParser ()
analisador.add_argument ('-nome', type = str, requerir = true)
args = analisador.parse_args ()
print ('oi', args.nome)

A biblioteca "argparse" seria importada no início do código. O analisador é inicializado pelo ArgumentParser (), para que possamos começar a adicionar parâmetros personalizados. Use o analisador.função add_argument () para adicionar argumentos desejados. O "nome", "tipo" e "necessário" serão dados como os argumentos deste método. O atributo 'exigido' é um booleano indicando se o seguinte campo de linha de comando é executado e o argumento "tipo" mostra o tipo de variável especificado como uma entrada. Definimos o valor do argumento "tipo" como "str" ​​e "necessário" como "verdadeiro". A função parse_args () será chamada. Os “args.Nome ”o atributo parece ser o nome de um argumento identificado com a função add_argument ().

O código anterior produz esse tipo de resultado, como mostrado:

Como podemos ver, isso levantará um erro, já que o argumento do "nome" é necessário, mas está faltando. Quando adicionamos -name, obtemos a seguinte saída:

Exemplo 2

Existem certas situações em que não queremos discutir sobre o nome que pode ser usado para a bandeira. Pode -se utilizar um parâmetro posicional para evitar ter que fornecer a bandeira -name antes de inserir o valor real.

Aqui, multiplicaremos os argumentos posicionais especificando os parâmetros.

importar argparse
analisador = argparse.ArgumentParser ()
analisador.add_argument ('-i', type = int, requerir = true)
analisador.add_argument ('-j', type = int, requerir = true)
args = analisador.parse_args ()
Produto = args.eu * args.j
Imprimir ('Produto:', Produto)

O analisador foi gerado pela primeira vez depois de importar o módulo "argparse". As variáveis ​​"eu" e "j", dois argumentos do tipo inteiro que devem ser verdadeiros, foram então adicionados. Depois disso, as fórmulas de produto serão aplicadas após analisar os parâmetros. Empregamos a função print () para exibir o produto.

Exemplo 3

Nesse caso, fazemos multiplicação sem especificar os parâmetros posicionais.

importar argparse
analisador = argparse.ArgumentParser ()
analisador.add_argument ('k', tipo = int)
analisador.add_argument ('l', tipo = int)
args = analisador.parse_args ()
Produto = args.K * args.eu
Imprimir ('Produto:', Produto)

Primeiro, integrando o pacote "ArgParse", o analisador foi inicialmente construído usando o método ArgumentParser (). Os "K" e "L" são os dois argumentos especificados com o tipo inteiro. Embora os argumentos posicionais mantenham uma linha de comando mais clara, não fornecemos o atributo "necessário" aqui. Posteriormente, os parâmetros fornecidos foram analisados ​​com a ajuda do método parse_args (). Definiremos uma função de produto usando as variáveis ​​"K" e "L". Para mostrar o resultado, utilizaremos a declaração de impressão.

Exemplo 4

Argumentos opcionais podem ser úteis sempre que queremos fornecer a um usuário alguma opção para usar a funcionalidade. Simplesmente especificamos o parâmetro opcional usando a função add_argument () para adicionar um argumento opcional.

importar argparse
analisador = argparse.ArgumentParser ()
analisador.add_argument ('-nome', type = str, requerir = true)
analisador.add_argument ('-classe', tipo = int)
args = analisador.parse_args ()
se args.Aula:
Imprimir (args.nome, 'in', args.Classe, 'classe.')
outro:
print ('hey', args.nome + '!')

Iniciamos o programa incorporando a biblioteca "argparse". Primeiro, estabelecemos um analisador usando o método ArgumentParser () para executar dois argumentos de analisador. Agora, chamaremos a função add_argument () para adicionar parâmetros diferentes. Esses argumentos incluem duas variáveis, nome e classe, onde o argumento do "nome" é do tipo "string", e deve ser verdadeiro. O parâmetro "classe" tem o tipo "inteiro".

Além disso, depois de analisar os parâmetros, utilizamos a condição "if-else". Dentro disso, estamos aplicando a função print () duas vezes, uma vez pela declaração "se" e novamente pela declaração "else", para representar a saída. Os argumentos em Print () métodos variam nesses dois casos. Os argumentos fornecidos na função Print Print () incluem nome e classe. Ao mesmo tempo, os argumentos apresentados no método Print () Print () incluem args.nome.

Depois de executar o código, obtemos as duas saídas, conforme dado abaixo. Temos a primeira saída depois de usar os argumentos opcionais e o segundo sem os argumentos opcionais.

Dos dois resultados anteriores, podemos observar que há uma diferença entre ambos os resultados devido ao uso dos argumentos opcionais em um e não no outro.

Exemplo 5

Vamos imaginar que, em vez de pedir ao usuário que forneça entradas "x" e "y", queremos que o usuário insira uma série de números e o script, o que retornaria o total de todos esses números. Como não podemos prever quantos valores um usuário entrará, não é necessário criar um novo argumento para cada novo valor. O número (ou entradas) que o argumento pode aceitar pode ser especificado usando a opção "NARGS" na função add_argument ().

Forneceremos vários argumentos de entrada e imprimiremos o resultado neste caso.

importar argparse
analisador = argparse.ArgumentParser ()
analisador.add_argument ('-valores', tipo = int, nargs = 5)
args = analisador.parse_args ()
soma = soma (args.valores)
Imprima ('soma:', soma)

Iniciamos importando a biblioteca "argparse", necessária para executar o código anterior. Criaremos um analisador chamando o método ArgumentParser (). Esta função não contém argumento. Em seguida, o método add_argument () será invocado. Este método tem três parâmetros. No caso de múltiplos argumentos de entrada, utilizamos o atributo "nargs" dentro do método add_argument (). Agora, chamaremos a função parse_args () para analisar. Aplicamos o método soma () para encontrar a soma dos valores. Para representar a saída, utilizamos a declaração de impressão.

Exemplo 6

E se queremos a soma de mais entradas do que cinco valores? Podemos fazer o argumento aceitar qualquer número de valores definindo NARGS = "+".

importar argparse
analisador = argparse.ArgumentParser ()
analisador.add_argument ('-valores', tipo = int, nargs = '+')
args = analisador.parse_args ()
soma = soma (args.valores)
Imprima ('soma:', soma)

Podemos executar o script com praticamente qualquer número de valores de entrada. Aqui, usamos o mesmo código do anterior, mas, neste código, estaremos mudando 'nargs' = 5 para 'nargs' = '+'.

Conclusão

Este artigo abordou uma variedade de técnicas de análise de linha de comando Python, como argumentos simples, argumentos posicionais, argumentos opcionais e vários argumentos de entrada. Ele também forneceu exemplos para ver como a saída muda, dependendo de um argumento ser usado ou não. Podemos utilizar exemplos para examinar e compreender se um argumento é apropriado em uma determinada circunstância.