Curso básico de programação com Python para iniciantes - D[6] - Hoje às 18 horas - Iteração
comentada em 19/11/2021 09:28

Tou inspirado fazendo os exercícios de hoje rs espero que gostem. 

Exercícios: 

1. Crie uma lista de chamada de uma sala de aula de uma escola, com nomes de 5 alunos. Itere sobre essa lista e printe o nome de cada aluno na tela. Simule o comportamento de uma sala de aula. A cada aluno, o programa irá esperar duas possíveis entradas: “presente” ou “faltou”. Se o aluno estiver presente, printe na tela o nome do aluno e ao lado a marcação que ele está presente. Se não, printe o nome do aluno e ao lado a palavra “faltou”. Brinque com esse comportamento.

2. Melhore o programa acima. Agora se a entrada de presença for diferente de “presente” ou “faltou”, faça o programa perguntar a resposta certa até o usuário digitar uma resposta entre “presente” ou “faltou”. Enquanto isso não acontecer, imprima na tela uma mensagem de erro e peça novamente a entrada correta.

3. O programa acima tem uma saída de dados bem brusca. Torne essa saída mais palatável para quem lê. Adicione um timer a cada output do programa.

-----

4. (Clássico): Crie um jogo de pedra, papel e tesoura onde você jogará contra o computador. Mostre as mensagens padrão dependendo do vencedor ou do empate. Iniba as possibilidades de erro do programa usando os conhecimentos desta aula. Tente escrever o código do jogo inteiro dentro de funções. Ao final, faça uma função que irá chamar as outras e chame esta função para rodar o jogo.

5. Melhore o jogo acima. Pergunte ao final de cada jogada se o jogador quer continuar jogando. Se sim, rode o jogo novamente até o jogador desistir de jogar. Se não, finalize o jogo. 

6. Melhore ainda mais o jogo acima. Adicione um placar ao jogo. Mostre o resultado global ao final de cada jogada. 

Thiago como faz pra assistir? quem perdeu no horário proposto pode assistir posteriormente inclusive a primeira aula? Se sim como faz? obrigado amigo

@gabiryan só ir lá na galeria da área e filtrar pelos vídeos. Tá tudo gravado lá:

Tecnologia - Bastter.com

Quando tá rolando ao vivo só clicar neste banner



Aqui tem toda a série, falta só o de hoje mas que já tá na galeria da área de tecnologia: Bastter Blue > Videos > Cursos e Séries > Tecnologia: Curso básico de programação com Python

Ufa, deu trabalho mas aí está. Até que foi divertido fazer esses exercícios.

# Ex 1

chamada = ['Ana', 'Bruno', 'Gustavo', 'Laura', 'Pedro']

for aluno in chamada:
    print(aluno + '!')
    situacao = input(f'Digite "presente" se {aluno} estiver presente ou "faltou" se {aluno} estiver faltado: ')
    if situacao == 'presente':
        print(aluno + ' - presente!')
    elif situacao == 'faltou':
        print(aluno + ' - faltou!')


############################################################################

# Ex 2

chamada = ['Ana', 'Bruno', 'Gustavo', 'Laura', 'Pedro']

respostas_certas = ['presente', 'faltou']

for aluno in chamada:
    print(aluno + '!')
    input_usu = input(f'Digite "presente" se {aluno} estiver presente ou "faltou" se {aluno} estiver faltado: ')
    while input_usu not in respostas_certas:
        print('Erro: você deve digitar apenas "presente" ou "faltou" (sem as aspas).')
        input_usu = input(f'Digite "presente" se {aluno} estiver presente ou "faltou" se {aluno} estiver faltado: ')
    if input_usu == 'presente':
        print(aluno + ' - presente!')
    elif input_usu == 'faltou':
        print(aluno + ' - faltou!')


############################################################################

# Ex 3

from time import sleep

chamada = ['Ana', 'Bruno', 'Gustavo', 'Laura', 'Pedro']

respostas_certas = ['presente', 'faltou']

for aluno in chamada:
    sleep(2)
    print(aluno + '!')
    sleep(2)
    input_usu = input(f'Digite "presente" se {aluno} estiver presente ou "faltou" se {aluno} estiver faltado: ')
    sleep(2)
    while input_usu not in respostas_certas:
        print('Erro: você deve digitar apenas "presente" ou "faltou" (sem as aspas).')
        sleep(2)
        input_usu = input(f'Digite "presente" se {aluno} estiver presente ou "faltou" se {aluno} estiver faltado: ')
        sleep(2)
    if input_usu == 'presente':
        print(aluno + ' - presente!')
    elif input_usu == 'faltou':
        print(aluno + ' - faltou!')


###########################################################################

# Ex 4

# funcao para coletar input do usuario

def input_usuario():
    from time import sleep
    print('Bem vindo ao jogo "pedra, papel e tesoura"!')
    sleep(1)
    print('Escolha um número que representa a sua jogada:')
    sleep(1)
    print('[ 1 ] - Pedra')
    print('[ 2 ] - Papel')
    print('[ 3 ] - Tesoura')
    lista_jogadas = ['1', '2', '3']
    sleep(1)
    escolha_usuario = input('Digite o número escolhido (entre 1 e 3): ')
    while escolha_usuario not in lista_jogadas:
        sleep(1)
        print('Erro: você deve digitar apenas um número inteiro entre 1 e 3.')
        sleep(1)
        escolha_usuario = input('Digite o número escolhido (entre 1 e 3): ')
    escolha_usuario = int(escolha_usuario)
    sleep(1)
    if escolha_usuario == 1:
        print('Você escolheu pedra!')
    elif escolha_usuario == 2:
        print('Você escolheu papel!')
    elif escolha_usuario == 3:
        print('Você escolheu tesoura!')
    return escolha_usuario




# Funcao para o computador escolher uma jogada

def input_PC():
    from random import randint
    escolha_PC = randint(1, 3)
    from time import sleep
    sleep(1)
    if escolha_PC == 1:
        print('O computador escolheu pedra!')
    elif escolha_PC == 2:
        print('O computador escolheu papel!')
    elif escolha_PC == 3:
        print('O computador escolheu tesoura!')
    return escolha_PC




# Funcao para definir o vencedor

def definir_vencedor(escolha_usuario, escolha_PC):
    from time import sleep
    sleep(1)
    if escolha_usuario == escolha_PC:
        print('O resultado é um empate!')
    elif escolha_usuario == 1 and escolha_PC == 2:
        print('Papel vence pedra!')
        sleep(1)
        print('O vencedor é o computador!')
    elif escolha_usuario == 1 and escolha_PC == 3:
        print('Pedra vence tesoura!')
        sleep(1)
        print('O vencedor é você!')
    elif escolha_usuario == 2 and escolha_PC == 1:
        print('Papel vence pedra!')
        sleep(1)
        print('O vencedor é você!')
    elif escolha_usuario == 2 and escolha_PC == 3:
        print('Tesoura vence papel!')
        sleep(1)
        print('O vencedor é o computador!')
    elif escolha_usuario == 3 and escolha_PC == 1:
        print('Pedra vence tesoura!')
        sleep(1)
        print('O vencedor é o computador!')
    elif escolha_usuario == 3 and escolha_PC == 2:
        print('Tesoura vence papel!')
        sleep(1)
        print('O vencedor é você!')


# Funcao para chamar as outras funcoes

def iniciar_jogo():
    definir_vencedor(input_usuario(), input_PC())


# Chamando a funcao para rodar o jogo:

iniciar_jogo()


############################################################################

# Ex 5

# funcao para coletar input do usuario

def input_usuario():
    from time import sleep
    print('Bem vindo ao jogo "pedra, papel e tesoura"!')
    sleep(1)
    print('Escolha um número que representa a sua jogada:')
    sleep(1)
    print('[ 1 ] - Pedra')
    print('[ 2 ] - Papel')
    print('[ 3 ] - Tesoura')
    lista_jogadas = ['1', '2', '3']
    sleep(1)
    escolha_usuario = input('Digite o número escolhido (entre 1 e 3): ')
    while escolha_usuario not in lista_jogadas:
        sleep(1)
        print('Erro: você deve digitar apenas um número inteiro entre 1 e 3.')
        sleep(1)
        escolha_usuario = input('Digite o número escolhido (entre 1 e 3): ')
    escolha_usuario = int(escolha_usuario)
    sleep(1)
    if escolha_usuario == 1:
        print('Você escolheu pedra!')
    elif escolha_usuario == 2:
        print('Você escolheu papel!')
    elif escolha_usuario == 3:
        print('Você escolheu tesoura!')
    return escolha_usuario




# Funcao para o computador escolher uma jogada

def input_PC():
    from random import randint
    escolha_PC = randint(1, 3)
    from time import sleep
    sleep(1)
    if escolha_PC == 1:
        print('O computador escolheu pedra!')
    elif escolha_PC == 2:
        print('O computador escolheu papel!')
    elif escolha_PC == 3:
        print('O computador escolheu tesoura!')
    return escolha_PC




# Funcao para definir o vencedor

def definir_vencedor(escolha_usuario, escolha_PC):
    from time import sleep
    sleep(1)
    if escolha_usuario == escolha_PC:
        print('O resultado é um empate!')
    elif escolha_usuario == 1 and escolha_PC == 2:
        print('Papel vence pedra!')
        sleep(1)
        print('O vencedor é o computador!')
    elif escolha_usuario == 1 and escolha_PC == 3:
        print('Pedra vence tesoura!')
        sleep(1)
        print('O vencedor é você!')
    elif escolha_usuario == 2 and escolha_PC == 1:
        print('Papel vence pedra!')
        sleep(1)
        print('O vencedor é você!')
    elif escolha_usuario == 2 and escolha_PC == 3:
        print('Tesoura vence papel!')
        sleep(1)
        print('O vencedor é o computador!')
    elif escolha_usuario == 3 and escolha_PC == 1:
        print('Pedra vence tesoura!')
        sleep(1)
        print('O vencedor é o computador!')
    elif escolha_usuario == 3 and escolha_PC == 2:
        print('Tesoura vence papel!')
        sleep(1)
        print('O vencedor é você!')


# Funcao para chamar as outras funcoes

def iniciar_jogo():
    continuar = 's'
    while continuar != 'n':
        definir_vencedor(input_usuario(), input_PC())
        from time import sleep
        sleep(1)
        print('Obrigado por jogar. Gostaria de jogar mais uma partida?')
        sleep(1)
        continuar = input('Digite "s" se sim ou "n" se não: ')
        resposta_adeq = ['s', 'n']
        while continuar not in resposta_adeq:
            sleep(1)
            continuar = input('Erro! Você deve digitar apenas "s" ou "n" (sem as aspas): ')    



# Chamando a funcao para rodar o jogo:

iniciar_jogo()


############################################################################

# Ex 6

# Placar global

usuario = 0
computador = 0


# funcao para coletar input do usuario

def input_usuario():
    from time import sleep
    print('Bem vindo ao jogo "pedra, papel e tesoura"!')
    sleep(1)
    print('Escolha um número que representa a sua jogada:')
    sleep(1)
    print('[ 1 ] - Pedra')
    print('[ 2 ] - Papel')
    print('[ 3 ] - Tesoura')
    lista_jogadas = ['1', '2', '3']
    sleep(1)
    escolha_usuario = input('Digite o número escolhido (entre 1 e 3): ')
    while escolha_usuario not in lista_jogadas:
        sleep(1)
        print('Erro: você deve digitar apenas um número inteiro entre 1 e 3.')
        sleep(1)
        escolha_usuario = input('Digite o número escolhido (entre 1 e 3): ')
    escolha_usuario = int(escolha_usuario)
    sleep(1)
    if escolha_usuario == 1:
        print('Você escolheu pedra!')
    elif escolha_usuario == 2:
        print('Você escolheu papel!')
    elif escolha_usuario == 3:
        print('Você escolheu tesoura!')
    return escolha_usuario




# Funcao para o computador escolher uma jogada

def input_PC():
    from random import randint
    escolha_PC = randint(1, 3)
    from time import sleep
    sleep(1)
    if escolha_PC == 1:
        print('O computador escolheu pedra!')
    elif escolha_PC == 2:
        print('O computador escolheu papel!')
    elif escolha_PC == 3:
        print('O computador escolheu tesoura!')
    return escolha_PC




# Procedural daqui pra frente

from time import sleep

continuar = 's'

while continuar != 'n':
    escolha_usuario = input_usuario()
    escolha_PC = input_PC()
    sleep(1)
    if escolha_usuario == escolha_PC:
        print('O resultado é um empate!')
    elif escolha_usuario == 1 and escolha_PC == 2:
        print('Papel vence pedra!')
        sleep(1)
        print('O vencedor é o computador!')
        computador += 1
    elif escolha_usuario == 1 and escolha_PC == 3:
        print('Pedra vence tesoura!')
        sleep(1)
        print('O vencedor é você!')
        usuario += 1
    elif escolha_usuario == 2 and escolha_PC == 1:
        print('Papel vence pedra!')
        sleep(1)
        print('O vencedor é você!')
        usuario += 1
    elif escolha_usuario == 2 and escolha_PC == 3:
        print('Tesoura vence papel!')
        sleep(1)
        print('O vencedor é o computador!')
        computador += 1
    elif escolha_usuario == 3 and escolha_PC == 1:
        print('Pedra vence tesoura!')
        sleep(1)
        print('O vencedor é o computador!')
        computador += 1
    elif escolha_usuario == 3 and escolha_PC == 2:
        print('Tesoura vence papel!')
        sleep(1)
        print('O vencedor é você!')
        usuario += 1
    sleep(1)
    placar = f'Placar: Você {usuario} X {computador} Computador'
    print(placar)
    sleep(1)
    print('Obrigado por jogar. Gostaria de jogar mais uma partida?')
    sleep(1)
    continuar = input('Digite "s" se sim ou "n" se não: ')
    resposta_adeq = ['s', 'n']
    while continuar not in resposta_adeq:
        sleep(1)
        continuar = input('Erro! Você deve digitar apenas "s" ou "n" (sem as aspas): ')

@Wag_B massa. Parabéns aí por ter tentado e conseguido. Na quarta-feira a gente discute pontos de melhoria e vou lançar um formato de visualização das soluções que vai ficar mais interessante pra quem tá acompanhando o curso. 

No primeiro, eu (também estava inspirado) e quis colocar um resumo da chamada no final. Aí, criei uma lista pra armazenar a condição do aluno. Aí só conseguir fazer por duas opções: (acabei utilizando a primeira no exercício)
1-Criei uma lista 'vazia' e usei o .append para criar uma posição e armazenar o valor ou
2- Criei uma lista fictícia tipo condicao_alunos= [0,0,0,0,0] e consigo armazenar no for usando um contador (tipo variavel[i] e coloco i=i+1)

Dei uma pesquisada, mas não achei nada muito claro. Há alguma forma de eu criar uma lista com, por exemplo, 1000 espaços vazios para poder usar o contador. A primeira opção acima funcionou bem, mas achei meio limitada, mas talvez eu esteja antecipando algo desnecessário. Já a segunda só funciona pq é uma lista pequena. Fui claro?

No segundo, a dificuldade foi quando as letras maiúsculas como Presente ou Faltou. Resolvi isso colocando na lista de possibilidades Presente/presente e Faltou/faltou ou coloquei um .lower no if de reconhecimento.

 

No 6, eu criei duas variáveis para servirem como contador para os pontos. Aí dava um erro de UnboundLocalError.
A solução que eu achei foi colocar "global variável" dentro da função pra rodar.

#1

lista_de_alunos = ['Antônio', 'Caio', 'Cláudio', 'Mateus', 'Vitor']

#Tive que incluir para fazer a armazenagem do resumo
posicao=0
condicao_alunos=list()

print(f'Lista de chamada. Digite presente ou faltou para cada aluno.')
for aluno in lista_de_alunos:
    print(f'{aluno}!')
    condicao_alunos.append(input(""))
    print(f'{aluno} - {condicao_alunos[posicao]}!')
    posicao=posicao+1

for para imprimir o resumo
posicao=0
print(f'
Resumo:')
for aluno in lista_de_alunos:
    print(f'{aluno} - {condicao_alunos[posicao]}')
    posicao=posicao+1

-----------------------------------------------------------
#2

lista_de_alunos = ['Antônio', 'Caio', 'Cláudio', 'Mateus', 'Vitor']
lista_de_possibilidades = [ 'presente', 'faltou']
#Tive que incluir para fazer a armazenagem do resumo
posicao=0
condicao_alunos=list()

print(f'Lista de chamada. Digite presente ou faltou para cada aluno.')
for aluno in lista_de_alunos:
    print(f'{aluno}!')
    condicao_alunos.append(input(""))
    while True:
        if condicao_alunos[posicao].lower() in lista_de_possibilidades:
            break
        else:
            print(f'Você tem que escrever Presente ou Faltou para o aluno {aluno}! Tente novamente')
            condicao_alunos[posicao]=input("")
    print(f'{aluno} - {condicao_alunos[posicao]}!')
    posicao=posicao+1

for para imprimir o resumo
posicao=0
print(f'
Resumo:')
for aluno in lista_de_alunos:
    print(f'{aluno} - {condicao_alunos[posicao]}')
    posicao=posicao+1

-------------------------------------------------
#3
import time 

lista_de_alunos = ['Antônio', 'Caio', 'Cláudio', 'Mateus', 'Vitor']
lista_de_possibilidades = [ 'presente', 'faltou']
#Tive que incluir para fazer a armazenagem do resumo
posicao=0
condicao_alunos=list()

print(f'Lista de chamada. Digite presente ou faltou para cada aluno.')
for aluno in lista_de_alunos:
    time.sleep(1)
    print(f'{aluno}!')
    condicao_alunos.append(input(""))
    while True:
        if condicao_alunos[posicao].lower() in lista_de_possibilidades:
            break
        else:
            time.sleep(1)
            print(f'Você tem que escrever Presente ou Faltou para o aluno {aluno}! Tente novamente')
            time.sleep(1)
            condicao_alunos[posicao]=input("")
    time.sleep(1.5)
    print(f'{aluno} - {condicao_alunos[posicao]}!')
    posicao=posicao+1

for para imprimir o resumo
posicao=0
print(f'
Conferência:')
for aluno in lista_de_alunos:
    time.sleep(1.2)
    print(f'{aluno} - {condicao_alunos[posicao]}')
    posicao=posicao+1

----------------------------------------------------------
#4
from random import randint
import time
lista_de_possibilidades=['1','2','3']

função para receber escolha do jogador e verificar se é válida
def escolha_do_jogador():
    print(f'Escolha sua jogada:
[1] - Pedra
[2] - Papel
[3] - Tesoura')
    jogada_humano=input('Opção:')
    while True:
        if jogada_humano in lista_de_possibilidades:
            break
        else:
            time.sleep(1)
            print(f'
Sua escolha não corresponde a nenhuma opção. Escolha novamente')
            print(f'Escolha sua jogada:
[1] - Pedra
[2] - Papel
[3] - Tesoura')
            jogada_humano=input('Opção:')
    return int(jogada_humano)

função random para escolha do computador
def escolha_do_computador():
    jogada_computador=randint(1,3)
    return jogada_computador

função para definir vencedor e imprimir
def jogo_decisao(jogada_humano, jogada_computador):
    time.sleep(1)
    if jogada_humano==1:
        print(f'Você escolheu Pedra')
        if jogada_computador==1:
            time.sleep(1)
            print(f'O computador escolheu Pedra
Vocês Empataram!')
        elif jogada_computador==2:
            time.sleep(1)
            print(f'O computador escolheu Papel
O computador venceu!')
        else:
            time.sleep(1)
            print(f'O computador escolheu Tesoura
Você venceu!')
    elif jogada_humano==2:
        print(f'Você escolheu Papel')
        if jogada_computador==1:
            time.sleep(1)
            print(f'O computador escolheu Pedra
Você Venceu!')
        elif jogada_computador==2:
            time.sleep(1)
            print(f'O computador escolheu Papel
Vocês empataram!')
        else:
            time.sleep(1)
            print(f'O computador escolheu Tesoura
Você Perdeu!')        
    else:
        print(f'Você escolheu Tesoura')
        time.sleep(1)
        if jogada_computador==1:
            time.sleep(1)
            print(f'O computador escolheu Pedra
O computador venceu!')
        elif jogada_computador==2:
            time.sleep(1)
            print(f'O computador escolheu Papel
Você venceu!')
        else:
            time.sleep(1)
            print(f'O computador escolheu Tesoura
Vocês empataram!')

#chamando as funcoes
jogo_decisao(escolha_do_jogador(), escolha_do_computador())

----------------------------
#5

import time
from random import randint
lista_de_possibilidades=['1','2','3']

def escolha_do_jogador():
    print(f'Escolha sua jogada:
[1] - Pedra
[2] - Papel
[3] - Tesoura')
    jogada_humano=input('Opção:')
    while True:
        if jogada_humano in lista_de_possibilidades:
            break
        else:
            time.sleep(1)
            print(f'
Sua escolha não corresponde a nenhuma opção. Escolha novamente')
            print(f'Escolha sua jogada:
[1] - Pedra
[2] - Papel
[3] - Tesoura')
            jogada_humano=input('Opção:')
    return int(jogada_humano)

def escolha_do_computador():
    jogada_computador=randint(1,3)
    return jogada_computador

def jogo_decisao():
    time.sleep(1)
#Criei o while e coloquei as funções dentro para rodarem novamente cada vez que são chamadas
    while True:
        jogada_humano=escolha_do_jogador()
        jogada_computador=escolha_do_computador()
        if jogada_humano==1:
            print(f'Você escolheu Pedra')
            if jogada_computador==1:
                time.sleep(1)
                print(f'O computador escolheu Pedra
Vocês Empataram!')
            elif jogada_computador==2:
                time.sleep(1)
                print(f'O computador escolheu Papel
O computador venceu!')
            else:
                time.sleep(1)
                print(f'O computador escolheu Tesoura
Você venceu!')
        elif jogada_humano==2:
            print(f'Você escolheu Papel')
            if jogada_computador==1:
                time.sleep(1)
                print(f'O computador escolheu Pedra
Você Venceu!')
            elif jogada_computador==2:
                time.sleep(1)
                print(f'O computador escolheu Papel
Vocês empataram!')
            else:
                time.sleep(1)
                print(f'O computador escolheu Tesoura
Você Perdeu!')        
        else:
            print(f'Você escolheu Tesoura')
            if jogada_computador==1:
                time.sleep(1)
                print(f'O computador escolheu Pedra
O computador venceu!')
            elif jogada_computador==2:
                time.sleep(1)
                print(f'O computador escolheu Papel
Você venceu!')
            else:
                time.sleep(1)
                print(f'O computador escolheu Tesoura
Vocês empataram!')  
        continuacao=continuar_jogando()
        time.sleep(1)
        if continuacao.lower() == 'n':
            break

função pergunta sobre continuar jogando
def continuar_jogando():
    while True:
        time.sleep(1)
        continuacao=input('Você quer continuar jogando? Digite S para Sim ou N para Não. ')
        if continuacao.lower() == 'n' or continuacao.lower() =='s':
            return continuacao

#aqui mudei e decidi chamar dessa forma, chamando as funcoes dentro do while da funcao
jogo_decisao()

----------------------------
#6

import time
from random import randint
lista_de_possibilidades=['1','2','3']
Só adicionei
pontos_jogador=0
pontos_computador=0

def escolha_do_jogador():
    print(f'Escolha sua jogada:
[1] - Pedra
[2] - Papel
[3] - Tesoura')
    time.sleep(1)
    jogada_humano=input('Opção:')
    while True:
        if jogada_humano in lista_de_possibilidades:
            break
        else:
            print(f'
Sua escolha não corresponde a nenhuma opção. Escolha novamente')
            time.sleep(1)
            print(f'Escolha sua jogada:
[1] - Pedra
[2] - Papel
[3] - Tesoura')
            jogada_humano=input('Opção:')
    return int(jogada_humano)

def escolha_do_computador():
    jogada_computador=randint(1,3)
    return jogada_computador

def jogo_decisao():
#Assim que conseguir evitar o erro que descrevi
    global pontos_computador
    global pontos_jogador
    while True:
        time.sleep(1)
        jogada_humano=escolha_do_jogador()
        jogada_computador=escolha_do_computador()
        if jogada_humano==1:
            print(f'Você escolheu Pedra')
            time.sleep(1)
            if jogada_computador==1:
                print(f'O computador escolheu Pedra
Vocês Empataram!')
                time.sleep(1)
            elif jogada_computador==2:
                print(f'O computador escolheu Papel
O computador venceu!')
                time.sleep(1)
                pontos_computador=pontos_computador+1
            else:
                print(f'O computador escolheu Tesoura
Você venceu!')
                time.sleep(1)
                pontos_jogador=pontos_jogador+1
        elif jogada_humano==2:
            time.sleep(1)
            print(f'Você escolheu Papel')
            if jogada_computador==1:
                print(f'O computador escolheu Pedra
Você Venceu!')
                time.sleep(1)
                pontos_jogador=pontos_jogador+1
            elif jogada_computador==2:
                print(f'O computador escolheu Papel
Vocês empataram!')
                time.sleep(1)
            else:
                print(f'O computador escolheu Tesoura
O computador venceu!')
                time.sleep(1)
                pontos_computador=pontos_computador+1        
        else:
            time.sleep(1)
            print(f'Você escolheu Tesoura')
            if jogada_computador==1:
                print(f'O computador escolheu Pedra
O computador venceu!')
                time.sleep(1)
                pontos_computador=pontos_computador+1
            elif jogada_computador==2:
                print(f'O computador escolheu Papel
Você venceu!')
                time.sleep(1)
                pontos_jogador=pontos_jogador+1
            else:
                print(f'O computador escolheu Tesoura
Vocês empataram!')  
                time.sleep(1)
        print(f'Placar: Jogador {pontos_jogador} x {pontos_computador} Computador ')
        time.sleep(1)
        continuacao=continuar_jogando()
        if continuacao.lower() == 'n':
            break

def continuar_jogando():
    while True:
        time.sleep(1)
        continuacao=input('Você quer continuar jogando? Digite S para Sim ou N para Não. ')
        if continuacao.lower() == 'n' or continuacao.lower() =='s':
            return continuacao


jogo_decisao()

@Ceos eu não entendi direito esse seu problema com as listas. Pode explicar melhor? 

No mais, legal você estar inspirado rs sinal que tá gostando de estudar programação. 

Parabéns por ter conseguido resolver e até ter ido além. 

Exercício 3

from time import sleep

alunos = ["Tiago", "Michele", "João", "Maria", "Marcos"]

def pergunta():
while True:
try:
x = input("Presente ou Faltou?")
if not (x == "Presente" or x == "presente" or x == "Faltou" or x == "faltou"):
raise ValueError("informar corretamente")
except ValueError as e:
print("Valor inválido", e)
else:
print(alunos[contador] + " " + x)
break


contador = 0
for nome in alunos:
print(nome)
pergunta()
contador += 1
sleep(2)

Preciso aprender a colar bonito igual a turma kkkkk não consegui 

@Abruxo hahaha só ir na ferramentazinha de código aqui



Esse primeiro símbolo, as chaves com um ponto e vírgula. Escolhe Python lá e manda brasa. 

from time import sleep

alunos = ["Tiago", "Michele", "João", "Maria", "Marcos"]

def pergunta():
    while True:
        try:
            x = input("Presente ou Faltou?")
            if not (x == "Presente" or x == "presente" or x == "Faltou" or x == "faltou"):
                raise ValueError("informar corretamente")  
        except ValueError as e:
            print("Valor inválido", e)
        else:
            print(alunos[contador] + " " + x)
            break
    
    
contador = 0      
for nome in alunos:
    print(nome)
    pergunta()
    contador += 1
    sleep(2)

@Abruxo legal, ainda capturou uma exceção ali, assunto que nem cheguei a falar ainda. 

Fala pessoal. Foi difícil, mas saiu hehe Segue o jeito que fiz

Ex1
'''
Crie uma lista de chamada de uma sala de aula de uma escola,
com nomes de 5 alunos. Itere sobre essa lista e printe o nome 
de cada aluno na tela. Simule o comportamento de uma sala de aula. 
A cada aluno, o programa irá esperar duas possíveis entradas: “presente” 
ou “faltou”. Se o aluno estiver presente, printe na tela o nome do aluno 
e ao lado a marcação que ele está presente. Se não, printe o nome do aluno
e ao lado a palavra “faltou”. Brinque com esse comportamento. (d6_ex1.py)
'''

def chamada():
    lista=['Caio', 'Pablo', 'Tício', 'Mévio', 'Saulo']
    for item in lista:
        print(f'aluno(a) {item}')
        situacao_aluno=input('Escreva "presente" ou "faltou": ')
        print(f'Aluno(a) {item} - {situacao_aluno}')

chamada()

----------------------------------------------------------------
Ex2:

'''
Melhore o programa acima. Agora se a entrada de presença for diferente 
de “presente” ou “faltou”, faça o programa perguntar a resposta certa 
até o usuário digitar uma resposta entre “presente” ou “faltou”. Enquanto 
isso não acontecer, imprima na tela uma mensagem de erro e peça novamente
 a entrada correta. (d6_ex2.py)
 '''


def chamada():
    lista=['Caio', 'Tício', 'Mévio', 'Pablo', 'Saulo']
    entrada=['presente', 'faltou']
    for item in lista:
        print(f'aluno(a) {item}')
        situacao_aluno=input('Escreva "presente" ou "faltou":  ')
        while situacao_aluno not in entrada:
            situacao_aluno=input('digite apenas "presente" ou "faltou"  ')
        print(f'Aluno(a) {item} - {situacao_aluno}')

chamada()

----------------------------------------------------------------
Ex3:
'''
O programa ex2 acima tem uma saída de dados bem brusca. 
Torne essa saída mais palatável para quem lê. Adicione
um timer a cada output do programa. 
'''

from time import sleep

def chamada():
    lista=['Tício', 'Mévio', 'Pablo', 'Caio', 'Saulo']
    entrada=['presente', 'faltou']
    for item in lista:
        print(f'aluno(a) {item}')
        situacao_aluno=input('Escreva "presente" ou "faltou":  ')
        sleep(3)
        while situacao_aluno not in entrada:
            situacao_aluno=input('algo deu errado! 
Digite apenas "presente" ou "faltou"  ')
            sleep(3)
        print(f'Aluno(a) {item} - {situacao_aluno}')

chamada()
----------------------------------------------------------------
Ex4:

'''
(Clássico): Crie um jogo de pedra, papel e tesoura onde você jogará contra 
o computador. Mostre as mensagens padrão dependendo do vencedor ou do empate. 
Iniba as possibilidades de erro do programa usando os conhecimentos desta aula.
Tente escrever o código do jogo inteiro dentro de funções. Ao final, faça uma 
função que irá chamar as outras e chame esta função para rodar o jogo. (d6_ex4.py).
 '''


def escolha_usuario():
    opcao=[1,2,3]
    input_usuario=int(input('Escolha o número correspendente entre 
[1] - pedra 
[2] - papel 
[3] - tesoura   '))

    while input_usuario not in opcao:
        input_usuario=int(input('Algo deu errado! 
Escolha apenas dentre os números correspondentes às opções "pedra", "papel" ou "tesoura":  '))
    
    return input_usuario
      
def escolha_computador():
    from random import choice
    opcao=[1,2,3]
    input_computador=choice(opcao)
    return input_computador


def comparacao_usuario_computador():

    input_usuario=escolha_usuario()
    input_computador=escolha_computador()
   
    if input_usuario==input_computador:
        mensagem=(f"Deu empate! Você escolheu {input_usuario} e o computador ecolheu {input_computador}")
    elif (input_usuario==1 and input_computador==2) or (input_usuario==2 and input_computador==3) or (input_usuario==3 and input_computador==1):
        mensagem=(f"Você perdeu! Você escolheu {input_usuario} e o computador ecolheu {input_computador}")
    elif (input_usuario==1 and input_computador==3) or (input_usuario==2 and input_computador==1) or (input_usuario==3 and input_computador==2):
        mensagem=(f"Você ganhou! Você escolheu {input_usuario} e o computador ecolheu {input_computador}")
    return mensagem


mensagem=comparacao_usuario_computador()

if '1' or '2' or '3' in mensagem:
    mensagem=mensagem.replace('1', 'pedra')
    mensagem=mensagem.replace('2', 'papel')
    mensagem=mensagem.replace('3', 'tesoura')

print(mensagem)

----------------------------------------------------------------
Ex5:
'''
Melhore o jogo acima. Pergunte ao final de cada jogada 
se o jogador quer continuar jogando. Se sim, rode o jogo 
novamente até o jogador desistir de jogar. Se não, finalize 
o jogo. (d6_ex5.py)
'''

from time import sleep

def escolha_usuario():
    opcao=['1','2','3']
    input_usuario=input('Escolha o número correspendente entre 
[1] - pedra 
[2] - papel 
[3] - tesoura   ')
    
    while input_usuario not in opcao:
        input_usuario=input('Algo deu errado! 
Escolha apenas dentre os números correspondentes às opções "pedra", "papel" ou "tesoura":  ')
    
    input_usuario=int(input_usuario)
    return input_usuario
      
def escolha_computador():
    from random import choice
    opcao=[1,2,3]
    input_computador=choice(opcao)
    return input_computador


def comparacao_usuario_computador():

    input_usuario=escolha_usuario()
    input_computador=escolha_computador()
   
    if input_usuario==input_computador:
        mensagem=(f"Deu empate! Você escolheu {input_usuario} e o computador ecolheu {input_computador}")
    elif (input_usuario==1 and input_computador==2) or (input_usuario==2 and input_computador==3) or (input_usuario==3 and input_computador==1):
        mensagem=(f"Você perdeu! Você escolheu {input_usuario} e o computador ecolheu {input_computador}")
    elif (input_usuario==1 and input_computador==3) or (input_usuario==2 and input_computador==1) or (input_usuario==3 and input_computador==2):
        mensagem=(f"Você ganhou! Você escolheu {input_usuario} e o computador ecolheu {input_computador}")
    
    if '1' or '2' or '3' in mensagem:
        mensagem2=mensagem.replace('1', 'pedra')
        mensagem2=mensagem2.replace('2', 'papel')
        mensagem2=mensagem2.replace('3', 'tesoura')
    sleep(3)
    print(mensagem2)
    
    jogar_de_novo=''
    while jogar_de_novo not in ['S', 'N']:
        jogar_de_novo=input('Digite S se quiser jogar de novo e N se não quiser:  ')
    if jogar_de_novo=="S":
        sleep(1)
        comparacao_usuario_computador()
    else:
        sleep(3)
        print('Obrigado por jogar! Nos vemos na próxima')
        from sys import exit
        exit()

   
comparacao_usuario_computador()

----------------------------------------------------------------
Ex6:

'''
Melhore ainda mais o jogo acima. Adicione um placar ao jogo. 
Mostre o resultado global ao final de cada jogada.
'''

from time import sleep
pontuacao_usuario=0
pontuacao_computador=0

def escolha_usuario():
    opcao=['1','2','3']
    input_usuario=input('Escolha o número correspendente entre 
[1] - pedra 
[2] - papel 
[3] - tesoura   ')
    
    while input_usuario not in opcao:
        input_usuario=input('Algo deu errado! 
Escolha apenas dentre os números correspondentes às opções "pedra", "papel" ou "tesoura":  ')
    
    input_usuario=int(input_usuario)
    return input_usuario
      
def escolha_computador():
    from random import choice
    opcao=[1,2,3]
    input_computador=choice(opcao)
    return input_computador

def comparacao_usuario_computador():
    input_usuario=escolha_usuario()
    input_computador=escolha_computador()

    if input_usuario==input_computador:
        mensagem=(f"Deu empate! Você escolheu {input_usuario} e o computador ecolheu {input_computador}")
        vencedor='empate'
    elif (input_usuario==1 and input_computador==2) or (input_usuario==2 and input_computador==3) or (input_usuario==3 and input_computador==1):
        mensagem=(f"Você perdeu! Você escolheu {input_usuario} e o computador ecolheu {input_computador}")
        vencedor='computador'
    elif (input_usuario==1 and input_computador==3) or (input_usuario==2 and input_computador==1) or (input_usuario==3 and input_computador==2):
        mensagem=(f"Você ganhou! Você escolheu {input_usuario} e o computador ecolheu {input_computador}")
        vencedor='usuario'

    if '1' or '2' or '3' in mensagem:
        mensagem2=mensagem.replace('1', 'pedra')
        mensagem2=mensagem2.replace('2', 'papel')
        mensagem2=mensagem2.replace('3', 'tesoura')
    sleep(3)
    print(mensagem2)
    
    global pontuacao_usuario
    global pontuacao_computador
 
    if vencedor=='empate':
        pontuacao_usuario+=1
        pontuacao_computador+=1
    elif vencedor=='usuario':
        pontuacao_usuario+=1
    elif vencedor=='computador':
        pontuacao_computador+=1
    
    print(f'Placar: 
computador={pontuacao_computador} x usuário={pontuacao_usuario}')
    
    

def jogo():
    comparacao_usuario_computador()
    jogar_de_novo=''
    while jogar_de_novo not in ['S', 'N']:
        jogar_de_novo=input('Digite S se quiser jogar de novo e N se não quiser:  ')
    if jogar_de_novo=="S":
        sleep(1)
        jogo()
    else:
        sleep(3)
        print('Obrigado por jogar! Nos vemos na próxima')
        from sys import exit
        exit()


jogo()?

@Pacoquinha muito bom. Esses exercícios desse dia acho que foram os que mais deram trabalho pra elaborar até agora hahaha

import time

def ampulheta():
    for x in range(3):
        print(' Aguarde - -- ', end = '\r')
        time.sleep(0.1)
        print(' Aguarde - \ ', end = '\r')
        time.sleep(0.1)
        print(' Aguarde - | ', end = '\r')
        time.sleep(0.1)
        print(' Aguarde - / ', end = '\r')
        time.sleep(0.1)
        print(' Aguarde - -- ', end = '\r')


# EXERCÍCIO 1

lista_alunos = ['João', 'Maria', 'José', 'Pedro', 'Paulo']

for aluno in lista_alunos:
    presenca = input(f'Registrar presença de {aluno} (P/F): ')
    if presenca == 'P':
        print(f'{aluno} presente!' )
    else:
        print(f'{aluno} faltou!' )


# EXERCÍCIO 2

for aluno in lista_alunos:
    
    presenca = input(f'Registrar presença de {aluno} (P/F): ')

    while presenca not in ['P', 'F']:
        presenca = input(f'Opção incorreta. Informe (P)resente ou (F)altou para {aluno}: ') 

    if presenca == 'P':
        print(f'{aluno} presente!' )
    else:
        print(f'{aluno} faltou!' )    
  


    # EXERCÍCIO 3
for aluno in lista_alunos:
    
    presenca = input(f'Registrar presença de {aluno} (P/F): ')

    while presenca not in ['P', 'F']:
        presenca = input(f'Opção incorreta. Informe (P)resente ou (F)altou para {aluno}: ') 

    if presenca == 'P':
        print(f'{aluno} presente!' )
    else:
        print(f'{aluno} faltou!' )    
    
    ampulheta()
  

    # EXERCICIO 4
    
    #  Matriz de jogadas
    #     0 1 2
    #   0 1 0 2
    #   1 2 1 0
    #   2 0 2 1
    
import random   

def iniciar_jogo():

    jogadas = ['Pedra', 'Papel', 'Tesoura']
    lista_resultados = ['Derrota', 'Empate', 'Vitória!']
    matriz = [[1, 0, 2],[2, 1, 0], [0, 2, 1]]

    jogada_humano = int(input('sair sua jogada [0]-Pedra [1]-Papel [2]-Tesoura :')) 

    while jogada_humano not in [0, 1, 2]:
        jogada_humano = int(input('Opção inválida. sair sua jogada [0]-Pedra [1]-Papel [2]-Tesoura :')) 

    jogada_computador = random.randint(0, 2)    

    def verifica_resultado(jogador, computador):
        print('
')
        print('*** Resultado ***')
        print(f'Sua jogada: {jogadas[jogada_humano]}')
        print(f'Computador: {jogadas[jogada_computador]}')
        print(lista_resultados[matriz[jogador][computador]])

    verifica_resultado(jogada_humano, jogada_computador)

iniciar_jogo()


# EXERCICIO 5

import random   

def iniciar_jogo():

    jogadas = ['Pedra', 'Papel', 'Tesoura']
    lista_resultados = ['Derrota', 'Empate', 'Vitória!']
    matriz = [[1, 0, 2],[2, 1, 0], [0, 2, 1]]

    jogada_humano = input('sair sua jogada [0]-Pedra [1]-Papel [2]-Tesoura :') 

    while jogada_humano not in ['0', '1', '2']:
        jogada_humano = input('Opção inválida. sair sua jogada [0]-Pedra [1]-Papel [2]-Tesoura :')

    jogada_humano = int(jogada_humano)
    jogada_computador = random.randint(0, 2)    

    def verifica_resultado(jogador, computador):
        print('
')
        print('*** Resultado ***')
        print(f'Sua jogada: {jogadas[jogada_humano]}')
        print(f'Computador: {jogadas[jogada_computador]}')
        print(lista_resultados[matriz[jogador][computador]])

    verifica_resultado(jogada_humano, jogada_computador)

sair = 'N'
while sair != 'S':    
    iniciar_jogo()    
    sair = input('Deseja sair [S] :')


# EXERCICIO 6

import random   

pontos_humano = 0
pontos_computador = 0

def iniciar_jogo():

    jogadas = ['Pedra', 'Papel', 'Tesoura']
    lista_resultados = ['Derrota', 'Empate', 'Vitória!']
    matriz = [[1, 0, 2],[2, 1, 0], [0, 2, 1]]
       
    jogada_humano = input('Escolha sua jogada [0]-Pedra [1]-Papel [2]-Tesoura :') 

    while jogada_humano not in ['0', '1', '2']:
        jogada_humano = input('Opção inválida. Escolha sua jogada [0]-Pedra [1]-Papel [2]-Tesoura :')

    jogada_humano = int(jogada_humano)
    jogada_computador = random.randint(0, 2)    

    def verifica_resultado(jogador, computador):
        print('
')
        print('*** Resultado ***')
        print(f'Sua jogada: {jogadas[jogada_humano]}')
        print(f'Computador: {jogadas[jogada_computador]}')
        print(lista_resultados[matriz[jogador][computador]])
        
        global pontos_humano
        global pontos_computador

        if matriz[jogador][computador] == 2:
            pontos_humano += 1
        elif matriz[jogador][computador] == 0:
            pontos_computador += 1

    verifica_resultado(jogada_humano, jogada_computador)
    print(f'Placar: Humano {pontos_humano} x {pontos_computador} Computador')

sair = 'N'
while sair != 'S':    
    iniciar_jogo()    
    sair = input('Deseja sair [S] :')

@Oogway tá aplicado, hein rs daqui a pouco alcança o momento atual do curso. 

E gostei da ampulheta. 

Já já alcanço! Tô curtindo muito voltar a programar! Obrigado pela oportunidade e parabéns pela qualidade e dedicação!

import random
import time


def jogada_aleatoria():
    """
    Escolhe um numero aleatorio de 1 a 3.
    """
    return random.randint(1, 3)


def vencedor(jogador1, jogador2):
    """
    Retorna o vencedor do jogo pedra, papel e tesoura.
    Os valores de entrada devem ser diferentes.
    """
    if jogador1 == 'Pedra':
        if jogador2 == 'Tesoura':
            return jogador1
        else:
            return jogador2
    elif jogador1 == 'Papel':
        if jogador2 == 'Pedra':
            return jogador1
        else:
            return jogador2
    elif jogador1 == 'Tesoura':
        if jogador2 == 'Papel':
            return jogador1
        else:
            return jogador2


def pedra_papel_tesoura():
    possibilidades = ['Pedra', 'Papel', 'Tesoura']
    jogada_usuario = ''
    print('Escolha uma jogada abaixo:
[1] - Pedra
[2] - Papel
[3] - Tesoura')
    try:
        jogada_usuario = int(input('Opção: '))
    except ValueError:
        print('Somente números são aceitos.')
    while jogada_usuario not in [1, 2, 3]:
        try:
            jogada_usuario = int(input('Tente novamente. Digite um número entre 1 e 3: '))
        except ValueError:
            print('Somente números são aceitos.')
    jogada_usuario = str(possibilidades[jogada_usuario-1])
    jogada_computador = possibilidades[jogada_aleatoria() - 1]
    print(f'Você escolheu {jogada_usuario}')
    time.sleep(1)
    print(f'O computador escolheu {jogada_computador}')
    time.sleep(1)
    if jogada_usuario != jogada_computador:
        resultado = vencedor(jogada_computador, jogada_usuario)
        if resultado == jogada_usuario:
            print(f'{jogada_usuario} ganha de {jogada_computador} - Você venceu!')
        else:
            print(f'{jogada_computador} ganha de {jogada_usuario} - Você perdeu!')
    else:
        print(f'{jogada_usuario} é igual a {jogada_computador} - Deu empate!')
    time.sleep(1)
    repetir = ''
    while repetir not in ['S', 'N']:
        repetir = input('Você quer jogar novamente? Digite "S" se sim e "N" se não: ').upper()
    return repetir


jogar = pedra_papel_tesoura()
while jogar == 'S':
    jogar = pedra_papel_tesoura()

import time
alunos = ['João', 'Pedro', 'Cláudia', 'Maria', 'Bruno']
def chama_lista_de_chamada(alunos):
    presente = ('presente')
    faltou = ('faltou')
    lista_de_possibilidades = ['presente', 'faltou']
    for aluno in alunos:
        time.sleep(0.5)
        print(f'{aluno}!')
        time.sleep(1)
        input_user = input (f'Se {aluno} estiver presente digite "presente", senão digite "faltou": ')
        time.sleep(1)
        while input_user not in lista_de_possibilidades:
            print('Erro, tente novamente.')
            time.sleep(0.5)
            input_user = input (f'Se {aluno} estiver presente digite "presente", senão digite "faltou": ')
            time.sleep(0.5)
        if input_user == presente:
            time.sleep(0.5)
            print(f'{aluno} está presente.')
        elif input_user == faltou:
            time.sleep(0.5)
            print(f'{aluno} faltou.')

chama_lista_de_chamada(alunos)

#Exercicio Jokenpo

import sys
import random
import time

#formata para tesoura
def formata_tesoura(tesoura):
    return tesoura.replace('1','Tesoura')

#formata para pedra
def formata_pedra(pedra):
    return pedra.replace('2','Pedra')

#formata para papel
def formata_papel(papel):
    return papel.replace('3','Papel')

#Computador escolhe
def computer_choose(lista_de_possibilidades):
    comp_result = random.choice(lista_de_possibilidades)
    if comp_result == '1':
        return formata_tesoura(comp_result)
    elif comp_result == '2':
        return formata_pedra(comp_result)
    else:
        return formata_papel(comp_result)

#Usuario escolhe
def user_choose(lista_de_possibilidades):
    user_result = input(f'Escolha sua jogada abaixo: 
 [1] - Tesoura 
 [2] - Pedra 
 [3] - Papael 
 Opção: ')
    while user_result not in lista_de_possibilidades:
        time.sleep(0.5)
        user_result = input(f'Algo deu errado. Tente novamente. Digite um número entre 1 e 3: ')
    if user_result in lista_de_possibilidades:
        if user_result == '1':
            return formata_tesoura(user_result)
        elif user_result == '2':
            return formata_pedra(user_result)
        else:
            return formata_papel(user_result)

#Chama as duas funções e da os resultados
def jokenpo():
    lista_de_possibilidades = ['1', '2', '3']
    tesoura = 'Tesoura'
    pedra = 'Pedra'
    papel = 'Papel'
    comp_result = computer_choose(lista_de_possibilidades)
    time.sleep(0.5)
    user_result = user_choose(lista_de_possibilidades)
    time.sleep(1)
    print(f'O computador escolheu {comp_result}')
    time.sleep(1)
    print(f'Você escolheu {user_result}')
    time.sleep(1)
    if comp_result == user_result:
        return f'Você empatou com o computador'
    elif comp_result == tesoura and user_result == papel \
        or comp_result == pedra and user_result == tesoura \
        or  comp_result == papel and user_result == pedra:
        return f'O computador venceu!'
    else:
        return f'Você venceu!'

def pontua_vencedor(vencedor, pontuacao_jogador, pontuacao_computador):
    if vencedor == 'Jogador':
        pontuacao_jogador += 1
    elif vencedor == 'Computador':
        pontuacao_computador += 1
    return [pontuacao_jogador, pontuacao_computador]

#Chama a função jokenpo() e repete ela
def repeat_jokenpo():
    print(jokenpo())
    lista_sair = ['n', 'N']
    lista_jogar = ['s', 'S']
    lista_repeat = lista_jogar + lista_sair
    answer = ''
    while answer not in lista_repeat:
        answer = input(f'Você quer jogar novament? Digite "S" se sim e "N" se não: ')
    if answer in lista_sair:
        print('Obrigado por jogar. Nos vemos na próxima')
        sys.exit()
    else:
        repeat_jokenpo()

repeat_jokenpo()

@Estevaopp boa

@ThiagoDV Obrigado pelo curso, tem me ajudado muito. Estou começando a aprender a programar, pois quero fazer uma faculdade na área, sou grato pelo seu trabalho!!!