Fazer um programa em Pyton para solicitar o Cadastro de portas de rede, que podem aceitar conexão. Em seguida, imprima as portas cadastradas e se pode ou não aceitar conexão.

Passo 1

O enunciado pede um programa em Python que faça o cadastro de portas de rede que podem aceitar conexão e, depois, imprima as portas cadastradas junto com a informação se cada uma pode ou não aceitar conexão.
Informações relevantes e o que o programa precisa fazer:
  • Receber do usuário um conjunto de portas de rede (cada porta é um número inteiro).
  • Para cada porta, o usuário deve informar se ela “aceita conexão” (sim/não).
  • Validar a entrada: portas válidas são inteiros no intervalo padrão de portas TCP/UDP: de 1 a 65535.
  • Imprimir todas as portas cadastradas e, para cada uma, indicar “Sim” ou “Não” para aceitar conexão.
  • O enunciado não especifica a forma de entrada (quantas portas, ou entrada até um sentinel). Vou escolher um método simples e controlado: pedir primeiro quantas portas o usuário quer cadastrar, e em seguida solicitar cada cadastro; isso facilita a repetição e a edição em prova.

Passo 2

Plano de solução (visão geral):
  1. Perguntar quantas portas cadastrar (um inteiro positivo).
  2. Para cada cadastro: pedir o número da porta (validando que é inteiro entre 1 e 65535) e perguntar se aceita conexão (resposta como “s”/“n” ou “sim”/“não”, validada).
  3. Evitar cadastrar a mesma porta duas vezes (avisar o usuário e pedir outra porta).
  4. Guardar os pares (porta, aceita) em uma lista.
  5. Ao final, imprimir a lista formatada, mostrando porta e “Sim”/“Não”.
Vou implementar funções pequenas para: leitura de inteiros validados e leitura da resposta sim/não, isso facilita reproduzir na prova e evita repetição de código.

Passo 3

Regras de validação (explicação didática):
  • Por que validar a porta? Porque entrada de usuário pode ser qualquer texto e portas só fazem sentido como inteiros no intervalo [1,65535].
  • Como validar: tentar converter a string para inteiro com int(). Se der ValueError, a entrada não era um inteiro. Depois verificar se o inteiro está entre [1,65535].
  • Na prova, quando fizer algo parecido, descreva esses passos: converter, tratar exceção, checar intervalo. Em Python usamos try: ... except ValueError: para capturar entrada inválida.

Passo 4

Função para ler um inteiro com validação (didática passo-a-passo):
  • A função vai repetir enquanto a entrada não for válida.
  • Recebe um texto de prompt e limites min e max.
  • Dentro dela, chamo input(prompt), tento int(valor); se falhar, aviso e continuo; se passar, verifico se está dentro do intervalo.
    Isso evita duplicar o mesmo tratamento várias vezes no código principal.

Passo 5

Função para ler uma resposta do tipo sim/não (didática):
  • O usuário pode digitar "s", "S", "sim", "Sim", "n", "N", "não", "nao", etc.
  • Normalizamos com .strip().lower() e aceitaremos as formas iniciadas por "s" como sim e por "n" como não.
  • Repetimos a pergunta até o usuário digitar algo reconhecível.
  • Convertendo a resposta para booleano temos True para “sim” e False para “não”.

Passo 6

Estratégia para evitar duplicatas (por que e como):
  • Se um mesmo número de porta for cadastrado duas vezes, normalmente é melhor avisar o usuário e pedir outra porta, para evitar confusão ao imprimir.
  • Técnica: mantenho um set() com portas já usadas. Ao ler uma nova porta, verifico if port in usado: aviso e pedir outra. Isso é eficiente e simples de implementar.

Passo 7

Como vou imprimir o resultado (formatação e didática):
  • Quero uma saída fácil de ler: uma tabela simples com cabeçalho “Porta | Aceita conexão”.
  • Para ficar alinhado e legível uso str.format ou f-strings com largura, por exemplo f"{porta:>5}" para alinhar à direita em 5 colunas.
  • Para cada entrada imprimo a porta e "Sim" ou "Não" dependendo do booleano.
  • Opcional: ordernar as portas antes de imprimir para ficar organizado (vou ordenar por número da porta).

Passo 8

Exemplo de fluxo de execução (o que o usuário verá):
  • Programa pergunta: “Quantas portas deseja cadastrar?” -> usuário digita 3.
  • Programa pede “Porta 1:” -> usuário digita 80.
  • Pergunta “Aceita conexão? (s/n):” -> usuário digita s.
  • Repete para Porta 2 e Porta 3.
  • Ao final imprime algo como:
    Porta | Aceita conexão
    80 | Sim
    8080 | Não
    65535 | Sim

Passo 9

Motivação final e dicas rápidas para prova:
  • Modularize: pequenas funções (ler inteiro validado, ler sim/não) facilitam a depuração.
  • Sempre trate entrada do usuário com try/except e repita até ficar válido.
  • Use set quando precisar garantir unicidade.
  • Em prova, comente brevemente cada bloco de código para o corretor entender sua lógica.
  • Respire! Você consegue — vá por etapas e teste cada função antes de integrar.

Resposta

def ler_int_valido(prompt, minimo=None, maximo=None):
    """
    Lê um inteiro do usuário repetindo até a entrada ser válida.
    Se minimo ou maximo forem fornecidos, valida o intervalo [minimo, maximo].
    """
    while True:
        texto = input(prompt)
        try:
            valor = int(texto)
        except ValueError:
            print("Entrada inválida: digite um número inteiro.")
            continue
        if minimo is not None and valor < minimo:
            print(f"Valor muito pequeno: deve ser >= {minimo}.")
            continue
        if maximo is not None and valor > maximo:
            print(f"Valor muito grande: deve ser <= {maximo}.")
            continue
        return valor

def ler_sim_nao(prompt):
    """
    Lê uma resposta do usuário e retorna True para 'sim' e False para 'não'.
    Aceita entradas como 's', 'sim', 'n', 'nao', 'não' (case-insensitive).
    Repetirá até receber algo válido.
    """
    while True:
        resposta = input(prompt).strip().lower()
        if not resposta:
            print("Resposta vazia. Digite 's' para sim ou 'n' para não.")
            continue
        primeira = resposta[0]
        if primeira == 's':
            return True
        if primeira == 'n':
            return False
        print("Resposta inválida. Use 's' para sim ou 'n' para não.")

def main():
    print("Cadastro de portas de rede (1 a 65535).")
    quantidade = ler_int_valido("Quantas portas deseja cadastrar? ", minimo=1)
    cadastradas = []
    usadas = set()

    i = 0
    while i < quantidade:
        prompt_porta = f"Porta {i+1}: "
        porta = ler_int_valido(prompt_porta, minimo=1, maximo=65535)
        if porta in usadas:
            print("Essa porta já foi cadastrada. Escolha outra porta.")
            continue
        aceita = ler_sim_nao("Aceita conexão? (s/n): ")
        cadastradas.append((porta, aceita))
        usadas.add(porta)
        i += 1

    # Ordena por número da porta para saída organizada
    cadastradas.sort(key=lambda x: x[0])

    # Imprime resultado formatado
    print("\nPorta | Aceita conexão")
    for porta, aceita in cadastradas:
        status = "Sim" if aceita else "Não"
        print(f"{porta:>5} | {status}")

if __name__ == "__main__":
    main()

Exercícios relacionados