Como Verificar se um Número é Par em Python - Guia para Iniciantes

Introdução

Neste laboratório, você aprenderá como determinar se um número é par ou ímpar em Python. Começaremos entendendo os conceitos fundamentais de números pares e ímpares, definindo-os como inteiros divisíveis por 2 com um resto de 0 (par) ou 1 (ímpar).

O laboratório então o guia através do uso do operador módulo (%) para verificar a paridade. Você criará um script Python que utiliza uma instrução if e o operador módulo para determinar e imprimir se um determinado número é par ou ímpar. O laboratório inclui instruções passo a passo para criar o script no VS Code e executá-lo a partir do terminal.

Aprenda sobre Números Pares e Ímpares

Nesta etapa, exploraremos os conceitos fundamentais de números pares e ímpares. Compreender esses conceitos é crucial para várias tarefas de programação, incluindo validação de dados, design de algoritmos e desenvolvimento de jogos.

O que são Números Pares?

Um número par é um inteiro que é exatamente divisível por 2. Isso significa que, quando você divide um número par por 2, o resto é sempre 0. Exemplos de números pares incluem: 2, 4, 6, 8, 10 e assim por diante.

O que são Números Ímpares?

Um número ímpar é um inteiro que não é exatamente divisível por 2. Quando você divide um número ímpar por 2, o resto é sempre 1. Exemplos de números ímpares incluem: 1, 3, 5, 7, 9 e assim por diante.

Como Determinar se um Número é Par ou Ímpar

Em programação, frequentemente precisamos determinar se um determinado número é par ou ímpar. Python fornece uma maneira simples de fazer isso usando o operador módulo (%). O operador módulo retorna o resto de uma divisão.

Por exemplo, 7 % 2 avalia para 1 porque quando você divide 7 por 2, o resto é 1. Da mesma forma, 8 % 2 avalia para 0 porque quando você divide 8 por 2, o resto é 0.

Vamos criar um script Python simples para ilustrar isso:

Abra o editor VS Code no WebIDE.
Crie um novo arquivo chamado even_odd.py no diretório ~/project.
```
~/project/even_odd.py
```
Adicione o seguinte código ao arquivo even_odd.py:
```
number = 10
if number % 2 == 0:
    print(number, "is an even number")
else:
    print(number, "is an odd number")
```
Este código primeiro atribui o valor 10 à variável number. Em seguida, ele usa uma instrução if para verificar se o resto de number dividido por 2 é igual a 0. Se for, o código imprime que o número é par. Caso contrário, ele imprime que o número é ímpar.
Execute o script usando o seguinte comando no terminal:
```
python ~/project/even_odd.py
```
Você deve ver a seguinte saída:
```
10 is an even number
```

Agora, altere o valor de number no arquivo even_odd.py para 7:

number = 7
if number % 2 == 0:
    print(number, "is an even number")
else:
    print(number, "is an odd number")

Execute o script novamente:
```
python ~/project/even_odd.py
```
Você deve agora ver a seguinte saída:
```
7 is an odd number
```

Este exemplo simples demonstra como usar o operador módulo para determinar se um número é par ou ímpar em Python. Nas próximas etapas, construiremos sobre essa base para criar programas mais complexos.

Use o Operador Módulo

Na etapa anterior, você aprendeu sobre números pares e ímpares e como o operador módulo (%) pode ser usado para determinar se um número é par ou ímpar. Nesta etapa, vamos nos aprofundar no operador módulo e explorar suas várias aplicações.

Entendendo o Operador Módulo

O operador módulo (%) retorna o resto de uma divisão. A sintaxe é a % b, onde a é o dividendo (o número que está sendo dividido) e b é o divisor (o número pelo qual você está dividindo). O resultado é o resto da divisão.

Aqui estão alguns exemplos:

7 % 2 avalia para 1 porque 7 dividido por 2 é 3 com um resto de 1.
10 % 3 avalia para 1 porque 10 dividido por 3 é 3 com um resto de 1.
15 % 5 avalia para 0 porque 15 dividido por 5 é 3 com um resto de 0.

Aplicações do Operador Módulo

O operador módulo tem muitas aplicações úteis em programação, incluindo:

Determinar Par ou Ímpar: Como você viu na etapa anterior, number % 2 == 0 indica que number é par, e number % 2 != 0 indica que number é ímpar.
Envolvimento (Wrapping Around): O operador módulo pode ser usado para envolver uma faixa de números. Por exemplo, se você tiver um contador que deve percorrer os números de 0 a 9, você pode usar o operador módulo para redefinir o contador para 0 quando ele atingir 10.
Extração de Dígitos: O operador módulo pode ser usado para extrair o último dígito de um número. Por exemplo, number % 10 retorna o último dígito de number.

Vamos modificar o script even_odd.py para obter o número da entrada do usuário e usar o operador módulo para verificar se ele é par ou ímpar.

Abra o arquivo even_odd.py no diretório ~/project usando o editor VS Code.
Modifique o código da seguinte forma:
```
number_str = input("Enter an integer: ")
number = int(number_str)

if number % 2 == 0:
    print(number, "is an even number")
else:
    print(number, "is an odd number")
```
Neste código, usamos a função input() para solicitar que o usuário insira um inteiro. A função input() retorna uma string, então usamos a função int() para converter a string em um inteiro. Em seguida, usamos o operador módulo para verificar se o número é par ou ímpar, como antes.
Execute o script usando o seguinte comando:
```
python ~/project/even_odd.py
```
O script solicitará que você insira um inteiro. Insira um número e pressione Enter. Por exemplo:
```
Enter an integer: 15
```
O script então exibirá se o número é par ou ímpar:
```
15 is an odd number
```
Tente executar o script com números diferentes para ver como o operador módulo funciona.

Este exemplo demonstra como usar o operador módulo com a entrada do usuário para determinar se um número é par ou ímpar. Na próxima etapa, adicionaremos tratamento de erros para garantir que o usuário insira um inteiro válido.

Certifique-se de que o Número é um Inteiro

Na etapa anterior, você aprendeu como usar a função input() para obter a entrada do usuário e a função int() para converter a entrada em um inteiro. No entanto, se o usuário inserir algo que não é um inteiro (por exemplo, "olá" ou "3.14"), a função int() irá lançar uma exceção ValueError, fazendo com que o programa trave. Nesta etapa, adicionaremos tratamento de erros para garantir que o usuário insira um inteiro válido.

Tratamento de Erros com try-except

Python fornece um bloco try-except para lidar com exceções. O código no bloco try é executado. Se uma exceção ocorrer, o código no bloco except é executado.

Aqui está a sintaxe básica:

try:
    ## Código que pode lançar uma exceção
except ValueError:
    ## Código para lidar com a exceção ValueError

Se um ValueError ocorrer no bloco try, o código no bloco except ValueError será executado.

Vamos modificar o script even_odd.py para usar um bloco try-except para lidar com possíveis exceções ValueError.

Abra o arquivo even_odd.py no diretório ~/project usando o editor VS Code.
Modifique o código da seguinte forma:
```
while True:
    number_str = input("Enter an integer: ")
    try:
        number = int(number_str)
        break  ## Sai do loop se a entrada for um inteiro válido
    except ValueError:
        print("Entrada inválida. Por favor, insira um inteiro.")

if number % 2 == 0:
    print(number, "is an even number")
else:
    print(number, "is an odd number")
```
Neste código, adicionamos um loop while True que continua a solicitar a entrada do usuário até que um inteiro válido seja inserido. Dentro do loop, temos um bloco try-except. O bloco try tenta converter a entrada do usuário em um inteiro. Se a conversão for bem-sucedida, a instrução break sai do loop. Se um ValueError ocorrer (o que significa que o usuário inseriu algo que não é um inteiro), o bloco except imprime uma mensagem de erro e o loop continua.
Execute o script usando o seguinte comando:
```
python ~/project/even_odd.py
```
Se você inserir um valor não inteiro, como "olá", você verá a seguinte saída:
```
Enter an integer: hello
Invalid input. Please enter an integer.
Enter an integer:
```
O script continuará a solicitar a entrada até que você insira um inteiro válido. Depois de inserir um inteiro válido, como 12, o script exibirá se o número é par ou ímpar:
```
Enter an integer: 12
12 is an even number
```

Este exemplo demonstra como usar um bloco try-except para lidar com possíveis exceções ValueError ao converter a entrada do usuário em um inteiro. Isso torna seu programa mais robusto e amigável ao usuário.

Resumo

Neste laboratório, exploramos os conceitos fundamentais de números pares e ímpares, entendendo que números pares são divisíveis por 2 com um resto de 0, enquanto números ímpares têm um resto de 1 quando divididos por 2.

Utilizamos o operador módulo (%) em Python para determinar se um número é par ou ímpar. Um script Python simples foi criado e executado para demonstrar isso, verificando se o resto de um número dividido por 2 é igual a 0 para identificar números pares.