Python para Iniciantes
Carregando, aguarde alguns segundos.

4 - Estruturas de Controle

As Estruturas de Controle são fundamentais para a programação, determinando o fluxo de execução do programa.

Linguagens de programação diferentes têm sintaxe própria, mas funcionamento similar, executando instruções sequencialmente, como foram declaradas na programação, uma após a outra, a atual sempre após a anterior e sempre antes da próxima.

Por exemplo, podemos atribuir valores às variáveis x e y e depois imprimir estes valores. 

x = 10
y = 20
print(x)
print(y)

As instruções acima são executadas sequencialmente, na ordem em que foram declaradas.

Primeiro atribuindo o valor 10 à variável x, depois o valor 20 à variável y, então imprimindo o valor de x e finalmente imprimindo o valor de y.

A execução sempre segue o fluxo sequencial de instruções declarado na programação, a não ser que este comportamento possa ser controlado e ocorrer de forma diferente.

As estruturas de controle permitem a execução de blocos de código em função da ocorrência de determinadas instruções condicionais ou de repetição, alterando o comportamento do fluxo de execução.

São como as rédeas de um cavalo, permitindo que você conduza o comportamento do seu código, ao invés de apenas deixá-lo simplesmente seguir sempre em frente e em linha reta, fluindo sequencialmente e sem desvios.

As cláusulas condicionais em programação são estruturas fundamentais para controlar o fluxo do código, permitindo que certas partes do programa sejam executadas com base em condições específicas.

Em Python, as cláusulas condicionais são frequentemente utilizadas e há várias combinações que podem ser empregadas para criar lógicas mais complexas.

As principais cláusulas condicionais em Python são if, else e elif (abreviação de else if).

  • if: É a estrutura condicional básica que permite a execução de um bloco de código se a condição for avaliada como verdadeira.
  • else: Utilizado em conjunto com o if, permite executar um bloco de código alternativo se a condição do if for avaliada como falsa.
  • elif: Adiciona uma nova condição para ser verificada caso a condição do if seja falsa. O elif é útil para testar múltiplas condições.

Combinações de cláusulas condicionais:

if-else: É a estrutura mais simples, onde um bloco de código é executado se a condição do if for verdadeira e outro bloco é executado se for falsa. 

if condicao:
    # bloco de código se a condição for verdadeira
else:
    # bloco de código se a condição for falsa

if-elif-else: Permite testar várias condições em sequência. Se a condição do if for falsa, verifica a condição do elif e executa o bloco correspondente caso seja verdadeira. Se nenhuma condição for verdadeira, o bloco do else é executado. 

if condicao1:
    # bloco de código se a condição1 for verdadeira
elif condicao2:
    # bloco de código se a condição2 for verdadeira
else:
    # bloco de código se nenhuma condição for verdadeira

Combinações aninhadas: As cláusulas condicionais podem ser aninhadas umas nas outras para formar lógicas mais complexas, permitindo verificar condições específicas em profundidade. 

if condicao1:
    if condicao2:
        # bloco de código se ambas as condições forem verdadeiras
    else:
        # bloco de código se a primeira condição for verdadeira e a segunda for falsa
else:
    # bloco de código se a primeira condição for falsa

Essas combinações permitem criar lógicas condicionais sofisticadas para controlar o fluxo de um programa, possibilitando a execução de diferentes blocos de código com base em condições variáveis.

A compreensão e o domínio das cláusulas condicionais são essenciais para construir programas robustos e funcionais em Python.

As cláusulas de repetição, também conhecidas como estruturas de controle de fluxo de repetição ou laços (loops), são utilizadas em programação para executar um bloco de código repetidamente enquanto uma condição específica é atendida. Em Python, as cláusulas de repetição principais são for e while, podendo ser combinadas para criar lógicas complexas de repetição.

for: O laço for é utilizado para iterar sobre uma sequência (como listas, tuplas, strings, dicionários, conjuntos) ou qualquer objeto que seja iterável. 

for item in sequencia:
    # bloco de código a ser executado para cada item na sequência

for/range(): A função range() gera uma sequência de números. Pode ser utilizado para iterar um número específico de vezes. 

for i in range(5):
    # bloco de código executado 5 vezes
    # os valores de i variam de 0 a 4

while: O laço while executa um bloco de código repetidamente enquanto uma condição específica é verdadeira. 

while condicao:
    # bloco de código a ser repetido enquanto a condição for verdadeira

Laço infinito: Um laço while pode resultar em infinito se a condição nunca se tornar falsa. 

while True:
    # Este bloco de código será executado indefinidamente

Combinação de Cláusulas de Repetição:

Aninhamento de laços: Os laços for e while podem ser aninhados, permitindo realizar tarefas complexas que exigem múltiplas iterações.

Usando while: 

i = 0
while i < 3:
    j = 0
    while j < 3:
        # bloco de código executado para cada combinação i, j
        j += 1
    i += 1

Usando for: 

for i in range(3):
    for j in range(2):
        # bloco de código executado para cada combinação i, j

Uso de laços com cláusulas condicionais: Os laços podem ser combinados com cláusulas condicionais (if, elif, else) para criar lógicas complexas de controle de fluxo dentro de cada iteração. 

for item in lista:
    if condicao:
        # bloco de código se a condição for verdadeira
    else:
        # bloco de código se a condição for falsa

Controle de laço: Palavras-chave como break (quebra o laço), continue (vai para a próxima iteração) e pass (não faz nada) são usadas para controlar o comportamento do laço. 

for item in lista:
    if condicao:
        break     # Interrompe o laço
    elif:
        pass      # Nada acontece
    else:
        continue  # Vai para a próxima iteração

Essas combinações e estruturas permitem criar algoritmos poderosos e complexos, possibilitando a manipulação e processamento de dados de maneira eficiente.

Entender como combinar e utilizar essas cláusulas de repetição é fundamental para qualquer programador Python.

Com estruturas de controle, as decisões podem ser tomadas com base em condições específicas ou criar repetições baseadas em iterações ou condicionais, tornando a execução de tarefas mais eficiente.

Vamos começar entendendo as declarações condicionais, que são blocos de código que permitem que você tome decisões no programa, como "se isso acontecer, faça isso; senão, faça aquilo".

Veremos como usar os comandos if, else, e elif para criar bifurcações lógicas em seu código, e também o comando match, que funciona como um seletor de caso (switch-case).

Em seguida, abordaremos as estruturas de repetição, que permitem que você execute um conjunto de instruções várias vezes.

O for e o while são dois tipos comuns de laços em Python, e aprenderemos a utilizá-los de forma eficaz. Veremos como utilizar comandos como break e continue para controlar o fluxo dentro dos laços, permitindo que o fim da execução de um laço antes que ele seja concluído, ou pule a iterações e siga para próxima.

Aqui estão os principais tópicos que serão abordados neste capítulo:

  • Condicionais (if, elif, else, match): Veremos como utilizar a estrutura de controle if, elif, else e match para realizar testes condicionais, executando blocos de código apenas se certas condições forem atendidas. Isso permite que o programa tome decisões lógicas com base nos valores das variáveis ou resultados de expressões.
  • Laços (while, for): Estudaremos os laços while e for para criar iterações em Python. O laço while permite executar repetidamente um bloco de código enquanto uma condição específica for verdadeira. Já o laço for é útil para percorrer elementos em sequências, como listas, strings, dicionários e outros objetos iteráveis.
  • Controle de Laço (break, continue, pass): Aprenderemos sobre as instruções break, continue e pass para controlar o comportamento dos laços. A instrução break permite sair do laço prematuramente, enquanto a instrução continue pula para a próxima iteração sem executar o restante do código no bloco de laço. A instrução pass simplesmente faz com que o bloco de código seja ignorado.
  • Compreensão de Listas: Exploraremos a poderosa técnica de compreensão de listas, que é uma forma concisa e eficiente de criar listas em Python, aplicando transformações e filtrando elementos.
  • Estruturas de Controle Aninhadas: Veremos como aninhar estruturas de controle, ou seja, colocar condicionais e laços dentro de outros condicionais e laços. Essa técnica é útil para criar lógica complexa e realizar tarefas mais avançadas.
  • Exemplos e Desafios Práticos: Ao longo do capítulo, encontraremos exemplos práticos e desafios para aplicar as estruturas de controle em cenários reais. Isso ajudará a consolidar o conhecimento e a ganhar confiança em sua aplicação.

As estruturas de controle são pilares fundamentais da programação, permitindo que desenvolvedores criem programas mais flexíveis e adaptáveis.

Ao dominar as condicionais e laços em Python, você poderá resolver problemas complexos e criar algoritmos mais eficientes.

Ao final deste capítulo, você estará apto(a) a controlar o fluxo de execução do seu programa de forma inteligente e lógica.

As estruturas de controle são ferramentas poderosas que adicionam dinamismo e funcionalidade aos seus códigos, e você estará pronto(a) para aplicá-las em seus futuros projetos.

4.1 - Controles Condicionais (if, elif, else, match)

As estruturas condicionais em Python permitem que você tome decisões em seu programa com base em certas condições. Elas são fundamentais para controlar o fluxo de execução do código e executar diferentes blocos de código dependendo das circunstâncias.

Aqui está uma explicação detalhada de cada parte das condicionais:

Observações:

A indentação é essencial em Python para definir os blocos de código dentro das estruturas condicionais. Certifique-se de alinhar corretamente o código com espaços ou tabulações.

O Python avalia as condições de cima para baixo, portanto, se uma condição for verdadeira, os blocos subsequentes serão ignorados.

As estruturas de controle condicionais são ferramentas poderosas para criar lógica em programas Python.

Com elas, você pode tomar decisões com base em diversas situações e criar programas mais dinâmicos e adaptáveis.

Lembre-se de que a lógica das condicionais é fundamental para a maioria das aplicações, e dominar esse conceito é essencial para programação eficiente em Python.

if

A estrutura if é usada para realizar um teste condicional. Ela avalia uma expressão ou variável e, se a condição for verdadeira, o bloco de código indentado abaixo do if será executado. Se a condição for falsa, o bloco será ignorado. A sintaxe é a seguinte: 

if condição:
    # Código a ser executado se a condição for verdadeira
    ...

Exemplo: 

idade = 18
if idade >= 18:
    print("Você é maior de idade.")

elif

A palavra-chave elif é usada para testar múltiplas condições. Quando o if for falso, o programa verificará a próxima condição usando elif. Se a condição for verdadeira, o bloco de código indentado abaixo do elif será executado. Você pode ter quantos blocos elif forem necessários para lidar com diferentes cenários. A sintaxe é a seguinte: 

if condição1:
    # Código a ser executado se a condição1 for verdadeira
    ...
elif condição2:
    # Código a ser executado se a condição2 for verdadeira
    ...

Exemplo: 

idade = 25
if idade < 18:
    print("Você é menor de idade.")
elif idade >= 18 and idade < 65:
    print("Você é adulto.")
else:
    print("Você é idoso.")

else

A estrutura else é opcional e é usada para definir um bloco de código a ser executado caso nenhuma das condições anteriores seja verdadeira. Se todas as condições do if e elif forem falsas, o bloco de código após o else será executado.

A sintaxe é a seguinte: 

if condição1:
    # Código a ser executado se a condição1 for verdadeira
    ...
elif condição2:
    # Código a ser executado se a condição2 for verdadeira
    ...
else:
    # Código a ser executado se nenhuma das condições for verdadeira
    ...

Exemplo: 

nota = 7
if nota >= 7:
    print("Você foi aprovado!")
else:
    print("Você foi reprovado.")

match

A estrutura "match" é usada para realizar um teste de correspondência entre um padrão e uma cadeia de caracteres.

A sintaxe é a seguinte: 

match valor:
    case padrão1:
        # Código a ser executado se o valor corresponde ao padrão1
    case padrão2:
        # Código a ser executado se o valor corresponde ao padrão2
    case padrão3:
        # Código a ser executado se o valor corresponde ao padrão3
    case padrão4:
        # Código a ser executado se o valor corresponde ao padrão4
    case padrão5:
        # Código a ser executado se o valor corresponde ao padrão5
    case padrão6:
        # Código a ser executado se o valor corresponde ao padrão6
    case padrão7:
        # Código a ser executado se o valor corresponde ao padrão7
    case padrão8:
        # Código a ser executado se o valor corresponde ao padrão8
    case padrão9:
        # Código a ser executado se o valor corresponde ao padrão9

Exemplo: 

numero = 5
match numero:
    case 1:
        print("Um")
    case 2:
        print("Dois")
    case 3:
        print("Tres")
    case 4:
        print("Quatro")
    case 5:
        print("Cinco")
    case 6:
        print("Seis")
    case 7:
        print("Sete")
    case 8: 
        print("Oito")   
    case 9:
        print("Nove")
    case 10:
        print("Dez")
    case _:
        print("Outro")

Aninhamento

As estruturas condicionais aninhadas em Python referem-se à prática de colocar condicionais (if, elif, else) dentro de outros condicionais, permitindo que você crie lógicas mais complexas e sofisticadas na tomada de decisões e a execução de ações com base em diferentes cenários.

O exemplo a seguir mostra o aninhamento de condicionais em função de idade e altura. 

idade = 25
altura = 175

if idade >= 18:
    if altura <= 170:
        print("Você é maior de idade e tem uma altura adequada para o brinquedo.")
    else:
        print("Você é maior de idade, mas sua altura não é adequada para o brinquedo.")
else:
    print("Você é menor de idade.")

Neste exemplo, temos um condicional if aninhado dentro de outro condicional if.

O programa primeiro verifica se a idade é maior ou igual a 18.

Se for, ele entra no próximo nível de condicional e verifica se a altura é maior ou igual a 170 (em cm).

Dependendo dessas condições, serão impressas diferentes mensagens.

4.2 - Controles de Repetição (while e for)

Os laços são estruturas de controle que permitem que você execute repetidamente um bloco de código até que uma condição específica seja atendida.

O Python oferece duas principais formas de implementar laços: o laço while e o laço for.

4.2.1 - Laço while

O laço while é usado quando você deseja que um bloco de código seja executado repetidamente enquanto uma condição específica for verdadeira.

Ele executa o bloco de código repetidamente até que a condição seja avaliada como falsa.

A sintaxe do laço while é a seguinte: 

while condição:
    # Código a ser executado enquanto a condição for verdadeira
    ...

Exemplo: 

contador = 0
while contador < 5:
    print("Contador: ", contador)
    contador += 1

4.2.2 - Laço for

O laço for é usado quando você deseja percorrer um conjunto de elementos, como uma lista, string ou qualquer outro objeto iterável.

Em cada iteração do laço, o bloco de código será executado com o valor atual do elemento.

A sintaxe do laço for é a seguinte: 

for elemento in sequência:
    # Código a ser executado para cada elemento na sequência

Exemplo: 

frutas = ["maçã", "banana", "laranja"]
for fruta in frutas:
    print(fruta)

Compreensão de lista

O exemplo acima pode ser simplificado com o uso de compreensão de listas. 

[print(fruta) for fruta in frutas]
[print(fruta) for fruta in frutas]

Observações:

A indentação é fundamental em Python para definir os blocos de código dentro dos laços.

No laço for, o termo "elemento" é apenas uma variável temporária que representa cada elemento da sequência em cada iteração.

4.2.3 - Função range()

A função range() é frequentemente utilizada em laços for para gerar sequências de números. A função range() pode ser usada de várias formas, mas a mais comum é com um único argumento, que determina o número de iterações:

Exemplo: 

for i in range(5):
    print(i)

Neste exemplo, o laço for irá iterar cinco vezes, exibindo os números de 0 a 4.

O exemplo acima pode ser simplificado com o uso de compreensão de listas. 

[print(i) for i in range(5)]

4.2.4 - Controle de laço (break e continue):

A instrução break é usada para sair do laço prematuramente, interrompendo a execução do laço antes de todas as iterações serem concluídas.

A instrução continue é usada para pular para a próxima iteração do laço, ignorando o restante do bloco de código para aquela iteração específica.

Exemplo: 

for i in range(10):
    if i == 5:
        break
    if i % 2 == 0:
        continue
    print(i)

Neste exemplo, o laço for irá iterar de 0 a 9, mas quando o valor de "i" for igual a 5, a instrução break será executada, e o laço será interrompido.

Além disso, se o valor de "i" for par, a instrução continue será executada, e o restante do bloco de código para aquela iteração será ignorado, e o valor do índice i não será exibido.

O exemplo acima pode ser simplificado com o uso de compreensão de listas.

Usando uma sequência de operadores if: 

[print(i) for i in range(10) if i < 5 if i % 2 != 0]

Usando as condições separadas com o operador condicional and: 

[print(i) for i in range(10) if i < 5 and i % 2 != 0]

Entretanto, a compreensão de listas nestes dos casos acima obrigará a execução da iteração completa da faixa de índices de 0 a 9, aumentando desnecessariamente o número de instruções executadas, pois todos os valores de i maiores que 5 serão sistematicamente filtrados fora e não serão exibidos.

Os laços são fundamentais para criar código eficiente e realizar tarefas repetitivas em Python. Eles permitem automatizar tarefas, processar listas de dados e resolver problemas complexos. Dominar as estruturas de laço é essencial para se tornar um(a) programador(a) completo(a) em Python e expandir suas habilidades de desenvolvimento.

O controle de laço com as instruções break e continue é uma técnica poderosa em Python para modificar o comportamento dos laços e torná-los mais flexíveis. Essas instruções permitem que você tome decisões dentro do laço com base em certas condições, o que pode ser útil para parar o laço prematuramente ou pular para a próxima iteração.

Instrução break

A instrução break é usada para sair do laço imediatamente quando uma condição específica é atendida. Quando o Python encontra a instrução break dentro de um laço, ele encerra o laço imediatamente e continua a execução do código após o laço.

Exemplo: 

for i in range(5):
    if i == 3:
        break
    print(i)

Neste exemplo, o laço for irá iterar de 0 a 4, mas quando o valor de "i" for igual a 3, a instrução break será executada e o laço será encerrado prematuramente.

Instrução continue

A instrução continue é usada para pular para a próxima iteração do laço, ignorando o restante do bloco de código para aquela iteração específica. Quando o Python encontra a instrução continue dentro de um laço, ele pula para a próxima iteração sem executar o restante do código no bloco de laço para a iteração atual.

Exemplo: 

for i in range(5):
    if i == 2:
        continue
    print(i)

Neste exemplo, o laço for irá iterar de 0 a 4, mas quando o valor de "i" for igual a 2, a instrução continue será executada e o restante do bloco de código será ignorado para a iteração atual. Portanto, a saída será:

Uso do controle de laço

As instruções break e continue são úteis para criar lógica mais complexa dentro de laços, permitindo que você controle o fluxo de execução de acordo com condições específicas. Elas são frequentemente usadas em conjunto com condicionais (if, elif, else) dentro de laços.

Exemplo: 

for i in range(10):
    if i % 2 == 0:
        continue
    if i == 7:
        break
    print(i)

Neste exemplo, o laço for irá iterar de 0 a 9. A instrução continue é usada para pular as iterações com valores pares, e a instrução break é usada para interromper o laço quando o valor de "i" for igual a 7. Portanto, a saída será:

Observações:

O uso cuidadoso das instruções break e continue é essencial para evitar laços infinitos ou resultados inesperados.

As instruções break e continue funcionam tanto com laços for quanto com laços while.

O controle de laço com break e continue é uma técnica avançada e poderosa que permite personalizar a execução de laços em Python, tornando seus programas mais eficientes e flexíveis. Ao aplicar essas instruções adequadamente, você pode resolver problemas complexos e criar algoritmos mais inteligentes e eficazes.

4.2.5 - Estruturas de Repetição Aninhadas

As estruturas de repetição aninhadas em Python referem-se à prática de colocar laços (for, while) dentro de outros laços.

Essa técnica permite criar lógica com diferentes níveis de iteração. 

for i in range(3):
    for j in range(3):
        print(f"i = {i}, j = {j}")

Neste exemplo, temos um laço for aninhado dentro de outro laço for. O programa executa todas as combinações possíveis de valores de "i" e "j", imprimindo cada combinação.

Também podemos aninhar controles de repetição com controles condicionais. 

numeros = [1, 2, 3, 4, 5]
pares = []
impares = []

for num in numeros:
    if num % 2 == 0:
        pares.append(num)
    else:
        impares.append(num)

print("Números pares:", pares)
print("Números ímpares:", impares)

Neste exemplo, temos um laço for que itera sobre uma lista de números. Dentro do laço, há um condicional if para verificar se o número é par ou ímpar. Dependendo da condição, o número é adicionado à lista "pares" ou à lista "ímpares".

Observações:

O aninhamento de estruturas de controle pode se estender a vários níveis, mas é essencial manter uma boa organização e indentação do código para garantir a legibilidade.

Estruturas de controle aninhadas são úteis quando você precisa resolver problemas mais complexos que envolvem várias condições e iterações.

As estruturas de controle aninhadas em Python são uma ferramenta poderosa para lidar com lógica complexa em seus programas, permitindo criar algoritmos mais sofisticados e respostas adaptáveis a diferentes situações.

No entanto, é importante equilibrar o aninhamento para manter a clareza e a facilidade de manutenção do código.

Com prática e experiência, você poderá utilizar efetivamente essas estruturas aninhadas para resolver problemas desafiadores em seus projetos de desenvolvimento.

4.3 - Exemplos

Agora iremos explorar exemplos para aplicar as estruturas de controle aprendidas anteriormente.

  • Verificação de Números Primos: Escreva um programa em Python que recebe um número inteiro positivo do usuário e verifica se ele é um número primo. Um número primo é aquele que é divisível apenas por 1 e por ele mesmo.
  • Contagem de Vogais: Escreva um programa que solicita ao usuário uma palavra ou frase e conta quantas vogais (a, e, i, o, u) estão presentes nela.
  • Tabuada: Crie um programa que exiba a tabuada de multiplicação de um número fornecido pelo usuário. A tabuada deve ir de 1 a 10.
  • Jogo da Adivinhação: Desenvolva um jogo da adivinhação em que o programa escolhe um número aleatório entre 1 e 100, e o usuário deve tentar adivinhar qual é o número. O programa deve fornecer dicas se o número é maior ou menor que a tentativa do usuário.
  • Cálculo de Média e Situação Escolar: Peça ao usuário para informar as notas de três provas (de 0 a 10) e calcule a média. Em seguida, mostre a média e a situação escolar do aluno: "Aprovado" se a média for igual ou superior a 7, "Recuperação" se a média estiver entre 5 e 7, e "Reprovado" se a média for menor que 5.
  • Fatorial: Escreva um programa que recebe um número inteiro não negativo do usuário e calcula o fatorial desse número. O fatorial de um número é o produto de todos os inteiros positivos menores ou iguais a ele. Desafio 4 - Sequência de Fibonacci:
  • Fibonacci: Desenvolva um programa que recebe um número inteiro positivo do usuário e mostra os primeiros números da sequência de Fibonacci. A sequência de Fibonacci é uma série de números em que cada número é a soma dos dois anteriores: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...

Os exemplos práticos ajudarão você a aplicar as estruturas de controle em cenários reais, tornando o aprendizado mais significativo, incentivando a criatividade e o pensamento lógico, desafiando você a resolver problemas complexos.

4.3.1 - Verificação de Números Primos

Neste exemplo, vamos criar um programa em Python que recebe um número inteiro positivo do usuário e verifica se ele é um número primo ou não. Um número primo é aquele que é divisível apenas por 1 e por ele mesmo, ou seja, possui exatamente dois divisores. Vamos criar uma função que realiza essa verificação e exibe o resultado ao usuário. 

def eh_primo(numero):
    if numero <= 1:
        return False

    for i in range(2, int(numero**0.5) + 1):
        if numero % i == 0:
            return False

    return True

try:
    numero = int(input("Digite um número inteiro positivo: "))
    if eh_primo(numero):
        print(f"{numero} é um número primo.")
    else:
        print(f"{numero} não é um número primo.")
except ValueError:
    print("Entrada inválida. Digite um número inteiro positivo.")

Explicação

Criamos a função eh_primo(numero) que recebe um número inteiro como argumento e verifica se ele é um número primo ou não. Se o número for menor ou igual a 1, retornamos False, já que números menores ou iguais a 1 não são primos.

Em seguida, percorremos um laço de 2 até a raiz quadrada do número mais 1 (int(numero**0.5) + 1). A raiz quadrada é usada para otimizar o laço, pois não é necessário verificar divisores maiores que a raiz quadrada do número.

Dentro do laço, verificamos se o número é divisível por i. Se for, significa que ele possui mais de dois divisores e não é primo, então retornamos False.

Se o laço não encontrar divisores entre 2 e a raiz quadrada do número, retornamos True, indicando que o número é primo.

No bloco try-except, pedimos ao usuário para digitar um número inteiro positivo. Caso o usuário digite um valor inválido (por exemplo, uma letra ou número negativo), o programa captura a exceção ValueError e exibe uma mensagem de erro.

O programa, então, chama a função eh_primo(numero) com o valor digitado pelo usuário e imprime na tela o resultado da verificação.

Exemplo de Execução

Suponha que o usuário digite o número 13, que é um número primo. A saída do programa seria: 

Digite um número inteiro positivo: 13
13 é um número primo.

E se o usuário digitar o número 6, que não é primo, a saída seria: 

Digite um número inteiro positivo: 6
6 não é um número primo.

O programa verifica se o número digitado pelo usuário é um número primo ou não, fornecendo um resultado claro e correto.

4.3.2 - Contagem de Vogais

Neste exemplo, vamos criar um programa em Python que solicita ao usuário uma palavra ou frase e conta quantas vogais (a, e, i, o, u) estão presentes nela.

Vamos criar uma função que realiza e retorna a contagem de vogais em um texto. 

import unicodedata

vogais_nao_acentuadas = "aeiouAEIOU"
vogais_acento_agudo = "áéíóúÁÉÍÓÚ"
vogais_acento_grave = "àèìòùÀÈÌÒÙ"
vogais_acento_circunflexo = "âêîôûÂÊÎÔÛ"
vogais_acento_til = "ãẽĩõũÃẼĨÕŨ"
vogais_acento_trema = "äëïöüÄËÏÖÜ"

todas_vogais = \
    vogais_nao_acentuadas + \
    vogais_acento_agudo + \
    vogais_acento_grave + \
    vogais_acento_circunflexo + \
    vogais_acento_til + \
    vogais_acento_trema

todas_vogais_normalizadas = unicodedata.normalize("NFC", todas_vogais)

def contar_vogais(texto, vogais=todas_vogais_normalizadas):
    contador = 0
    for letra in texto:
        if letra in vogais:
            contador += 1
    return contador

Explicação

Criamos a função contar_vogais() que recebe um texto como argumento. A função inicializa uma variável contador para armazenar a quantidade de vogais encontradas.

Em seguida, criamos uma variáveis com os textos de vogais acentuadas, tanto minúsculas quanto maiúsculas.

Usamos um laço for para percorrer cada letra no texto passado na função no argumento texto.

Dentro do laço, verificamos se a letra está presente em texto. Se estiver, incrementamos o contador.

Quando o laço termina, retornamos o valor do contador, que representa a quantidade de vogais em texto.

Exemplo de Execução

Vamos testar algumas frases: 

print(contar_vogais('Primeiro teste!'))
print(contar_vogais('O dia está muito belo'))
print(contar_vogais('Amanhã é um novo dia'))

O programa conta as vogais presentes nas frases com as contagens de vogais acentuadas e não acentuadas.

Unicode

Os caracteres acentuados na variável todas_vogais contém caracteres compostos por uma letra seguida de um acento agudo como entidades separadas, e não como um único caractere pré-composto.

Isso pode ser uma fonte de confusão porque visualmente os caracteres parecem ser únicos com acentos, mas tecnicamente eles são formados por duas unidades de código (ou "code points") no padrão Unicode: uma para a letra e outra para o acento.

No Python, quando você acessa vogais_acento[0], onde supsotamente se encontra a letra 'á', ele retorna o primeiro "code point" Unicode da string, que no caso é a letra 'a', e não o caractere composto 'á'.

No exemplo acima, a função normalize do módulo unicodedata com o modo 'NFC' (Normalization Form Composed), combinou os caracteres e os acentos em um único "code point", se possível.

Depois dessa normalização, ao acessar os índices do texto da variável todas_vogais_normalizadas, serão retornados os caracteres acentuados como um caracter único, como esperado.

4.3.3 - Tabuada

Neste desafio, vamos criar um programa em Python que recebe um número inteiro do usuário e exibe a tabuada de multiplicação desse número, indo de 1 a 10.

Vamos criar uma função para calcular a tabuada e exibir os resultados ao usuário. 

def tabuada_multiplicacao(numero):
    print(f"Tabuada de multiplicação do número {numero}:")
    for i in range(1, 11):
        resultado = numero * i
        print(f"{numero} x {i} = {resultado}")

Explicação

Criamos a função tabuada_multiplicacao(numero) que recebe um número inteiro numero como argumento. A função exibe a tabuada de multiplicação do número fornecido, indo de 1 a 10.

Utilizamos um laço for usando função range(1, 11) para percorrer os valores de 1 a 10.

Dentro do laço, calculamos o resultado da multiplicação entre número e i e o armazenamos na variável resultado.

Em seguida, imprimimos a expressão da tabuada no formato "numero x i = resultado".

Exemplo de Execução

Vamos fazer a tabuada de 1 a 10. 

for i in range(1, 11):
    tabuada_multiplicacao(i)

O programa exibe a tabuada de multiplicação dos número 1 a 10, muiltiplicando estes valores de 1 a 10.

Cada linha representa uma multiplicação diferente, e o resultado é exibido ao lado da expressão.

4.3.4 - Jogo da Adivinhação

Neste desafio, vamos criar um programa em Python que implementa o clássico "Jogo da Adivinhação".

O programa irá gerar um número aleatório entre 1 e 100 e pedir ao usuário para adivinhar qual é esse número. O usuário terá um número limitado de tentativas para acertar o número.

Vamos fornecer dicas ao usuário, informando se o número a ser adivinhado é maior ou menor do que o palpite atual. 

import random

def jogo_da_adivinhacao():
    numero_secreto = random.randint(1, 100)
    max_tentativas = 10

    print("Bem-vindo ao Jogo da Adivinhação!")
    print("Tente adivinhar o número secreto entre 1 e 100.")

    for tentativa in range(1, max_tentativas + 1):
        palpite = int(input(f"Tentativa {tentativa}: Digite seu palpite: "))

        if palpite == numero_secreto:
            print(f"Parabéns! Você acertou o número secreto {numero_secreto} em {tentativa} tentativa(s)!")
            break
        elif palpite < numero_secreto:
            print("Dica: O número secreto é maior.")
        else:
            print("Dica: O número secreto é menor.")

    else:
        print(f"Fim de jogo! O número secreto era {numero_secreto}. Tente novamente!")

try:
    jogo_da_adivinhacao()
except ValueError:
    print("Entrada inválida. Digite apenas números inteiros.")

Explicação

Importamos o módulo random para gerar o número secreto aleatoriamente.

Criamos a função jogo_da_adivinhacao() que será responsável por executar o jogo.

A variável numero_secreto é inicializada com um número aleatório entre 1 e 100 usando random.randint(1, 100).

Definimos a variável max_tentativas para limitar o número de tentativas que o usuário terá para adivinhar o número.

Dentro do laço for, o programa pede ao usuário para digitar o palpite.

O programa verifica se o palpite é igual ao número secreto. Se for, o usuário acertou e o programa exibe uma mensagem de parabéns com o número de tentativas.

Caso o palpite seja menor que o número secreto, o programa fornece a dica "O número secreto é maior.", e caso for maior, fornece a dica "O número secreto é menor.".

Se o laço terminar sem que o usuário acerte o número, o programa exibe uma mensagem de "Fim de jogo" e revela o número secreto.

Exemplo de Execução

A cada tentativa, o usuário deve digitar um palpite. Suponha que o número secreto seja 50. Uma possível sequência de interação pode ser: 

Bem-vindo ao Jogo da Adivinhação!
Tente adivinhar o número secreto entre 1 e 100.
Tentativa 1: Digite seu palpite: 75
Dica: O número secreto é menor.
Tentativa 2: Digite seu palpite: 40
Dica: O número secreto é maior.
Tentativa 3: Digite seu palpite: 55
Dica: O número secreto é menor.
Tentativa 4: Digite seu palpite: 50
Parabéns! Você acertou o número secreto 50 em 4 tentativa(s)!

O programa fornece dicas ao usuário, indicando se o número secreto é maior ou menor do que o palpite atual, até que o usuário acerte o número ou atinja o limite de tentativas.

4.3.5 - Cálculo de Média e Situação Escolar

Neste desafio, vamos criar um programa em Python que solicita ao usuário as notas de três provas e calcula a média aritmética dessas notas.

Em seguida, o programa determina a situação escolar do aluno com base na média obtida. 

def calcular_media(nota1, nota2, nota3):
    return (nota1 + nota2 + nota3) / 3

def verificar_situacao(media):
    if media >= 7:
        return "Aprovado"
    elif 5 <= media < 7:
        return "Recuperação"
    else:
        return "Reprovado"

try:
    nota1 = float(input("Digite a nota da primeira prova: "))
    nota2 = float(input("Digite a nota da segunda prova: "))
    nota3 = float(input("Digite a nota da terceira prova: "))

    media_aluno = calcular_media(nota1, nota2, nota3)
    situacao_aluno = verificar_situacao(media_aluno)

    print(f"A média do aluno é: {media_aluno:.2f}")
    print(f"Situação Escolar: {situacao_aluno}")

except ValueError:
    print("Entrada inválida. Digite apenas números.")

Explicação

Criamos a função calcular_media(nota1, nota2, nota3) que recebe as três notas das provas como argumentos e retorna a média aritmética das notas.

Em seguida, criamos a função verificar_situacao(media) que recebe a média como argumento e retorna a situação escolar do aluno com base na média.

Dentro da função verificar_situacao, utilizamos declarações if-elif-else para determinar a situação do aluno de acordo com os seguintes critérios:

Se a média for maior ou igual a 7, o aluno é aprovado.

Se a média estiver entre 5 (inclusive) e 7 (exclusivo), o aluno está em recuperação.

Caso contrário, o aluno é reprovado.

No bloco try-except, solicitamos ao usuário para digitar as notas das três provas. Se o usuário digitar um valor inválido (por exemplo, uma letra), o programa captura a exceção ValueError e exibe uma mensagem de erro.

O programa, então, calcula a média do aluno chamando a função calcular_media(nota1, nota2, nota3) com as notas fornecidas pelo usuário.

Em seguida, o programa determina a situação do aluno chamando a função verificar_situacao(media_aluno) com a média calculada.

Por fim, o programa exibe a média do aluno e sua situação escolar na tela.

Exemplo de Execução

Suponha que o usuário digite as notas 7, 8 e 6, respectivamente. A saída do programa seria: 

Digite a nota da primeira prova: 7
Digite a nota da segunda prova: 8
Digite a nota da terceira prova: 6
A média do aluno é: 7.00
Situação Escolar: Aprovado

O programa calcula a média (7 + 8 + 6) / 3 = 7 e informa que o aluno foi aprovado, pois a média é maior ou igual a 7.

4.3.6 - Fatorial

Neste exemplo, vamos criar um programa em Python que calcula o fatorial de um número fornecido pelo usuário. O fatorial de um número inteiro positivo "n" é o produto de todos os números inteiros positivos menores ou iguais a "n". Vamos criar uma função para calcular o fatorial e exibir o resultado ao usuário. 

def calcular_fatorial(numero):
    if numero < 0:
        return None
    elif numero == 0:
        return 1
    else:
        fatorial = 1
        for i in range(1, numero + 1):
            fatorial *= i
        return fatorial

try:
    numero = int(input("Digite um número inteiro positivo: "))

    resultado_fatorial = calcular_fatorial(numero)

    if resultado_fatorial is not None:
        print(f"O fatorial de {numero} é: {resultado_fatorial}")
    else:
        print("O fatorial não está definido para números negativos.")
except ValueError:
    print("Entrada inválida. Digite um número inteiro positivo.")

Explicação

Criamos a função calcular_fatorial(numero) que recebe um número inteiro numero como argumento e retorna o fatorial do número.

Antes de realizar o cálculo, verificamos se o numero é negativo. Se for, retornamos None, indicando que o fatorial não está definido para números negativos.

Se o numero for igual a 0, retornamos 1, pois o fatorial de 0 é 1.

Caso contrário, inicializamos a variável fatorial com o valor 1 e usamos um laço for i in range(1, numero + 1) para calcular o fatorial.

Multiplicamos o valor de fatorial por cada número inteiro de 1 até numero, atualizando o valor de fatorial a cada iteração.

Por fim, retornamos o valor de fatorial, que é o fatorial do número numero.

No bloco try-except, solicitamos ao usuário para digitar um número inteiro positivo. Se o usuário digitar um valor inválido (por exemplo, uma letra), o programa captura a exceção ValueError e exibe uma mensagem de erro.

O programa, então, chama a função calcular_fatorial(numero) com o valor digitado pelo usuário e imprime na tela o resultado do cálculo do fatorial.

Exemplo de Execução

Suponha que o usuário digite o número 5. A saída do programa seria: 

Digite um número inteiro positivo: 5
O fatorial de 5 é: 120
O programa calcula o fatorial de 5 (5 x 4 x 3 x 2 x 1) e exibe o resultado 120.

4.3.7 - Sequência de Fibonacci

Neste desafio, vamos criar um programa em Python que gera a sequência de Fibonacci. A sequência de Fibonacci é uma sequência de números em que cada número é a soma dos dois números anteriores. Os primeiros dois números da sequência são 0 e 1. Vamos criar uma função que gera a sequência de Fibonacci até um determinado limite fornecido pelo usuário. 

def gerar_sequencia_fibonacci(limite):
    sequencia = [0, 1]

    while True:
        proximo_numero = sequencia[-1] + sequencia[-2]
        if proximo_numero > limite:
            break
        sequencia.append(proximo_numero)

    return sequencia

try:
    limite = int(input("Digite o limite para a sequência de Fibonacci: "))

    sequencia_fibonacci = gerar_sequencia_fibonacci(limite)

    print("Sequência de Fibonacci:")
    for numero in sequencia_fibonacci:
        print(numero)

except ValueError:
    print("Entrada inválida. Digite um número inteiro.")

Explicação

Criamos a função gerar_sequencia_fibonacci(limite) que recebe um número inteiro limite como argumento e gera a sequência de Fibonacci até esse limite.

Inicializamos a lista sequencia com os primeiros dois números da sequência, que são 0 e 1.

Utilizamos um laço while True para continuar gerando números da sequência até que o próximo número seja maior que o limite fornecido.

Dentro do laço, calculamos o próximo número da sequência somando os dois últimos números da lista sequencia (sequencia[-1] e sequencia[-2]).

Verificamos se o próximo número é maior que o limite. Se for, interrompemos o laço usando a instrução break.

Caso contrário, adicionamos o próximo número à lista sequencia.

Por fim, retornamos a lista sequencia contendo a sequência de Fibonacci até o limite fornecido.

No bloco try-except, solicitamos ao usuário para digitar um limite para a sequência de Fibonacci. Se o usuário digitar um valor inválido (por exemplo, uma letra), o programa captura a exceção ValueError e exibe uma mensagem de erro.

O programa, então, chama a função gerar_sequencia_fibonacci(limite) com o valor digitado pelo usuário e imprime na tela os números da sequência de Fibonacci.

Exemplo de Execução

Suponha que o usuário digite o limite 100. A saída do programa seria: 

Digite o limite para a sequência de Fibonacci: 100
Sequência de Fibonacci:
0
1
1
2
3
5
8
13
21
34
55
89

O programa gera a sequência de Fibonacci até o limite de 100 e imprime os números da sequência. Cada número é a soma dos dois números anteriores na sequência.

Arduino
Coautor
Betobyte
Autor
Autores
||| Áreas ||| Estatística ||| Python ||| Projetos ||| Dicas & Truques ||| Quantum ||| Python para Iniciantes || Python para Iniciantes || Python Básico || Matplotlib || Numpy || Seaborn || Pandas || Django || Estatística para Cientistas de Dados || Python com ML Básico || Python com ML Básico || Aulas | Introdução (Instalação, variáveis e tipos de dados, operações, formatação e comentários.) | Coleções (Listas, Tuplas, Conjuntos e Dicionários.) | Funções e Módulos (Declaração, argumentos, retorno, recursão, funções lambda.) | Estruturas de Controle (Controle Condicional (if/elif/else, match) e Controle de repetição (for, while).) | Classes (Classes, Herança e Polimorfismo.) | Bibliotecas e Frameworks (Pacotes integrados, instalados e personalizados.) | Manipulação de Arquivos (Manipulação de Arquivos) | Bancos de Dados SQL (MySQL, SQLite e PostgreSQL.) | Capítulo 9 (APIs e Web Scraping) | Capítulo 10 (Projetos Práticos) | Considerações finais () |