Python é uma linguagem de programação poderosa que permite aos desenvolvedores criar uma variedade de aplicativos, desde scripts básicos até sistemas de software complexos. Uma das tarefas de programação mais comuns é criar interfaces de linha de comando (CLIs), que permitem aos usuários interagir com programas por meio de um terminal ou linha de comando. CLIs são essenciais para script, automação e situações em que uma interface gráfica do usuário é impraticável.
O tratamento de parâmetros de linha de comando é uma parte importante do design de CLIs. Esses argumentos permitem aos usuários influenciar o comportamento de um programa fornecendo parâmetros de entrada enquanto ele é executado. Sem a capacidade de avaliar esses fatores, os programas seriam menos versáteis e mais difíceis de ajustar para tarefas específicas.
O Python fornece vários módulos para análise de argumentos de linha de comando, mas o módulo argparse se destaca por sua simplicidade e abrangência. O módulo argparse facilita o desenvolvimento de interfaces funcionais de linha de comando. Ele lida automaticamente com a análise de parâmetros, exibe instruções úteis e fornece erros quando os usuários fornecem informações incorretas.
Neste tutorial, veremos como usar o pacote Python argparse. Começaremos com uma visão geral das interfaces de linha de comando do Python e a importância da análise de entrada de linha de comando. Em seguida, discutiremos o módulo argparse e seus benefícios.
Visão Geral das Interfaces de Linha de Comando em Python
Interfaces de linha de comando são programas que funcionam exclusivamente com comandos baseados em texto. Os usuários inserem comandos em um terminal ou linha de comando, que normalmente incluem argumentos e opções que alteram o comportamento do programa. As CLIs são úteis porque são facilmente automatizadas e integradas com outras tecnologias.
No Python, uma CLI é criada desenvolvendo um script que aceita entrada de linha de comando. Esta entrada é geralmente apresentada como uma lista de argumentos que o script pode acessar e interpretar. Para programas básicos, lidar manualmente com esses argumentos através da lista sys.argv pode ser suficiente. No entanto, quando a complexidade do programa aumenta, processar manualmente os argumentos se torna ineficiente e propenso a erros.
Importância de Analisar Argumentos de Linha de Comando
Analisa os argumentos da linha de comando é necessário por inúmeras razões:
- Flexibilidade: Ao receber parâmetros, um programa pode realizar várias tarefas ou agir em diferentes conjuntos de dados sem alterar o código. Os usuários podem especificar arquivos a serem processados, configurar configurações e selecionar modos de operação.
- Facilidade de uso do usuário: Uma análise adequada de argumentos permite que o programa exiba mensagens úteis, instrua o usuário sobre como usar o programa e lide de forma elegante com falhas.
- Maintenabilidade: Usar um módulo de análise dedicado, como argparse, torna seu código mais claro e mais fácil de manter. Ele separa a lógica usada para analisar argumentos da operação principal do programa.
Introdução ao Módulo argparse e seus Benefícios
O módulo argparse faz parte da biblioteca padrão do Python. Portanto, pode ser usado sem a necessidade de instalar pacotes adicionais. Ele oferece uma interface direta e consistente para analisar entradas da linha de comando. Algumas das vantagens de utilizar argparse são:
- Geração automática de ajuda: Gera mensagens de ajuda e uso com base nos argumentos do código.
- Tratamento de erros: Exibe mensagens de erro úteis quando os usuários inserem argumentos inválidos.
- Conversão de tipos: Pode converter automaticamente strings de parâmetros para o tipo de dados apropriado.
- Suporta tanto argumentos posicionais necessários quanto argumentos opcionais com simplicidade.
- Valores padrão: Permite fornecer valores padrão para parâmetros que o usuário não fornece.
argparse permite aos desenvolvedores focar na funcionalidade principal de seus programas, dependendo de uma base sólida para gerenciar a entrada da linha de comando.
Configurando argparse e Uso Básico
Agora que abordamos a importância de analisar argumentos da linha de comando e as vantagens de usar argparse, vamos ver como configurá-lo e usá-lo em um script Python.
Instalando e importando argparse
Não é necessário instalar nada separadamente, pois o argparse faz parte da biblioteca padrão do Python. Você pode importá-lo logo no início do seu script.
import argparse
Esta linha carrega o módulo argparse em seu script, permitindo que você use sua funcionalidade para analisar argumentos da linha de comando.
Criando um simples analisador de argumentos
O primeiro passo para utilizar o argparse é gerar um objeto de parser. Este objeto armazenará informações sobre os argumentos que seu programa aceita e analisará a entrada da linha de comando.
parser = argparse.ArgumentParser(description='Process some integers.')
Neste exemplo, criamos um objeto ArgumentParser() e descrevemos o programa. Quando o usuário seleciona a opção de ajuda (-h ou --help), esta descrição será exibida.
Adicionando argumentos posicionais e opcionais
Agora que desenvolvemos o parser, podemos especificar os argumentos que nosso programa aceitará.
Adicionando argumentos posicionais
Argumentos posicionais são essenciais e devem ser apresentados em uma ordem precisa. Por exemplo, considere um script que adiciona dois números. Podemos definir dois argumentos posicionais para os números:
parser.add_argument('num1', type=int, help='The first number to add.') parser.add_argument('num2', type=int, help='The second number to add.')
Neste código, num1 e num2 referem-se aos parâmetros posicionais.
type=int indica que os parâmetros devem ser convertidos em inteiros. O argumento help especifica uma descrição que aparecerá na mensagem de ajuda.
Adicionando argumentos opcionais
Argumentos opcionais não são necessários e geralmente fornecem opções adicionais ou alteram o comportamento do programa. Eles são geralmente prefixados com um ou dois traços. Vamos adicionar um argumento opcional para habilitar a saída detalhada:
parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.')
Aqui:
- A opção curta é
-v(por exemplo,-v).--verboseé uma opção longa. action='store_true'indica que se a opção for selecionada, o atributo verbose será definido comoTrue; caso contrário, seráFalse.- O argumento
helpespecifica uma descrição para a mensagem de ajuda.
Analisando os argumentos e acessando seus valores
Após especificar todos os argumentos, precisamos analisar a entrada da linha de comando. Use o método .parse_args() para fazer isso.
args = parser.parse_args()
Os parâmetros analisados agora estão armazenados na variável args como atributos. Podemos acessá-los usando a notação de ponto.
result = args.num1 + args.num2 print('The sum of {} and {} is {}'.format(args.num1, args.num2, result)) if args.verbose: print('Verbose mode is enabled.')
Juntando tudo, aqui está um script completo que adiciona dois números e inclui um modo verbose opcional:
import argparse parser = argparse.ArgumentParser(description='Add two integers.') parser.add_argument('num1', type=int, help='The first number to add.') parser.add_argument('num2', type=int, help='The second number to add.') parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.') args = parser.parse_args() result = args.num1 + args.num2 print('The sum of {} and {} is {}'.format(args.num1, args.num2, result)) if args.verbose: print('Calculation completed successfully.')
Você pode executar este script a partir da linha de comando e fornecer os argumentos posicionais necessários:
python add_numbers.py 3 5 The sum of 3 and 5 is 8
Se você incluir a opção -v ou --verbose, o script imprimirá a mensagem verbose adicional:
python add_numbers.py 3 5 --verbose The sum of 3 and 5 is 8 Calculation completed successfully.
Se o usuário executar o script com a opção -h ou --help, o argparse exibirá uma mensagem de ajuda gerada automaticamente:
python add_numbers.py -h usage: add_numbers.py [-h] [-v] num1 num2 Add two integers. positional arguments: num1 The first number to add. num2 The second number to add. optional arguments: -h, --help show this help message and exit -v, --verbose Increase output verbosity.
Essa funcionalidade torna o seu programa mais amigável, fornecendo instruções claras sobre como utilizá-lo.
Manipulação Avançada de Argumentos
Ao desenvolver programas de linha de comando em Python, você pode encontrar cenários que exigem análises de argumentos mais complexas. O módulo argparse do Python inclui várias funcionalidades para lidar com esses requisitos complexos, permitindo que você desenvolva interfaces flexíveis e amigáveis ao usuário.
Usando nargs para múltiplos argumentos
Existem situações em que sua aplicação precisa aceitar vários valores para o mesmo argumento. Por exemplo, suponha que você deseje criar um script que processe vários arquivos de uma só vez. O parâmetro nargs no argparse permite que você especifique quantos argumentos de linha de comando devem ser lidos.
Aqui está como usar nargs para aceitar vários nomes de arquivos:
import argparse parser = argparse.ArgumentParser(description='Process multiple files.') parser.add_argument('filenames', nargs='+', help='List of files to process.') args = parser.parse_args() for filename in args.filenames: print(f'Processing file: {filename}') # Adicione seu código de processamento de arquivos aqui
Neste caso, nargs='+' instrui o analisador a esperar um ou mais argumentos em nomes de arquivos. O usuário pode fornecer quantos nomes de arquivo forem necessários, e eles serão salvos em uma lista chamada args.filenames.
Se você deseja aceitar uma quantidade específica de argumentos, defina nargs para esse número. Por exemplo, nargs=2 requer exatamente dois parâmetros.
Implementar escolhas para limitar os valores do argumento
Às vezes, você deseja limitar um argumento a um intervalo específico de valores válidos. Isso garante que o usuário forneça uma entrada válida, evitando assim erros ou ações inesperadas. O parâmetro de opções permite que você especifique os valores permitidos para um argumento.
Considere um script que executa múltiplas atividades dependendo de um modo selecionado pelo usuário.
import argparse parser = argparse.ArgumentParser(description='Perform actions in different modes.') parser.add_argument('--mode', choices=['backup', 'restore', 'delete'], required=True, help='Mode of operation.') args = parser.parse_args() if args.mode == 'backup': print('Backing up data...') # Código de backup aqui elif args.mode == 'restore': print('Restoring data...') # Código de restauração aqui elif args.mode == 'delete': print('Deleting data...') # Código de exclusão aqui
Neste script, o argumento --mode deve ser uma das opções. Se o usuário inserir um valor que não está na lista, o argparse retornará uma mensagem de erro.
Manipulando flags booleanas e comutadores
As flags booleanas são escolhas que habilitam ou desabilitam funcionalidades específicas em sua aplicação. Geralmente, são definidas sem um valor, apenas incluindo a flag no comando. Você pode lidar com essas flags no argparse com o parâmetro action.
Por exemplo, vamos incluir um modo de depuração em um script:
import argparse parser = argparse.ArgumentParser(description='A script with debug mode.') parser.add_argument('--debug', action='store_true', help='Enable debug output.') args = parser.parse_args() if args.debug: print('Debug mode is enabled.') # Informações de depuração adicionais aqui else: print('Debug mode is disabled.')
Ao usar action='store_true', a flag --debug definirá args.debug como True quando presente e False caso contrário.
Definindo valores padrão e argumentos obrigatórios
Argumentos opcionais frequentemente incluem valores padrão sensatos. Isso significa que se o usuário não especificar o argumento, a aplicação usará o padrão. O argumento default permite que você especifique um valor padrão.
Aqui está um exemplo:
import argparse parser = argparse.ArgumentParser(description='Adjust program settings.') parser.add_argument('--timeout', type=int, default=30, help='Timeout in seconds.') args = parser.parse_args() print(f'Timeout is set to {args.timeout} seconds.')
Neste cenário, se o usuário não especificar --timeout, o padrão é de 30 segundos.
Para tornar um argumento opcional obrigatório, defina required=True.
import argparse parser = argparse.ArgumentParser(description='Send a message.') parser.add_argument('--recipient', required=True, help='Recipient of the message.') args = parser.parse_args() print(f'Sending message to {args.recipient}.')
O script agora exigirá o argumento --recipient.
Personalizando Mensagens de Ajuda e Erro
Fornecer mensagens claras e úteis aos usuários é um componente essencial no desenvolvimento de um programa de linha de comando eficaz. O módulo argparse do Python cria automaticamente mensagens de ajuda, mas você pode modificar essas mensagens para atender melhor às suas necessidades.
Gerando mensagens de ajuda automáticas
Por padrão, o argparse gera uma mensagem de ajuda, que pode ser acessada usando as opções -h ou --help. Esta mensagem contém o uso do programa, uma descrição e informações sobre cada argumento.
Por exemplo:
import argparse parser = argparse.ArgumentParser(description='Calculate factorial of a number.') parser.add_argument('number', type=int, help='The number to calculate the factorial for.') args = parser.parse_args()
Quando um usuário executa o script com -h, eles verão:
usage: script.py [-h] number Calculate factorial of a number. positional arguments: number The number to calculate the factorial for. optional arguments: -h, --help show this help message and exit
Esta mensagem de ajuda automática fornece informações úteis sem exigir esforço adicional.
Personalizando descrições de ajuda e mensagens de uso
Embora as mensagens de ajuda padrão sejam úteis, você pode querer alterá-las para fornecer informações adicionais ou para se adequar a uma estrutura específica. Você pode alterar a descrição, epílogo e texto de uso no ArgumentParser.
Por exemplo, para incluir um epílogo e personalizar a mensagem de uso:
import argparse parser = argparse.ArgumentParser( description='Convert temperatures between Celsius and Fahrenheit.', epilog='Enjoy using the temperature converter!', usage='%(prog)s [options] temperature') parser.add_argument('temperature', type=float, help='Temperature value to convert.') parser.add_argument('--to-fahrenheit', action='store_true', help='Convert Celsius to Fahrenheit.') parser.add_argument('--to-celsius', action='store_true', help='Convert Fahrenheit to Celsius.') args = parser.parse_args()
Agora, quando o usuário verifica a mensagem de ajuda, ela incluirá a descrição personalizada, uso e epílogo:
python file.py --help usage: p.py [options] temperature Convert temperatures between Celsius and Fahrenheit. positional arguments: temperature Temperature value to convert. options: -h, --help show this help message and exit --to-fahrenheit Convert Celsius to Fahrenheit. --to-celsius Convert Fahrenheit to Celsius.
–para-fahrenheit Converter Celsius em Fahrenheit.
–para-celsius Converter Fahrenheit em Celsius.
Gerenciando a manipulação de erros e feedback do usuário
import argparse import sys class CustomArgumentParser(argparse.ArgumentParser): def error(self, message): print(f'Error: {message}') self.print_help() sys.exit(2) parser = CustomArgumentParser(description='Divide two numbers.') parser.add_argument('numerator', type=float, help='The numerator.') parser.add_argument('denominator', type=float, help='The denominator.') args = parser.parse_args() if args.denominator == 0: parser.error('Denominator cannot be zero.') result = args.numerator / args.denominator print(f'Result: {result}')
Se um usuário inserir argumentos inválidos, o argparse exibirá uma mensagem de erro e encerrará o programa. Você pode modificar esse comportamento para fornecer um feedback mais útil ou para lidar com falhas de forma diferente.
Python file.py 6 0 Error: Denominator cannot be zero. usage: file.py [-h] numerator denominator Divide two numbers. positional arguments: numerator The numerator. denominator The denominator. options: -h, --help show this help message and exit
Uma abordagem é substituir o método de erro em uma subclasse de ArgumentParser:
import argparse import os parser = argparse.ArgumentParser(description='Read a file and display its contents.') parser.add_argument('filepath', help='Path to the file.') args = parser.parse_args() if not os.path.exists(args.filepath): parser.error(f"The file {args.filepath} does not exist.") with open(args.filepath, 'r') as file: contents = file.read() print(contents)
Se o usuário tentar dividir por zero neste script, a aplicação exibirá um aviso de erro e texto de ajuda, direcionando o usuário a fornecer dados válidos.
python app..py file usage: p.py [-h] filepath app.py: error: The file file does not exist.
Você também pode incluir uma manipulação de erros personalizada em seu script. Por exemplo, para gerenciar caminhos de arquivo inválidos:
Executar o script com um caminho inválido exibirá o erro abaixo:
Exemplos do Mundo Real e Casos de Uso
Entender como usar o módulo argparse em configurações do mundo real tornará sua funcionalidade mais clara. Vamos ver alguns exemplos de como usar argparse em aplicações do mundo real.
Construindo uma calculadora de linha de comando
import argparse parser = argparse.ArgumentParser(description='Simple command-line calculator.') parser.add_argument('num1', type=float, help='First number.') parser.add_argument('operator', choices=['+', '-', '*', '/'], help='Operation to perform.') parser.add_argument('num2', type=float, help='Second number.') args = parser.parse_args() if args.operator == '+': result = args.num1 + args.num2 elif args.operator == '-': result = args.num1 - args.num2 elif args.operator == '*': result = args.num1 * args.num2 elif args.operator == '/': if args.num2 == 0: print('Error: Division by zero is not allowed.') exit(1) result = args.num1 / args.num2 print(f'The result is: {result}')
Suponha que você precise desenvolver uma calculadora simples que possa realizar operações aritméticas básicas a partir da linha de comando. Esta calculadora deve aceitar dois números e um operador para executar o cálculo solicitado.
python calculator.py 10 + 5 The result is: 15.0
Aqui está como abordar essa tarefa:
Neste script, o módulo argparse é usado para definir três argumentos posicionais: dois números e um operador. O argumento choices limita o operador a símbolos aritméticos válidos. Quando o usuário executa o script, eles podem realizar esses cálculos:
Esta calculadora básica mostra como as opções de linha de comando podem aprimorar a flexibilidade e interatividade de um programa.
Criando um script de processamento de arquivos com várias opções
import argparse parser = argparse.ArgumentParser(description='Process text files.') parser.add_argument('input_file', help='Path to the input file.') parser.add_argument('-o', '--output', help='Path to the output file.') parser.add_argument('-m', '--mode', choices=['uppercase', 'lowercase'], default='uppercase', help='Processing mode.') parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose output.') args = parser.parse_args() Suponha que você precise de um script que processe arquivos de texto e forneça escolhas, como designar um arquivo de saída, selecionar um modo de processamento e habilitar a saída detalhada. with open(args.input_file, 'r') as file: content = file.read() if args.verbose: print(f'Reading from {args.input_file}') Aqui está um exemplo de como você poderia configurá-lo: if args.mode == 'uppercase': processed_content = content.upper() else: processed_content = content.lower() if args.verbose: print('Processing content') # Ler o arquivo de entrada if args.output: with open(args.output, 'w') as file: file.write(processed_content) if args.verbose: print(f'Writing output to {args.output}') else: print(processed_content)
# Processar o conteúdo
python text_processor.py input.txt -o output.txt --mode lowercase -v Reading from input.txt Processing content Writing output to output.txt
# Escrever no arquivo de saída ou imprimir no console
Este script aceita um arquivo de entrada e tem opções para o arquivo de saída, modo de processamento e saída detalhada. Os usuários podem modificar como o script se comporta sem alterar o código.
Desenvolvendo uma ferramenta CLI com subcomandos
import argparse parser = argparse.ArgumentParser(description='Manage tasks.') subparsers = parser.add_subparsers(dest='command', required=True) Em aplicações mais complicadas, subcomandos podem ser necessários, semelhante ao funcionamento do git usando comandos como git commit e git push. O móduloargparsefornece subparsers para esse propósito. parser_add = subparsers.add_parser('add', help='Add a new task.') parser_add.add_argument('name', help='Name of the task.') parser_add.add_argument('-p', '--priority', type=int, choices=range(1, 6), default=3, help='Priority of the task.') Aqui está como criar uma ferramenta CLI com subcomandos: parser_list = subparsers.add_parser('list', help='List all tasks.') parser_list.add_argument('-a', '--all', action='store_true', help='List all tasks, including completed ones.') # Subcomando 'add' parser_complete = subparsers.add_parser('complete', help='Mark a task as completed.') parser_complete.add_argument('task_id', type=int, help='ID of the task to complete.') args = parser.parse_args() if args.command == 'add': print(f"Adding task '{args.name}' with priority {args.priority}") # Subcomando 'list' elif args.command == 'list': print('Listing tasks') if args.all: print('Including completed tasks') # Subcomando 'complete' elif args.command == 'complete': print(f'Marking task {args.task_id} as completed') # Código para adicionar a tarefa
# Código para listar tarefas
# Código para completar a tarefa
python task_manager.py add "Write report" -p 2 Adding task 'Write report' with priority 2
Neste exemplo, o script tem três subcomandos: add, list e complete. Cada subcomando tem seus argumentos. Quando os usuários executam o script, eles inserem o subcomando e quaisquer outros parâmetros.
python task_manager.py list Listing tasks
Por exemplo:
python task_manager.py complete 3 Marking task 3 as completed
Listando tarefas
Marcando tarefas como concluídas:
subparsers permitem que você crie ferramentas de linha de comando complexas que são bem organizadas e fáceis de estender, permitindo que você construa aplicações que podem fazer múltiplas coisas em uma única interface.
Melhores Práticas e Dicas do Python argparse
Desenvolver programas de linha de comando envolve mais do que simplesmente escrever um código que funcione. Também implica escrever um código que seja limpo, manutenível e amigável ao usuário.
Aqui estão algumas melhores práticas ao trabalhar com o módulo argparse.
Organizando o código para legibilidade e manutenção
Quando seus scripts se tornam mais complexos, é fundamental manter seu código organizado para melhor compreensão e manutenção. Uma abordagem para conseguir isso é usar funções e classes para organizar seções distintas do seu código.
Dividir seu programa em partes menores e reutilizáveis facilita a gestão e elimina a duplicação de código.
Por exemplo, em um script de gerenciamento de tarefas, você poderia definir diferentes funções para adicionar tarefas, listar tarefas e concluir tarefas. Essa divisão permite que você se concentre em um aspecto da lógica de cada vez, tornando seu código mais claro.
Outra técnica eficaz é separar a lógica de análise de argumentos do restante do seu código. Colocar todas as definições e análises de argumentos no início do seu script, ou em uma função dedicada, facilita para os outros compreenderem como seu programa lida com a entrada.
Usar nomes de variáveis apropriados também melhora a legibilidade. Escolha nomes de variáveis que reflitam seu propósito, para que qualquer pessoa que visualize seu código possa entender o que está acontecendo. Incluir comentários e docstrings para explicar o que suas funções fazem e quaisquer detalhes importantes pode ajudar a aumentar a compreensão.
Testando e depurando aplicações de linha de comando
Testar suas aplicações é fundamental para garantir que funcionem corretamente e detectar falhas precocemente. Escrever testes unitários com frameworks de teste Python como unittest ou pytest é uma abordagem excelente para testar seu código. Esses testes permitem simular várias entradas e garantir que suas funções funcionem corretamente.
Por exemplo, é possível testar vários cenários simulando as entradas de linha de comando em vez de executar o script a partir da linha de comando. Essa estratégia permite garantir que o parsing de argumentos funcione conforme esperado e que sua aplicação lide corretamente com vários cenários.
Lidar com exceções de forma graciosa também é vital. Usando blocos try-except, é possível capturar erros e fornecer mensagens úteis ao usuário. Isso torna sua aplicação mais estável e amigável ao usuário.
Considere incluir também uma flag de depuração em seu script. Essa flag pode habilitar saídas adicionais que permitem rastrear a execução do programa quando algo dá errado. Ter essa opção facilita o diagnóstico de problemas ao longo do desenvolvimento e da manutenção.
Comparando argparse com outras bibliotecas de parsing de argumentos
Embora o argparse seja uma ferramenta valiosa na biblioteca padrão do Python, existem outras bibliotecas disponíveis que proporcionam métodos alternativos para analisar argumentos de linha de comando. Compreender essas opções ajudará você a selecionar a ferramenta certa para o seu projeto.
Uma dessas bibliotecas é Click. Click é um pacote de terceiros para criar interfaces de linha de comando com decoradores. Ele possui uma sintaxe mais intuitiva e é ideal para aplicações sofisticadas. Por exemplo, você pode usar decoradores Python para criar comandos e opções, tornando seu código mais compacto e compreensível.
Docopt é outra opção que permite definir a interface de linha de comando usando a docstring do programa. Docopt analisa automaticamente a mensagem de ajuda e constrói o analisador de argumentos quando as instruções de uso estão incluídas na docstring. Esta abordagem é elegante e adequada para scripts simples que requerem uma especificação mais legível para humanos.
Ao escolher qual biblioteca utilizar, leve em consideração as exigências do seu projeto. Se deseja eliminar dependências externas e quer uma ferramenta que possa lidar com a maioria das circunstâncias, argparse é uma excelente solução. Se deseja uma sintaxe mais intuitiva e está trabalhando em uma aplicação complexa, Click pode ser mais adequado. Docopt é uma boa escolha para programas pequenos com interfaces simples.
Conclusão
Ao longo deste artigo, examinamos como usar o módulo Python argparse para desenvolver programas de linha de comando em Python. Trabalhando através de exemplos do mundo real, aprendemos como criar scripts realistas que recebem entrada do usuário e realizam tarefas relevantes.