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:

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:

2 3 
5 6 
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:

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:

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()` e `break`#

Python oferece várias formas de controlar o fluxo de execução em seu código. Duas dessas possibilidades são exit() e break, utilizadas para interromper a execução do programa ou de loops.

A função exit() é usada para encerrar a execução do programa completamente. Se chamada dentro de um loop, exit() interrompe o loop e encerra o programa, e nenhum código subsequente é 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 do Código:

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, incluindo a linha após o loop for.

Exemplo de uso do `exit()` em um loop `while`#

contador = 1
while True:
    print(f"Contagem: {contador}")
    if contador == 10:
        print("Contagem chegou a 10. Saindo do programa.")
        exit()
    contador += 1

Neste exemplo, o loop while repete indefinidamente até que contador chegue a 10. Nesse ponto, exit() é chamado, encerrando o programa.

`break` para Sair do Loop Atual#

A função break, por outro lado, é usada para interromper apenas o loop atual, permitindo que o restante do código seja 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 do Código:

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.

Neste caso, o break interrompe apenas o loop for, e o programa continua executando o código subsequente, incluindo a linha print("Estou fora do 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 exemplo, o loop while repete indefinidamente até que a opção “sair” seja escolhida, momento em que break é chamado para encerrar o loop, permitindo a continuidade do programa.

Resumo das Diferenças#

exit(): Interrompe todo o programa, parando a execução imediatamente, mesmo que chamado dentro de um loop.
break: Encerra apenas o loop atual, permitindo que o código fora do loop continue a ser executado.

Esses exemplos mostram como exit() e break podem ser aplicados para controlar o fluxo de execução de maneira efetiva e precisa, de acordo com a necessidade.

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 uma variedade de distribuições estatísticas.

Para comparação, números verdadeiramente aleatórios podem ser gerados a partir de fenômenos físicos, como os disponíveis no site random.org, que utiliza ruído atmosférico para isso.

Módulos em Python#

Módulos em Python são arquivos contendo definições e instruções Python que podem ser reutilizados em outros programas. Para utilizá-los, você precisa importá-los no seu código. Isso é feito usando a instrução import, seguida pelo nome do módulo.

Por exemplo, para importar o módulo random, que é responsável pela geração de números aleatórios, você pode usar:

import random

Depois de importar o módulo, você pode acessar suas funções e classes usando a notação de ponto, como random.random(), random.randint() e random.sample().

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 você pode gerar números aleatórios utilizando 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 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 antes de gerar números aleatórios pode ser útil quando você precisa reproduzir resultados específicos em diferentes execuções do seu programa. Ao definir uma semente, a sequência de números gerada será sempre a mesma, garantindo a reprodução dos resultados.

Aqui está um exemplo com a geração de números aleatórios após a inicialização de uma semente fixa:

import random

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

# Agora, a sequência de números aleatórios será sempre a mesma
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

Inicialização da Semente com o Tempo Atual#

Para garantir que a sequência de números aleatórios seja diferente a cada execução, você pode inicializar a semente usando o tempo atual, utilizando o módulo time:

import random
import time

# Define a semente com o tempo atual
random.seed(time.time())

# Exemplo de geração de números aleatórios
for i in range(3):
    print(f"Número aleatório {i+1}: {random.randint(1, 100)}")

A função time.time() retorna o tempo atual em segundos (com frações) desde 1º de janeiro de 1970. Como esse valor muda constantemente, ele permite gerar sementes diferentes a cada execução, garantindo variedade na sequência de números aleatórios.

Saída do Código (exemplo):

Número aleatório 1: 43
Número aleatório 2: 77
Número aleatório 3: 23

Exemplo de Jogo com Dados#

Vamos criar um exemplo simples de um jogo onde dois jogadores jogam um dado, e o primeiro a obter um 6 ganha o jogo.

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!")
    print(f"Jogador 1 venceu {jogador1_vitorias} rodadas.")
    print(f"Jogador 2 venceu {jogador2_vitorias} rodadas.")
elif jogador2_vitorias > jogador1_vitorias:
    print("Jogador 2 venceu!")
    print(f"Jogador 1 venceu {jogador1_vitorias} rodadas.")
    print(f"Jogador 2 venceu {jogador2_vitorias} rodadas.")
else:
    print("Empate no total de rodadas!")
    print(f"Jogador 1 venceu {jogador1_vitorias} rodadas.")
    print(f"Jogador 2 venceu {jogador2_vitorias} rodadas.")

Exemplo de Saída do Código:

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!

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

...

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

Neste exemplo, dois jogadores lançam um dado, e o primeiro a tirar um 6 ganha a rodada. O programa simula 10 rodadas e conta quantas cada jogador ganhou. Defina uma semente caso queira garantir que os resultados sejam reproduzíveis.

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.

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

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

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

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

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:

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

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

Contents

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

Estruturas de Decisão Aninhadas#

Estrutura de Repetição for#

A Função range()#

O Operador in#

O Loop for#

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

Iterando Sobre uma String#

Iterando Sobre uma Lista de Números#

Executando um Número Específico de Vezes#

Iterando Sobre um Dicionário#

Entendendo o for Aninhado#

Outro Exemplo de for Aninhado#

Estrutura de Repetição while#

Usando o while not#

For dentro de um while#

Compreensões de Listas (List Comprehensions)#

Sintaxe Básica#

Exemplo: Elevando Números ao Quadrado#

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

Compreensão de Lista vs. Estrutura Convencional#

Controle de Fluxo com exit() e break#

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

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

break para Sair do Loop Atual#

Exemplo de uso do break em um loop for#

Exemplo de uso do break em um loop while#

Resumo das Diferenças#

Números Aleatórios#

Módulos em Python#

Métodos Comuns do Módulo random#

Exemplos de Uso#

Definindo uma Semente#

Inicialização da Semente com o Tempo Atual#

Exemplo de Jogo com Dados#

Exercícios#

Estrutura de Repetição `for`#

A Função `range()`#

O Operador `in`#

O Loop `for`#

Entendendo o `for` Aninhado#

Outro Exemplo de `for` Aninhado#

Estrutura de Repetição `while`#

Controle de Fluxo com `exit()` e `break`#

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

Exemplo de uso do `exit()` em um loop `while`#

`break` para Sair do Loop Atual#

Exemplo de uso do `break` em um loop `for`#

Exemplo de uso do `break` em um loop `while`#

Métodos Comuns do Módulo `random`#