Capítulo 4: Controle de Fluxo e Números Aleatórios

Capítulo 4: Controle de Fluxo e Números Aleatórios#

ch4

Estruturas de Decisão Aninhadas#

🎙️ Ouça a explicação sobre condicionais (if-elif-else):

As estruturas condicionais permitem que o programador controle o fluxo do programa, executando diferentes blocos de código de acordo com condições específicas. Vamos revisar as estruturas mais utilizadas:

  • if: Avalia uma condição e executa um bloco de código se a condição for verdadeira.

  • elif: Avalia uma condição e executa um bloco de código se a condição for verdadeira, mas somente se a condição anterior for falsa.

  • else: Executa um bloco de código se todas as condições anteriores forem falsas.

Cadeias de Comparação:

Python permite cadeias de comparação, que são uma maneira concisa de expressar múltiplas comparações. Por exemplo, if a < b < c: é equivalente a if a < b and b < c:.

Aninhamento de Estruturas Condicionais:

O poder real das estruturas condicionais reside na capacidade de aninhá-las, criando lógica complexa para lidar com diferentes cenários.

Exemplo: Verificação de Maioridade e Sexo

idade = 25
sexo = "Feminino"

if idade >= 18:
    print("Você é maior de idade.")
    if sexo == "Feminino":
        print("E também do sexo feminino.")
else:
    print("Você é menor de idade.")

Saída do Código:

Você é maior de idade.
E também do sexo feminino.

Neste exemplo, verificamos a idade e o sexo da pessoa. Se a pessoa for maior de idade, verificamos o sexo e imprimimos uma mensagem adicional se for feminino.

Exemplo: Classificação de Notas com Cadeias de Comparação

nota = 75

if 90 <= nota < 100:
    print("Parabéns! Você obteve uma nota A.")
elif 80 <= nota < 90:
    print("Ótimo! Sua nota é B.")
elif 70 <= nota < 80:
    print("Bom trabalho! Sua nota é C.")
else:
    print("Infelizmente, você não atingiu a nota mínima. Sua nota é D.")

Saída do Código:

Bom trabalho! Sua nota é C.

Neste exemplo, a nota do aluno é comparada em intervalos usando cadeias de comparação. O código verifica a qual faixa de notas a nota pertence e imprime uma mensagem correspondente. Como a nota é 75, a condição 70 <= nota < 80 é satisfeita, e o programa imprime que o aluno obteve uma nota C.

Estrutura de Repetição for#

O loop for é amplamente utilizado em Python para realizar iterações sobre coleções de dados como listas, tuplas, dicionários e até strings.

for

Mas antes de explorarmos a estrutura do for, é importante entender dois conceitos fundamentais: a função range() e o operador in.

A Função range()#

A função range() é utilizada para gerar sequências numéricas. Ela pode ser configurada para definir o início, o fim e o intervalo entre os números da sequência, utilizando a seguinte sintaxe:

  • range(início, fim, passo), onde:

    • início: O primeiro número da sequência (inclusivo). O valor padrão é 0.

    • fim: O último número da sequência (exclusivo).

    • passo: A diferença entre os números consecutivos. O valor padrão é 1.

Por exemplo:

# Gera uma lista com os números de 0 a 4
lista_numeros = list(range(5))
print(lista_numeros)

Saída do Código:

[0, 1, 2, 3, 4]

Neste exemplo, a função range(5) gera uma sequência de números de 0 a 4, e usamos list() para transformar essa sequência em uma lista visível.

Outro exemplo com incremento de 2:

# Gera uma lista com números pares de 0 a 10
pares = list(range(0, 11, 2))
print(pares)

Saída do Código:

[0, 2, 4, 6, 8, 10]

Aqui, range(0, 11, 2) gera uma sequência de números pares de 0 a 10 com incrementos de 2.

O Operador in#

O operador in é usado para verificar se um valor está presente em uma sequência, e no contexto do loop for, ele indica que o loop deve iterar sobre cada elemento dessa sequência.

Por exemplo:

if 3 in [1, 2, 3, 4, 5]:
    print("3 está presente na lista")

Saída do Código:

3 está presente na lista

Aqui, o operador in verifica se o número 3 está dentro da lista. Ele retorna True se o valor estiver presente e False caso contrário.

O Loop for#

Agora que entendemos range() e o operador in, podemos introduzir o loop for. Ele permite iterar sobre cada elemento de uma sequência (lista, string, tupla, etc.) e executar um bloco de código para cada elemento:

for variavel in sequencia:
    # Bloco de código a ser repetido

A variável assume, em cada iteração, o valor de um elemento da sequência, e o bloco de código é executado para cada um desses valores.

Exemplo Prático: Iterando Sobre uma Sequência Numérica#

Com base no que aprendemos sobre range(), podemos agora utilizar um loop for para iterar sobre a sequência de números:

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

Saída do Código:

0
1
2
3
4

Aqui, o loop for itera sobre a sequência gerada por range(5), imprimindo os números de 0 a 4.

Iterando Sobre uma String#

Podemos usar o loop for para iterar sobre os caracteres de uma string:

palavra = "Python"
for letra in palavra:
    print(letra)

Saída do Código:

P
y
t
h
o
n

Nesse caso, o loop for percorre cada letra da string "Python" e as imprime individualmente.

Iterando Sobre uma Lista de Números#

Podemos também usar o loop for para percorrer uma lista de números e realizar cálculos:

numeros = [10, 20, 30, 40, 50]
for num in numeros:
    print(f"O dobro de {num} é {2 * num}.")

Saída do Código:

O dobro de 10 é 20.
O dobro de 20 é 40.
O dobro de 30 é 60.
O dobro de 40 é 80.
O dobro de 50 é 100.

Nesse exemplo, iteramos sobre cada número na lista numeros e imprimimos o seu dobro.

Executando um Número Específico de Vezes#

Se quisermos executar um bloco de código um número fixo de vezes, podemos usar o for com range():

for _ in range(3):
    print("Olá, mundo!")

Saída do Código:

Olá, mundo!
Olá, mundo!
Olá, mundo!

O uso de _ como variável (também chamado de placeholder) indica que não estamos interessados no valor da variável durante a iteração, apenas no número de vezes que o loop será executado.

Iterando Sobre um Dicionário#

Podemos usar o loop for para percorrer as chaves e valores de um dicionário:

aluno_notas = {"João": 8.5, "Maria": 9.0, "Pedro": 7.8}
for nome, nota in aluno_notas.items():
    print(f"{nome} obteve nota {nota}.")

Saída do Código:

João obteve nota 8.5.
Maria obteve nota 9.0.
Pedro obteve nota 7.8.

Aqui, o método .items() permite iterar tanto pelas chaves quanto pelos valores do dicionário, imprimindo o nome do aluno e sua respectiva nota.

Entendendo o for Aninhado#

Em alguns casos, pode ser necessário usar loops aninhados, ou seja, um loop for dentro de outro. Um exemplo prático seria iterar sobre uma matriz (ou tabela) de números:

matriz = [
    [1, 2, 3],  # Primeira linha
    [4, 5, 6],  # Segunda linha
    [7, 8, 9]   # Terceira linha
]

for linha in matriz:
    for numero in linha:
        print(numero, end=' ')  # Mantém os números da mesma linha juntos
    print()  # Pula para a próxima linha

Saída do Código:

1 2 3 
4 5 6 
7 8 9

Aqui, usamos um loop externo para percorrer cada linha da matriz, e um loop interno para percorrer cada número dentro da linha. A combinação de loops permite navegar em estruturas mais complexas como essa.

Outro Exemplo de for Aninhado#

Vamos usar um for aninhado para gerar todas as combinações possíveis entre dois grupos de elementos. Imagine que você tem duas listas, uma de cores e outra de tamanhos, e quer combinar cada cor com cada tamanho.

cores = ["vermelho", "azul", "verde"]
tamanhos = ["P", "M", "G"]

for cor in cores:
    for tamanho in tamanhos:
        print(f"{cor} - {tamanho}")

Saída do Código:

vermelho - P
vermelho - M
vermelho - G
azul - P
azul - M
azul - G
verde - P
verde - M
verde - G

Nesse exemplo, o loop externo itera sobre cada cor e o loop interno itera sobre cada tamanho, gerando todas as combinações possíveis de cor e tamanho. Este é um exemplo clássico de como o for aninhado pode ser útil para resolver problemas envolvendo múltiplos conjuntos de dados.

Estrutura de Repetição while#

O loop while é Utilizado para repetir um bloco de código enquanto uma condição especificada for verdadeira, proporcionando controle preciso sobre o fluxo de execução.

for

A estrutura do loop while é composta por duas partes. Sua sintaxe básica é:

while condicao:
    # Bloco de código a ser repetido

  • Condição: Uma expressão booleana que determina se o loop deve continuar ou parar.

  • Bloco de Código: As instruções que serão executadas enquanto a condição for verdadeira.

Exemplo de um contador simples para contar até 5 usando o loop while:

contador = 1
while contador <= 5:
    print(contador)
    contador += 1

Saída do Código:

1
2
3
4
5

Explicando o código:

  • contador é inicializado com 1.

  • A condição contador <= 5 é avaliada. Se for True, o bloco de código é executado.

  • print(contador) imprime o valor atual de contador.

  • contador += 1 incrementa contador em 1.

  • O loop repete enquanto a condição for True, até que contador seja maior que 5.

Imprimindo os Números Pares de 1 a 10:

numero = 1
while numero <= 10:
    if numero % 2 == 0:
        print(numero)
    numero += 1

Saída do Código:

2
4
6
8
10

  • O loop itera de 1 a 10.

  • A condição numero % 2 == 0 verifica se numero é par.

  • Se for par, print(numero) imprime o número.

  • numero += 1 incrementa numero em 1.

Usando o while not#

Durante o while not, o loop continua enquanto a condição, por exemplo, da variável flag for False.

flag = False
while not flag:
    resposta = input("Você deseja sair? (sim/não): ")
    if resposta.lower() == 'sim':
        flag = True
print("Você saiu do loop.")

Explicando o código:

  • flag é inicializada como False.

  • O loop while not continua enquanto flag for False.

  • O usuário é solicitado a responder se deseja sair.

  • Se o usuário digitar “sim”, flag se torna True.

  • Quando flag é True, o loop termina e imprime “Você saiu do loop.”

While dentro de outro while: Exemplo de aninhamento de loops while.

x = 0
while x < 3:
    y = 0
    while y < 2:
        print(f"Valor de x: {x}, Valor de y: {y}")
        y += 1
    x += 1

Saída do Código:

Valor de x: 0, Valor de y: 0
Valor de x: 0, Valor de y: 1
Valor de x: 1, Valor de y: 0
Valor de x: 1, Valor de y: 1
Valor de x: 2, Valor de y: 0
Valor de x: 2, Valor de y: 1

Aqui, x varia de 0 a 2 e y de 0 a 1. Para tornar o exemplo mais interessante, podemos adicionar uma condição para destacar quando x e y são iguais:

x = 0
while x < 3:
    y = 0
    while y < 2:
        if x == y:
            print(f"X e Y são iguais e valem: {x}!")
        else:
            print(f"Valor de x: {x}, Valor de y: {y}")
        y += 1
    x += 1

Saída do Código:

X e Y são iguais e valem: 0!
Valor de x: 0, Valor de y: 1
Valor de x: 1, Valor de y: 0
X e Y são iguais e valem: 1!
Valor de x: 2, Valor de y: 0
Valor de x: 2, Valor de y: 1

For dentro de um while#

Também é possível aninhar estruturas diferentes, como um loop for dentro de um loop while.

x = 0
while x < 3:
    for i in range(3):
        print(f"Valor de x: {x}, Valor de i: {i}")
    x += 1

Saída do Código:

Valor de x: 0, Valor de i: 0
Valor de x: 0, Valor de i: 1
Valor de x: 0, Valor de i: 2
Valor de x: 1, Valor de i: 0
Valor de x: 1, Valor de i: 1
Valor de x: 1, Valor de i: 2
Valor de x: 2, Valor de i: 0
Valor de x: 2, Valor de i: 1
Valor de x: 2, Valor de i: 2

No último exemplo, x é incrementado após cada ciclo do loop for, até que atinja o valor 3 e o loop while seja interrompido.

Compreensões de Listas (List Comprehensions)#

Uma das características mais poderosas do Python é a capacidade de simplificar operações complexas em poucas linhas de código, e as compreensões de listas são um exemplo perfeito disso.

As compreensões de listas fornecem uma maneira concisa de criar listas. Aplicações comuns incluem gerar novas listas em que cada elemento é o resultado de alguma operação aplicada a cada membro de outra sequência ou iterável, ou criar uma subsequência de elementos que atendem a uma determinada condição.

Sintaxe Básica#

A sintaxe básica de uma compreensão de lista é:

[expressão for item in iterável if condição]

  • expressão: A operação que será realizada em cada item, como uma operação matemática ou chamada de função.

  • item: Representa cada elemento da sequência ou coleção que está sendo percorrida.

  • iterável: Uma sequência (lista, tupla, etc.) ou coleção (conjunto, dicionário, etc.) sobre a qual você deseja iterar.

  • condição (opcional): Um filtro que inclui apenas os elementos onde a condição for verdadeira.

Exemplo: Elevando Números ao Quadrado#

Suponha que você queira elevar ao quadrado cada número em uma lista. Veja como isso pode ser feito usando uma compreensão de lista:

numeros = [1, 2, 3, 4, 5]
quadrados = [x ** 2 for x in numeros]
print(quadrados)

Saída do Código:

[1, 4, 9, 16, 25]

Exemplo: Filtrando e Elevando ao Quadrado Apenas Números Pares#

Agora, suponha que você queira elevar ao quadrado apenas os números pares de uma lista. Para isso, você pode adicionar uma condição if na compreensão de lista. Veja o exemplo:

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
quadrados_pares = [x ** 2 for x in numeros if x % 2 == 0]
print(quadrados_pares)

Saída do Código:

[4, 16, 36, 64, 100]

Nesse exemplo, a lista resultante contém apenas os quadrados dos números pares, pois o if x % 2 == 0 filtra os elementos da lista original, garantindo que apenas os pares sejam elevados ao quadrado.

Compreensão de Lista vs. Estrutura Convencional#

Para ver o quanto as compreensões de listas podem simplificar o código, compare a filtragem de números pares e a elevação ao quadrado com e sem o uso de compreensão de listas.

Sem Compreensão de Lista (Modo Convencional)

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
quadrados_pares = []

for x in numeros:
    if x % 2 == 0:
        quadrados_pares.append(x ** 2)

print(quadrados_pares)

Nesse caso, o código exige várias linhas para definir a lista resultante, iterar sobre a lista original, aplicar a condição e adicionar os resultados.

Com Compreensão de Lista

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
quadrados_pares = [x ** 2 for x in numeros if x % 2 == 0]
print(quadrados_pares)

Aqui, a compreensão de lista condensa a lógica em uma única linha, mantendo o código mais direto e legível.

Ao usar compreensões de listas, você pode reduzir significativamente o número de linhas de código, facilitando a leitura e a manutenção. Isso torna o código mais “Pythonic” e é especialmente útil para operações que envolvem filtragem e mapeamento de dados, como no exemplo acima, onde o código foi reduzido de cinco linhas para apenas uma.

Controle de Fluxo com exit(), break, continue e pass#

Python oferece diversas maneiras de controlar o fluxo de execução em um programa. Entre elas, destacam-se exit(), break, continue e pass, que permitem encerrar a execução de loops, pular iterações ou até mesmo deixar blocos de código propositalmente vazios.

Esses comandos são fundamentais para tornar seu código mais dinâmico, controlado e legível.

Encerrando o Programa com exit()#

A função exit() é usada para encerrar completamente a execução do programa. Se chamada dentro de um loop, ela interrompe o loop e encerra o programa imediatamente — nenhum código subsequente será executado.

Exemplo de uso do exit() em um loop for#

frutas = ["maçã", "uva", "morango", "banana", "abacaxi"]
for fruta in frutas:
    if fruta == "banana":
        print("Encontrei uma banana! Saindo do programa.")
        exit()
    print(f"Estou processando a fruta {fruta}.")
print("Estou fora do Loop.")  # Esta linha não será executada.

Saída:

Estou processando a fruta maçã.
Estou processando a fruta uva.
Estou processando a fruta morango.
Encontrei uma banana! Saindo do programa.

Quando “banana” é encontrada, exit() é chamado e o programa é encerrado imediatamente, sem executar o restante do código.

Saindo do Loop Atual com break#

O comando break é usado para interromper apenas o loop atual, permitindo que o restante do código continue sendo executado após o loop.

Exemplo de uso do break em um loop for#

frutas = ["maçã", "uva", "morango", "banana", "abacaxi"]
for fruta in frutas:
    if fruta == "banana":
        print("Encontrei uma banana! Saindo do loop.")
        break
    print(f"Estou processando a fruta {fruta}.")
print("Estou fora do Loop.")

Saída:

Estou processando a fruta maçã.
Estou processando a fruta uva.
Estou processando a fruta morango.
Encontrei uma banana! Saindo do loop.
Estou fora do Loop.

Aqui, o break encerra apenas o loop for. O programa segue normalmente após o loop.

Exemplo de uso do break em um loop while#

while True:
    opcao = input("Digite uma opção (a/b/c/sair): ")
    if opcao == "sair":
        print("Saindo do programa.")
        break
    elif opcao == "a":
        print("Executando ação relacionada à opção 'a'")
    elif opcao == "b":
        print("Executando ação relacionada à opção 'b'")
    else:
        print("Opção inválida. Tente novamente.")

Neste caso, o loop while se repete indefinidamente até que o usuário digite “sair”. Nesse momento, o break interrompe o loop e o programa continua sua execução normalmente.

Pulando para a Próxima Iteração com continue#

O comando continue é utilizado quando você deseja pular o restante do código dentro do loop atual e voltar imediatamente ao início da próxima iteração.

Exemplo de uso do continue em um loop for#

frutas = ["maçã", "uva", "morango", "banana", "abacaxi"]
for fruta in frutas:
    if fruta == "banana":
        print("Ignorando a banana.")
        continue
    print(f"Estou processando a fruta {fruta}.")
print("Estou fora do Loop.")

Saída:

Estou processando a fruta maçã.
Estou processando a fruta uva.
Estou processando a fruta morango.
Ignorando a banana.
Estou processando a fruta abacaxi.
Estou fora do Loop.

Quando o loop encontra “banana”, o continue faz com que o restante do código dentro do loop seja ignorado e a próxima iteração seja iniciada.

Criando Blocos Vazios com pass#

O comando pass é usado como um espaço reservado (placeholder) em blocos de código que ainda não foram implementados. Ele não faz nada — serve apenas para manter a estrutura sintaticamente válida.

Exemplo de uso do pass#

frutas = ["maçã", "uva", "morango", "banana", "abacaxi"]

for fruta in frutas:
    if fruta == "banana":
        pass  # Futuramente, adicionarei algo aqui
    else:
        print(f"Estou processando a fruta {fruta}.")

Saída:

Estou processando a fruta maçã.
Estou processando a fruta uva.
Estou processando a fruta morango.
Estou processando a fruta abacaxi.

Neste exemplo, o pass é usado como um marcador para indicar que, no caso de “banana”, nada deve acontecer (por enquanto). É útil durante o desenvolvimento, quando você ainda está planejando a lógica do código.

Resumo das Diferenças#

Comando

Ação

Escopo de Efeito

Observação

exit()

Encerra todo o programa

Global

Nenhum código após ele é executado

break

Interrompe apenas o loop atual

Local (loop)

Continua o código após o loop

continue

Pula para a próxima iteração do loop

Local (loop)

Ignora o restante da iteração atual

pass

Não faz nada (placeholder)

Local

Mantém a sintaxe válida sem ação executada

Números Aleatórios#

O módulo random em Python facilita a geração de números aleatórios, fornecendo uma interface simples e direta. Este módulo implementa geradores de números pseudoaleatórios, que produzem sequências de números que aproximam a aleatoriedade verdadeira para diversas distribuições estatísticas.

💡 Curiosidade: números verdadeiramente aleatórios podem ser gerados a partir de fenômenos físicos — como ruído atmosférico — em serviços como o random.org.

Módulos em Python#

Módulos em Python são arquivos contendo definições e instruções que podem ser reutilizadas em outros programas. Para utilizá-los, é preciso importá-los com a instrução import, seguida pelo nome do módulo.

Por exemplo, para importar o módulo random (responsável pela geração de números aleatórios):

import random

Depois de importado, suas funções e classes podem ser acessadas usando a notação de ponto, como random.random(), random.randint() e random.choice().

Métodos Comuns do Módulo random#

Método

Descrição

Exemplo

random.random()

Retorna um número flutuante aleatório entre 0 e 1

random.random() ➞ 0.45

random.randint(a, b)

Retorna um número inteiro aleatório entre a e b (inclusive)

random.randint(1, 10) ➞ 7

random.choice(seq)

Retorna um elemento aleatório de uma sequência

random.choice(['maçã', 'banana', 'cereja']) ➞ 'banana'

random.sample(seq, k)

Retorna uma amostra de k elementos aleatórios de uma sequência

random.sample([1, 2, 3, 4, 5], 3) ➞ [4, 1, 5]

random.shuffle(seq)

Embaralha a sequência original

lista = [1, 2, 3]; random.shuffle(lista); lista ➞ [3, 1, 2]

Exemplos de Uso#

Aqui estão alguns exemplos de como gerar números aleatórios com o módulo random:

import random

# Gerar um número flutuante aleatório entre 0 e 1
random_float = random.random()
print(f"Número flutuante aleatório entre 0 e 1: {random_float}")

# Gerar um número inteiro aleatório entre 1 e 10
random_integer = random.randint(1, 10)
print(f"Número inteiro aleatório entre 1 e 10: {random_integer}")

# Escolher aleatoriamente um item de uma lista
lista = ['maçã', 'banana', 'cereja']
escolha_aleatoria = random.choice(lista)
print(f"Escolha aleatória de uma lista: {escolha_aleatoria}")

# Amostra aleatória de elementos de uma lista
amostra_aleatoria = random.sample(lista, 2)
print(f"Amostra aleatória de 2 elementos da lista: {amostra_aleatoria}")

Saída do código (exemplo):

Número flutuante aleatório entre 0 e 1: 0.08329587492346713
Número inteiro aleatório entre 1 e 10: 8
Escolha aleatória de uma lista: maçã
Amostra aleatória de 2 elementos da lista: ['banana', 'cereja']

Definindo uma Semente#

Definir uma semente pode ser útil quando você precisa reproduzir resultados específicos em execuções diferentes do mesmo programa. Ao definir uma semente com random.seed(valor), a sequência de números gerada será sempre a mesma.

import random

# Define uma semente para reproduzibilidade
random.seed(123)

for i in range(3):
    print(f"Número aleatório {i+1}: {random.randint(1, 100)}")

Saída do código (exemplo):

Número aleatório 1: 7
Número aleatório 2: 34
Número aleatório 3: 27

Nota: O Python, por padrão, já inicializa a semente automaticamente com base em fontes de entropia do sistema, garantindo resultados aleatórios diferentes a cada execução. Você só precisa usar random.seed() quando desejar controlar a geração de números aleatórios (por exemplo, em testes ou simulações reproduzíveis).

Exemplo: Simulando um Jogo de Dados#

Vamos criar um exemplo simples em que dois jogadores lançam um dado, e o primeiro a tirar um 6 vence a rodada.

import random

# Simulação do jogo
jogador1_vitorias = 0
jogador2_vitorias = 0

for i in range(1, 11):  # Simular 10 rodadas
    jogador1_resultado = random.randint(1, 6)
    jogador2_resultado = random.randint(1, 6)

    print(f"Rodada {i}: Jogador 1 tirou {jogador1_resultado}, Jogador 2 tirou {jogador2_resultado}")

    if jogador1_resultado == 6 and jogador2_resultado == 6:
        print("Empate nesta rodada!")
    elif jogador1_resultado == 6:
        jogador1_vitorias += 1
        print("Jogador 1 ganhou esta rodada!")
    elif jogador2_resultado == 6:
        jogador2_vitorias += 1
        print("Jogador 2 ganhou esta rodada!")
    else:
        print("Nenhum jogador ganhou esta rodada.")
    print()

if jogador1_vitorias > jogador2_vitorias:
    print("Jogador 1 venceu o jogo!")
elif jogador2_vitorias > jogador1_vitorias:
    print("Jogador 2 venceu o jogo!")
else:
    print("Empate no total de rodadas!")

print(f"\nJogador 1 venceu {jogador1_vitorias} rodadas.")
print(f"Jogador 2 venceu {jogador2_vitorias} rodadas.")

Saída do código (exemplo):

Rodada 1: Jogador 1 tirou 4, Jogador 2 tirou 2
Nenhum jogador ganhou esta rodada.

Rodada 2: Jogador 1 tirou 6, Jogador 2 tirou 3
Jogador 1 ganhou esta rodada!

Rodada 3: Jogador 1 tirou 2, Jogador 2 tirou 6
Jogador 2 ganhou esta rodada!

...

Empate no total de rodadas!
Jogador 1 venceu 1 rodadas.
Jogador 2 venceu 1 rodadas.

Com o módulo random, você pode criar simulações, jogos e testes que dependem de comportamento imprevisível. E quando precisar reproduzir um resultado específico, basta definir uma semente com random.seed() — sem necessidade de recorrer ao módulo time, já que o Python gerencia automaticamente a aleatoriedade padrão.

Exercícios#

Antes de começar os exercícios, vamos aprender mais um pouco sobre a leitura dos dados de entrada. Desta vez sobre a função map(), que é usada para aplicar uma função específica a todos os elementos de uma sequência (como listas ou tuplas), retornando um iterador com os resultados. Ela recebe dois argumentos: a função a ser aplicada e a sequência de entrada.

Por exemplo, quando queremos converter a entrada do usuário em números de ponto flutuante, usamos map() juntamente com a função float():

nota1, nota2, nota3 = map(float, input().split())

Neste código, o input() recebe três notas separadas por espaços. O método .split() divide a entrada em uma lista de strings. Em seguida, map(float, ...) aplica a função float() a cada elemento da lista, convertendo as strings em números de ponto flutuante. Finalmente, os valores convertidos são atribuídos às variáveis nota1, nota2 e nota3.

Outro exemplo é quando queremos converter a entrada do usuário em uma lista de números de ponto flutuante. Podemos fazer isso da seguinte maneira:

notas = list(map(float, input().split()))

Neste caso, o input() recebe várias notas separadas por espaços. O método .split() divide a entrada em uma lista de strings. Em seguida, map(float, ...) aplica a função float() a cada elemento da lista, convertendo as strings em números de ponto flutuante. Finalmente, a função list() transforma o objeto map em uma lista de números de ponto flutuante, que é atribuída à variável notas. Agora sim, vamos aos Exercícios.

  1. Classificação Etária: Desenvolva um programa que recebe várias idades de usuários na entrada, todas separadas por espaços. Para cada idade, o programa deve imprimir a categoria correspondente de acordo com a seguinte escala:

Categoria

Faixa Etária

Menor de idade

Menos de 13 anos

Adolescente

De 13 a 17 anos

Maior de idade

De 18 a 59 anos

Idoso

60 anos ou mais

 
# Teste
Entrada: 12 15 20 16 21 60 22 14 23 65
Saída: 
Menor de idade
Adolescente
Maior de idade
Adolescente
Maior de idade
Idoso
Maior de idade
Adolescente
Maior de idade
Idoso

  1. Verificação de Palíndromo: Faça um programa que receba uma lista de palavras e verifique se cada palavra é um palíndromo. Um palíndromo é uma palavra que permanece a mesma quando lida de trás para frente. O programa deve imprimir “Sim” para palíndromos e “Não” para não palíndromos. Utilize end=' ' no comando print para que os resultados sejam exibidos na mesma linha, separados por espaços.

# Teste
Entrada: arara python reviver código osso casa radar programa mussum piloto
Saída: Sim Não Sim Não Sim Não Sim Não Sim Não

  1. Contagem Regressiva: Escreva uma contagem regressiva de 10 a 1, com um intervalo de 1 segundo entre cada número. Para isso, pesquise e utilize o módulo time para pausar a execução do programa por 1 segundo antes de imprimir cada número.

Lembre-se de importar o módulo time e usar a função time.sleep(1) para criar o atraso desejado. Você pode encontrar mais informações sobre o módulo time na documentação oficial do Python.

# Teste
Entrada: Sem entrada
Saída: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

  1. Análise de Desempenho de uma Turma com até 100 Alunos: Analise o desempenho de uma turma com até 100 alunos em uma disciplina de linguagem de programação. Seu programa deve receber como entrada uma lista de até 100 números entre 0 e 10, representando as notas finais de cada aluno.

Para cada nota na lista, o programa deve:

  • Adicionar a nota à uma soma total (para posterior cálculo da média da turma).

  • Verificar se a nota é maior ou igual a 5. Se for, incrementar o contador de alunos aprovados.

  • Se a nota for menor que 5, incrementar o contador de alunos reprovados.

Após processar todas as notas, o programa deve calcular e imprimir as seguintes informações: Número de Alunos Aprovados, Número de Alunos Reprovados e Média da Turma.

Obs: Considere utilizar essa sintaxe para o armazenamento das notas em uma lista: list(map(float, input().split(',')))

# Teste 1
Entrada: 1.3, 2.8, 8.1, 5.6, 8.1, 6.9, 9.7, 0.7, 0.7, 1.1, 10.0, 1.7, 8.5, 3.3, 2.4, 6.9, 2.5, 0.3, 8.8, 3.1, 8.1, 9.2, 1.4, 4.6, 4.6, 0.6, 10.0, 1.4, 4.3, 7.9, 3.9, 2.4, 5.4, 5.6, 4.4, 3.5, 0.5, 7.4, 2.7, 2.1, 3.5, 6.3, 3.6, 0.0, 7.7, 0.8, 7.7, 9.7, 1.6, 0.3, 6.5, 4.2, 1.2, 4.3, 4.5, 8.9, 5.8, 7.5, 9.7, 8.2, 1.5, 9.2, 6.1, 9.7, 6.7, 0.5, 7.1, 3.4, 7.8, 8.1, 4.5, 4.1, 5.8, 3.4, 0.3, 10.0, 7.7, 0.2, 9.9, 2.3, 7.8, 5.6, 3.6, 1.3, 9.5, 1.2, 6.4, 3.2, 9.1, 8.6, 6.2, 7.9, 4.9, 7.3, 1.2, 5.1, 9.2, 7.6, 0.3, 7.4
Saída:
Número de Alunos Aprovados: 50
Número de Alunos Reprovados: 50
Média da Turma: 5.06

# Teste 2
Entrada: 7.0, 8.5, 9.0, 4.5, 6.0, 3.0, 2.5, 8.0, 9.5, 5.0
Saída:
Número de Alunos Aprovados: 7
Número de Alunos Reprovados: 3
Média da Turma: 6.30

# Teste 3
Entrada: 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0
Saída:
Número de Alunos Aprovados: 10
Número de Alunos Reprovados: 0
Média da Turma: 10.00

# Teste 4
Entrada: 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
Saída:
Número de Alunos Aprovados: 0
Número de Alunos Reprovados: 10
Média da Turma: 0.00

  1. Cálculo do Fatorial: Escreva um programa que receba uma lista de números inteiros, e obedecendo alguns critérios, calcule e imprima o fatorial de cada um deles. O fatorial de um número é o produto de todos os números inteiros de 1 até o próprio número.

Aqui estão as etapas e critérios para implementar seu programa:

  • Receba e armazene uma lista de números inteiros.

  • Verifique se cada número é válido (ou seja, maior ou igual a zero e menor do que 15).

  • Calcule o fatorial de cada número usando um loop for ou while.

  • Exiba o resultado do fatorial para cada um dos números. Se não for possível calcular o fatorial (por exemplo, para números não válidos), escreva um X.

  • Mostre a quantidade de números para os quais não foi possível calcular o fatorial.

# Teste 1
Entrada: 7, 6, -1, 14, 1, 12, 0, 18, 15, 12, 5, 9, 10, 0, 12, 17, 2, 15, 12, 2, 16, 19, 5, 4, 10
Saída: 5040, 720, X, 87178291200, 1, 479001600, 1, X, X, 479001600, 120, 362880, 3628800, 1, 479001600, X, 2, X, 479001600, 2, X, X, 120, 24, 3628800
Quantidade de números inválidos: 7

# Teste 2
Entrada: 3, 9, 12, 15, 12, 0, 8, 15, 12, 5, 9, 10, 0, 12, 17, 2, 15, 12, 2, 16, 19, 5, 4, 10, 3, 13
Saída: 6 362880 479001600 X 479001600 1 40320 X 479001600 120 362880 3628800 1 479001600 X 2 X 479001600 2 X X 120 24 3628800 X 6227020800 
Quantidade de números inválidos: 6

Lembre-se de tratar casos especiais. Zero possui fatorial 1 e um número negativo não possui fatorial.

6. Jogo da Adivinhação (Jogador vs Computador): O objetivo é desenvolver um jogo interativo de adivinhação de números no qual o jogador compete contra o computador. O jogo deve seguir as seguintes regras:

  • No início do jogo, o programa deve gerar um número aleatório secreto entre 1 e 100. Este será o número que o jogador e o computador tentarão adivinhar.

  • Tanto o jogador quanto o computador têm um número limitado de tentativas para adivinhar o número. Por exemplo, pode-se limitar a 20 tentativas.

  • Em cada rodada, o jogador e o computador fazem um palpite. O programa deve então fornecer uma dica para ambos, indicando se o número secreto é maior ou menor que os palpites.

  • Se o jogador ou o computador adivinhar o número corretamente, o programa deve parabenizá-lo e informar o número de tentativas que foram necessárias para adivinhar o número. Se ambos adivinharem o número na mesma rodada, o jogo termina em empate.

  • Se o jogador e o computador esgotarem todas as suas tentativas sem adivinhar o número, o programa deve informar que o jogo terminou e revelar o número secreto.

7. Exercício de Padrão de Asteriscos: Escreva um programa em Python que imprima um triângulo de asteriscos. O programa deve receber na entrada o número de linhas do triângulo e o tipo de triângulo a ser impresso (tipo1 ou tipo2). Em seguida, o programa deve imprimir o triângulo de asteriscos com o número de linhas especificado e no formato escolhido.

  • Tipo 1: Cada linha começa com um asterisco e aumenta o número de asteriscos à medida que descemos.

  • Tipo 2: O número máximo de asteriscos aparece na primeira linha e à medida que avançamos para a direita, este número vai diminuindo.

# Teste 1
Entrada: tipo1, 3
Saída:
*
**
***

# Teste 2
Entrada: tipo1, 5
Saída:
*
**
***
****
*****

# Teste 3
Entrada: tipo2, 4
Saída:
****
***
**
*

8. Identificação de Números Primos em uma Lista: Desenvolva um programa que identifique todos os números primos presentes em uma lista fornecida na entrada. Um número primo é um número maior que 1 que não possui divisores positivos além de 1 e si próprio. Siga as Instruções a seguir:

  • Leia uma lista de números inteiros.

  • Para cada número na lista, verifique se ele é um número primo.

  • Se o número for primo, adicione-o a uma nova lista.

  • Após verificar todos os números na lista original, exiba a nova lista contendo apenas os números primos.

# Teste 1
Entrada: -23, 15, -7, 49, -35, 21, -2, 30, -14, 8, -50, 44, -29, 17, -3, 34, -9, 25, -40, 12, 5, -28, 37, -16, 10, -4, 42, -33, 18, -6, 27, -13, 39, -22, 11, -1, 31, -19, 20, -36, 14, -8, 26, -45, 9, -24, 32, -10, 23, -5
Saída: 17, 5, 37, 11, 31, 23

# Teste 2
Entrada: -18, 33, -12, 27, -6, 42, -30, 21, -3, 39, -24, 15, -9, 36, -15, 12, -1, 45, -27, 18, -7, 30, -21, 9, -33, 24, -13, 6, -42, 36, -19, 3, -39, 30, -10, 0, 48, -25, 16, -4, 41, -28, 22, -5, 38
Saída: 3, 41

9. Loteria de 5 números: Desenvolva um programa que simule uma loteria onde são sorteados 5 números distintos entre 1 e 50. O programa deve gerar aleatoriamente jogos de 5 números até que um jogo corresponda exatamente à combinação sorteada. O objetivo é determinar quantos jogos são necessários até que haja um ganhador. Siga as instruções a seguir:

  • Receba na entrada um inteiro correspondente à semente para geração pseudoaleatória de números.

  • Gere uma combinação vencedora de 5 números únicos entre 1 e 50 usando random.sample.

  • Converta a combinação vencedora em um conjunto (set) para facilitar a comparação.

  • Crie um loop que simule jogos de 5 números únicos entre 1 e 50, também usando random.sample.

  • Após cada jogo, converta a combinação de números gerada em um conjunto (set) e verifique se ela corresponde à combinação vencedora.

  • Conte o número de jogos realizados até que um jogo corresponda exatamente à combinação vencedora.

  • Exiba o número total de jogos necessários para encontrar um ganhador.

# Teste 1
Entrada: 1
Saída: Número de jogos necessários: 24836

# Teste 2
Entrada: 2
Saída: Número de jogos necessários: 622164

# Teste 3
Entrada: 11
Saída: Número de jogos necessários: 807045

10. O “Velho” Fibonacci: A sequência de Fibonacci é uma série infinita de números inteiros em que cada número é a soma dos dois anteriores. Ela começa com os números 1 e 1:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, …

Para calcular o próximo número na sequência, somamos os dois números anteriores. Por exemplo:

  • O terceiro número é 1 + 1 = 2.

  • O quarto número é 1 + 2 = 3.

  • O quinto número é 2 + 3 = 5.

E assim por diante.

Veja a imagem ilustrativa a seguir:

fib

Agora, vamos criar um programa que gere a sequência de Fibonacci até o n-ésimo termo. O usuário fornecerá o valor de n.

  • Inicializamos as variáveis ultimo e penultimo com os valores 1, pois os dois primeiros termos da sequência são 1.

  • Usamos um laço de repetição (como um for ou while) para calcular os próximos termos. Salvando os valores em uma lista.

  • A cada iteração, somamos ultimo e penultimo para obter o próximo termo.

  • Atualizamos as variáveis ultimo e penultimo para os valores corretos.

  • Repetimos o processo até chegarmos ao n-ésimo termo.

  • Por fim, todos os números da sequência, armazenados em uma lista, devem ser impressos.

# Teste 1
Entrada: 10
Saída: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55

# Teste 2
Entrada: 19
Saída: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181

# Teste 3
Entrada: 23
Saída: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657

11. Gerador de Senhas Aleatórias

Você foi contratado para desenvolver um sistema simples que gere senhas seguras para usuários. Cada senha deve conter letras maiúsculas, letras minúsculas e números. Para facilitar a criação de várias senhas, o sistema deve gerar um conjunto de senhas automaticamente.

Importante: a semente deve ser definida com random.seed(42) antes de qualquer chamada a funções como random.choices() ou random.shuffle(). Isso garante que todos os alunos gerem exatamente as mesmas senhas.

Requisitos:

  • Cada senha deve conter:

    • 3 letras maiúsculas

    • 3 letras minúsculas

    • 3 dígitos

  • A senha deve ter 9 caracteres no total, dispostos em ordem aleatória.

  • Utilize um laço de repetição para gerar a quantidade (qtd) de senhas desejada.

  • Use o módulo random e defina a semente com random.seed(42) antes de gerar qualquer senha.

Dicas:

  • import string pode ser útil

  • Use string.ascii_uppercase, string.ascii_lowercase e string.digits para acessar letras e números.

  • Use random.choices(..., k=3) para sortear 3 caracteres de uma lista.

  • Por fim, use random.shuffle(lista) para embaralhar a ordem dos caracteres da senha.

# Teste 1
Entrada: 3
Saída: rfH4t80AQ wl74S1SKh Gl0I9J2bd

# Teste 2
Entrada: 5
Saída: rfH4t80AQ wl74S1SKh Gl0I9J2bd W6l37evJW ft8R8YHi0

# Teste 3
Entrada: 8
Saída: rfH4t80AQ wl74S1SKh Gl0I9J2bd W6l37evJW ft8R8YHi0 5LKgg8Xo2 pDrE45kW2 19gC5LLyw

12. Batalha de Números Primos

Dois jogadores entraram em uma batalha matemática! Cada um receberá 15 números aleatórios entre 1 e 1000. O objetivo é simples: quem tiver mais números primos vence a partida.

Para garantir que os testes possam ser reproduzidos de forma idêntica, o programa deve receber duas sementes de números aleatórios — uma para cada jogador.

Requisitos

  • Receba dois números inteiros como entrada: eles serão usados como sementes (random.seed()) — uma para cada jogador.

  • Após definir a semente, sorteie 15 números entre 1 e 1000 para cada jogador.

  • Verifique quais desses números são primos.

  • Mostre:

    • Os 15 números sorteados para cada jogador

    • Quantos números primos cada jogador recebeu

  • Declare o vencedor com base em quem teve mais primos. Em caso de empate, informe: “Empate!”

# Teste 1
Entrada: 123 456
Saída:
JOGADOR 1
[54, 275, 90, 788, 418, 273, 111, 859, 923, 896, 40, 389, 550, 576, 341]
Número de Primos: 2

JOGADOR 2
[767, 461, 990, 478, 446, 400, 814, 911, 664, 42, 633, 749, 843, 921, 809]
Número de Primos: 3

Vencedor: Jogador 2

# Teste 2
Entrada: 111 222
Saída esperada:
JOGADOR 1
[848, 972, 218, 944, 966, 324, 506, 199, 408, 427, 632, 832, 174, 645, 199]
Número de Primos: 2

JOGADOR 2
[798, 111, 241, 291, 314, 33, 30, 494, 229, 456, 758, 738, 452, 464, 77]
Número de Primos: 2

Vencedor: Empate

# Teste 3
Entrada: 42 99
Saída:
JOGADOR 1
[655, 115, 26, 760, 282, 251, 229, 143, 755, 105, 693, 759, 914, 559, 90]
Número de Primos: 2

JOGADOR 2
[414, 390, 205, 614, 184, 236, 255, 137, 779, 89, 258, 747, 393, 544, 701]
Número de Primos: 3

Vencedor: Jogador 2