Exercício Python

Estude pelo nosso site e tire certificado de 40 horas. Curso completo em:
www.cursoemvideo.com/curso/python-3-mundo-3/

[@RadioactiveGamesOficial]

Guanabara, por favor faz uma série ensinando Interface gráfica, quero muito entender como funciona e começar a tentar desenvolver algo. Quem concorda da UP pra ele ver

[@MrDavidribeiro570]

UP

[@ricardopouza4198]

Na Udemy tem alguns cursos bons e e bem barato.

[@TurokTurk]

UP

[@herissonricardo-slackwareo450]

@@ricardopouza4198 As aulas do Guanabara é melhor que dá Udemy, eu tirei certificado de um e estou fazendo outro la, mas sem comparação com as aulas do Prf Guanabara que é o melhor, Parabéns professor pela excelente didática de ensino. Esse merece todo apoio e compartilhamento.

[@halaintrabulsi7722]

concordo plenamente.

[@ideiasmarginais9534]

Um dia eu tava nos módulos,agora já estou aqui,nos dicionários,obrigado Guanabara. Muito sucesso para você ;)

[@amandamendonca2494]

Senti falta de uma explicacao pra utilidade de itemgetter, somente a aplicacao sem detalhamento dificulta para entendimento e futuros usos. No mais, acho exelente as aulas e exercicios.

[@interagetech]

concordo 100%

[@hydraxler5537]

eu fiz sem o itemgetter , tomei a utilidade o funcionamento dele como o mesmo do meu script

[@paulodosanjos7253]

uma forma mais simples de preencher o dict seria
dado=dict()
for c in range (1,5):
dado[f"jogador {c}"]=randint(1,6)

[@hydraxler5537]

fiz igual, só que botei range(4) depois {c+1}

[@XDanRJ]

Boa.
Assim dá pra até definir a quantidade de players com um input (não esquece de transformar o input em inteiro se não vai dar erro na hora de colocar no range)

[@edicaokss488]

eu fiz desse jeito porem so não coloquei o randint ai, pq assim pode dar numeros repetidos

[@paulodosanjos7253]

@@edicaokss488 mas não teria problema, pois como é pra simular arremesso de dados, é normal que o os jogadores tirem números repetidos

[@steel9203]

eu fiz assim, deu 1 linha no total
jogadores={'jogador-1':randint(1,6),'jogador-2':randint(1,6),'jogador-3':randint(1,6),'jogador-4':randint(1,6),}

[@MusicaPoesia]

Sem itemgetter
from random import randint
from time import sleep
resutados = dict()
jogadores = list()
print('Valores sorteados:')
for c in range(0, 4):
n = randint(1, 6)
resutados['Jogador'+str(c+1)] = n
jogadores.append(n)
sleep(0.5)
print(f'O {"Jogador"+str(c+1)} tirou {n}')
jogadores.sort(reverse= True)
jogar = 't'
print('Ranking dos jogadores:')
for p in range(0,4):
print(f'{p+1}º Lugar: ', end='')
for k, v in resutados.items():
if v == jogadores[p] and jogar != k:
sleep(0.1)
print(k,'com',v)
jogar = k
break

[@jml1640]

Bacana!

[@jezreelmoraes5864]

fiz uma versão que n precisa da lista, usando repetição;
import time,random
data = {}
for c in range (0,4):
player_id = "player "+str(c+1)
data[player_id] = random.randint(1,6)
time.sleep(.5)
print(f'The {player_id} has {data[player_id]}')
n = 1
for c in range(0,7):
for p,v in data.items():
if v == (6 - c):
time.sleep(.5)
print(f"The {n}º position is the {p} with {v}")
n += 1

[@finnzao_]

nossa mano!valeu demais,a montagem desse ultimo if me ensinou muito com um problema que enfretava

[@lucapohl-angel4618]

legal tua solocuao é curta e simples, mas infelizmente serve apenas 1 vez pra esse caso especifico se tu quiser mudar a quantidade de jogadores se tem q mudar manualmente é mais compensavel fazer solucoes que possam ser mudadas facilmente como essa minha:
from random import randint
from time import sleep
# import operator
jogador = 1
Dict = {}
quantidade_de_jogadores = 4
for c in range(quantidade_de_jogadores):
Dict['Jogador' + str(jogador)] = randint(1, 7)
jogador += 1
lista = list(Dict.copy().items())
# print(sorted(lista, key=operator.itemgetter(1)))
ordem = sorted(lista, key=lambda a: a[1], reverse=True)
print('Valores sorteados: ')
for c in lista:
print(f' O {c[0]} tirou {c[1]}')
sleep(1)
print('Ranking dos Jogadores: ')
for v, c in enumerate(ordem):
print(f' Em {v+1}° lugar: {c[0]} com {c[1]}')
sleep(1)
aq vc pode mudar quantidade de jogadores pela variavel "quantidade_de_jogadores" a qualquer momento e automaticamente ira organizar o dicionario reversamente tbm.

[@ianrl100]

@@lucapohl-angel4618 Muito bom brother, mas acho que tu confundiu o randint() com a função range() mano. É que tá de 1 a 7, mas ta tranks! A propósito, achei incrível a forma como você usou o lambda. Eu particularmente nem saberia como aplicar o lambda em qualquer tipo de ocasião, seja ela qual fosse!

[@playerboxiptv8346]

Guanabara, faz um vídeo recomendando bibliotecas úteis para Python p/ estudarmos a parte.

[@marco.nascimento]

Depende da área: numpy, matplotlib, scipy, pandas são as mais utilizadas no ramo científico e machine learning etc, por exemplo.

[@playerboxiptv8346]

Quero aprender Machine Learning e Deep Learning =(

[@jeanmichael2917]

@Kleber Rodrigues Games: pygame
Web: django ou flask(frameworks)

[@DznSkips]

@@marco.nascimento Alguma recomendação para segurança/ hacking?

[@igor_707]

O pyautogui é muito bom para automações

[@ildebrandobastos7602]

Pelo que entendi, funciona tanto usando "lambda" quanto com o import do "itemgetter", de qualquer forma, muito interessante esse exercício e denso! Valeu prof. Guanabara!!!

[@MatheusAzevedo-ni9vb]

Eu vi muitas pessoas com diversas soluções diferentes, acho isso super interessante e válido. Estudei por fora e consegui chegar em uma resolução mais enxuta e consideravelmente simples, sem o uso do módulo itemgetter.
from random import randint
from time import sleep
players = dict()
print('Drawn values: ')
for play in range(1, 5):
players[f'player{play}'] = randint(1, 6)
print(f' Player {play} rolled {players[f"player{play}"]}')
sleep(0.5)
print('Player ranking')
for key, value in enumerate(sorted(players, key=players.get, reverse=True)):
print(f' {key + 1}° place: {value} with {players[value]}')
sleep(0.5)

[@Saykmaruu]

Bem mais simples, o professor deu uma sacaneada na explicação dele, ao invés de usar essa solução com uma linha, importou uma biblioteca, jogou tudo pra dentro de uma lista, arrodeio da peste pra chegar no resultado, só complica pra aprender.

[@santiagofilipe5115]

Estou gostando da minja evolução. Estou conseguindo fazer cada exercício antes de ver a resolução.❤
Muito obrigado prof.

[@joaoneto1399]

- Não entendi por que uma variável inicializada como dicionário pode se transformar em uma lista e o Python só informa erro se tentarmos acessar como dicionário.
- O método itemgetter poderia ter sido mencionado antes, mesmo que não fosse explicado, antes como preparação.
No mais, tudo certo, a metodologia do curso e o professor realmente são diferenciados.Parabéns!

[@rodrigomarimon6576]

bom dia, já achou a resposta do teu primeiro questionamento?

[@Enzoerb]

depois de descobrir que existe o
from operator import itemgetter
fica facil, antes tava dificil hahahaha

[@jeaninove1881]

Eu fiz um programa com 56 linhas antes de conhecer o itemgetter kkk

[@olokinhomewwww550]

enzoerb,você por aqui?? Dahora man,se vc voltar pro brawl me avis

[@Enzoerb]

@@olokinhomewwww550 man, voltei esses dias, não tou postando porque falta editar alguns, mas acho que vou começar a postar mesmo sem editar, pra conseguir disponibilizar conteudo

[@Tavinnzx01]

@@jeaninove1881 kkkk voce nao conhece o lambda? é so troca o itemgetter por lambda x:x["Dados'"]

[@aDDxDD]

Depois de algumas pesquisas resolvi a ordenação com:
sort_orders = sorted(jogo.items(), key=lambda x: x[1], reverse=True)
Sem precisar fazer nenhuma importação de modulo...

[@lucianolopezdossantos]

tive a ideia de usar o sort() mas não conseguir, do jeito que fiz só aceitava com lista, enfim desisti

[@stomperhk9107]

@@lucianolopezdossantos O sort é um método que só funciona com listas.

[@lucapohl-angel4618]

sim, eu fiz o mesmo dpois de pesquisas eu tbm fiz assim e tbm testei o modulo operator :)

[@guilhermemenezes5398]

Acho que nesse vídeo faltou uma explicação melhor sobre o 'itemgetter'. Ficou um vazio sobre a função que ele exerce e em quais situações deve ser usado.

[@alexandremoreira8776]

Vamos por partes:
Olhando a função sorted()
sorted(jogo.items, key, reverse=False) Retorna uma lista sorteada nova dos "itens em jogo".
( key e reverse são opcionais)
key: opcional, neste caso chamou o operador itemgetter.
itemgetter(1) = retorna uma Tupla de valores do item chamado:
(jogador1,resultado)
0 (1)item chamado
A tupla será dos resultados no dict.jogo, esta será a referencia a ser sorteada é:
(resultadojogador1, resultadojogador2, ......
reverse = True e para sortear em ordem decrescente
No inicio do curso o Guanabara falou sobre estudar os docs no Phyton.gov, falta alguém nos explicar os nomes utilizados no texto, este é o complicado. Use sempre busca para entender o item, neste caso itemgetter.
docs.python.org/pt-br/3/library/operator.html?highlight=itemgetter#operator.itemgetter
operator.itemgetter(item)
operator.itemgetter(*items)
Return a callable object that fetches item from its operand using the operand’s __getitem__() method. If multiple items are specified, returns a tuple of lookup values. For example:

[@thiagoestudante7227]

sim faltou mesmo

[@terrornaweb9739]

Sentir a mesma coisa :(

[@thor_kryptonite1940]

tbm

[@MonkeyDLuffy-xp5dg]

from operator import itemgetter
A = {'biscoito':'120 gramas'}
Esse número dentro do key=itemgetter(1) serve para definir o valor que você quer dentro do dicionário. No caso se o valor dentro do itemgetter for 1, ele pegaria '120 gramas', e se fosse 0, pegaria 'biscoito'. Foi oq eu entendi sobre, e ai só usar dentro do sorted.
Me corrija, pois posso estar absolutamente errado, e ainda nn testei o itemgetter a fundo. Me baseei na explicação e no que executei brevemente aqui.

[@HawkNyon]

no ranking usei um cont e deu certo também:
print('Ranking dos jogadores:')
cont = 1
for k, v in ranking:
print(f' {cont}º lugar: {k} com {v}')
cont += 1
sleep(.5)
>> Ranking dos jogadores:
1º lugar: jogador2 com 6
2º lugar: jogador1 com 4
3º lugar: jogador3 com 2
4º lugar: jogador4 com 1

[@grehebert]

Fazendo na marra, eu só consigo com o uso de lista pra guardar o ranking e depois dar um sorted na lista. Apesar desse modo chegar mais perto do que eu gostaria de fazer, eu não gostei. O uso de lambda foi o que mais me agradou. Tentei também com vários while, for e if, porém o resultado final também não me agradou. No fundo, lambda e itemgetter se tornam a mesma coisa, uma forma de mascarar o uso de lista pra resolver esse problema. Enfim, nada na vida é perfeito, tirando você xuxuzinho, mas os resto, mesmo não sendo como nós gostaria que fossem, é mais do que o suficiente. Estou sim um pouco frustado por ter passado o dia todo tentando fazer o negocio e não conseguir, mas mil vezes grato, pelos inúmeros conhecimento adquirido hoje. Graças ao Curso em Video, graças aos comentários, graças aos sites, graças a comunidade de programadores. Sou muito grato a todos vocês.
.
.
.
Este foi o código pra ser divertido, espero que gostem
from random import randint
from time import sleep
print('~' * 50)
print(f'{"SUPER MEGA ULTRA BLASTER JOGO DE DADO":^50}')
print('~' * 50)
sleep(3)
print(' Cada jogador vai jogar 2d6, ou seja, 2 dados de 6 lados')
sleep(3)
print('BOA SORTE!!!')
sleep(1)
print('Que o primeiro jogaador comece!!!')
sleep(2)
Jogadores = dict()
for repetição in range (0, 4):
Jogadores[f'{repetição + 1}p'] = {'1d6': randint(1,6), '2d6': randint(1 , 6)}
Jogadores[f'{repetição + 1}p']['soma'] = Jogadores[f'{repetição + 1}p']['1d6'] + Jogadores[f'{repetição + 1}p']['2d6']
for P, dados in Jogadores.items():
print(f'O {P} jogou o primeiro dado.')
sleep(1)
print(f'Caiu {dados["1d6"]}')
sleep(1)
print('Jogou o segundo dado.')
sleep(1)
print(f'Caiu {dados["2d6"]}')
sleep(1)
print(f'Total: {dados["soma"]}')
sleep(1)
if Jogadores[P]['soma'] == 12:
print('INCRÍVEL!!!')
elif Jogadores[P]['soma'] == 11:
print('Muito bom!')
elif Jogadores[P]['soma'] == 2:
print('QUE JOGADA HORRÍVEL!!!')
print('-' * 27)
sleep(2)
rank = sorted(Jogadores.items(), key=lambda item:item[1]['soma'], reverse=True)
print('~' * 50)
print(f'{"RANKING DOS MELHORES MAIS BEM COLOCADOS":^50}')
print('~' * 50)
sleep(3)
for colocação, dado in enumerate(rank):
print(f'{colocação + 1}º LUGAR: {dado[0]} com {dado[1]["soma"]}pts')
sleep(1)

[@julianacdo]

E quando é o próprio professor que manda o vídeo para os alunos?? kkkkkkkkkk
Algo de errado não tá certo.
Excelente didática! coloca todos no chinelo!!

[@GustavoCosta-jr1mh]

Consegui extrair o maior e o menor dessa maneira:
for k,v in bets.items():
if v < holder_smaller:
holder_smaller = v
smaller = k
if v > holder_bigger:
holder_bigger = v
bigger = k

[@GustavoCosta-jr1mh]

Sendo que o valor inicial do holder_bigger é 1 e o holder_smaller é 6

[@nelsonsoares2281]

Professor faz uma serie ensinando sobre interface gráfica e Orientação Objeto.

[@rodrigoortega1092]

A criação do dicionário fiz um pouco diferente... Mas funcionou da mesma forma!
Obrigado pelas aulas Guanabara! Muito bom.. tenho evoluído muito em Python ...
import random as rd
import operator as op
from time import sleep
dado = dict()
for i in range(0, 4):
dado['jogador'+str(i+1)] = rd.randint(1, 6)
print('-='*30)
print('Valores sorteados: ')
for k, v in dado.items():
print(f' O {k} tirou {v} no dado')
sleep(1)
print('Ranking dos Jogadores: ')
dados = sorted(dado.items(), key=op.itemgetter(1), reverse=True)
for i, v in enumerate(dados):
print(f' {str(i+1)}º lugar: {v[0]} com {v[1]} ')

[@augustoalvesserpa1797]

# trabalhei com dois dicionários, mas usar só um e no fim apresentar/printar os resultados na ordem também dá certo #
from random import randint
registro = {}
registro_ordenado = {}
pos = 0
# No 1º dicionário eu criei os 4 jogadores, e um número aleatório do jogo de dados #
for i in range(1, 5):
registro[f'jogador {i}'] = randint(1, 6)
# sem usar itemgetter - para cada número que tem no dado, ver quem tirou esse número - começando pelo 6 já que é o maior número e fazendo decréscimo - se encontrar um jogador que tirou esse número de dado, printar o nome e a posição dele #
for dado in range(6, 0, -1): --> número do dado
for key, value in registro.items(): --> ver quem tirou o número do dado
if value == dado:
registro_ordenado[key] = value --> pra lançar/criar outro dic. mas na ordem correta
print(f' {pos + 1}º LUGAR - O {key} tirou {value} nos dados.')
pos += 1
# se eu printar registro_ordenado vai mostrar o dicionário na ordem correta...

[@andrerossi6026]

Fala, Gustavo!! Esse foi o primeiro exercício que tive dificuldade de verdade, pois por não conhecer esses comandos precisei dar uma volta enorme. Funcionou, mas tá com umas gambiarras.
from random import randint
from time import sleep
info = []
info_em_ordem = []
individual = {}
menor = 0
pos_menor = 0
maior = 0
pos_maior = 0
print('-'*31 + '
LET THE DICES BEGIN
'+ '-'*31)
for i in range(0, 4):
individual['jogador'] = f'Jogador {i+1}'
individual['resultado'] = randint(1, 6)
print(f' {individual["jogador"]} tirou {individual["resultado"]}.')
sleep(0.5)
if i == 0:
menor = individual["resultado"]
maior = individual["resultado"]
else:
if individual["resultado"] < menor:
menor = individual["resultado"]
pos_menor = i
if individual["resultado"] > maior:
maior = individual["resultado"]
pos_maior = i
info.append(individual.copy())
individual.clear()
print('-'*31)
intermediario1 = 0
intermediario2 = 0
for i in range(0, 4):
if i != pos_maior and i != pos_menor:
if intermediario1 == 0:
intermediario1 = i
else:
intermediario2 = i
info_em_ordem.append(info[pos_maior])
if info[intermediario1]['resultado']

[@RodrigoSilva-pj1hv]

Guanabara é o melhor professor do mundo

[@franciscotadeupezzi3431]

Obrigado! Esse sai a primeira parte ! Mas a Desistir nunca, principalmente com o apoio do Guanabara! Obrigado!
from random import randint
rodada = dict()
print('-='*3,'Valores sorteados','-='*3)
for c in range (1, 5):
rodada[f'jogador{c}'] = randint(1,6)
for k, v in rodada.items():
print(f' O {k} tirou {v}')
print(rodada)

[@ABCDEF-qx8iw]

FINALMENTE CONSeGUI DPS DE UM DIA INTEIRO. DICA: qnd vc travar numa etapa
e ficar mais de 5 min tentando, REFACA tudo de novo, dai vc vai vendo parte
por parte e novas solucoes e ideais certamente vao sugir enquanto vc faz.
a parte mais legal de tudo eh que no final eu consegui fzer com mais de uma maneira diferente
from random import randint
from time import sleep
listaordenada = []
for i in range(0, 4):
jogadas = {'numjogador': i, 'jogada': randint(0, 10)}
if i == 0:
listaordenada.append(jogadas)
print(f'jogador{i} tirou {jogadas["jogada"]}')
sleep(1)
elif jogadas['jogada'] < listaordenada[-1]['jogada']:
listaordenada.append(jogadas)
print(f'jogador{i} tirou {jogadas["jogada"]}')
sleep(1)
else:
for pos, d in enumerate(listaordenada):
if jogadas['jogada'] > d['jogada']:
listaordenada.insert(pos, jogadas)
print(f'jogador{i} tirou {jogadas["jogada"]}')
sleep(1)
break
print('=-'*20)
sleep(1)
print('====== RANKING =======')
sleep(1)
for v, c in enumerate(listaordenada):
print(f'{v+1} LUGAR: jogador{c["numjogador"]} com valor {c["jogada"]} ')
sleep(1)

[@MarcosAntonio-rb8or]

Pq tu fez com lista mano?

[@lucasb.1941]

Resolução boa, mas era com dicionário ;)

[@tijolinhostt1529]

nao era com lista irmao kkkkkkkkkkk dicionario !, se fosse pra fazer com lista eu fazia em 5 minutos

[@coisasbostas1648]

@@tijolinhostt1529 Né kkkkkk

[@allanmessiasdecoelho6039]

Muito bom mano! Não sei se você sabe disso, mas você utilizou um dos algoritmos de ordenação de dados, nesse seu caso acredito ser o Selection Sort.
Apesar da proposta do exercício não ter sido com essa resolução, foi muito boa.

[@santiagofilipe5115]

Quando fiz, criei uma lista onde armazenei todos os valores.

[@LucasKetelhut]

caramba Guanabara como que eu ia chegar nesse sorted gigante ai sem vc explicar na aula kkkkk pra resolver esse ex completo só vendo a resolução mesmo

[@maikyrayan]

Confesso que a logica sobre a ordem crescente me pegou kkkk mas tem uns 15 dias q nao pratico, fiz umas coisas diferentes mas vale o aprendizado, segue:
import random
from time import sleep
from operator import itemgetter
jogo = {}
print('Valores Sorteados:')
ranking = ()
for c in range(1,5):
x = random.randint(1,6)
jogo [f'Jogador{c}'] = x
for k, v in jogo.items(): #função de enumeratte para cada indice ira mostrar o seu valor
print(f'O {k} tirou {v}')
sleep(1)
ranking = sorted(jogo.items(), key=itemgetter(1), reverse=True) #instruções para colocar em ordem crescente um dicionario dentro de uma lista, é necessaio criar uma lista primeiro
print(f"{' RANKING ':X^20}")
for i, v in enumerate(ranking):
print(f' {i+1}º lugar: {v[0]} com {v[1]}')
sleep(1)

[@mekyleibelchior5624]

"""
Crie um programa onde 4 jogadores joguem um dado e tenham resultados aleatórios.
Guarde esses resultados em um dicionário em Python. No final, coloque esse dicionário em ordem, sabendo que
o vencedor tirou o maior número no dado.
"""
from random import randint
from time import sleep
jogadores = {}
p = 1
print()
for i in range(0, 4):
dado = int(randint(1, 6))
jogadores[i + 1] = dado
for i in range(1, 5):
print(f'O jogador {i} tirou {jogadores[i]} no dado.')
sleep(0.8)
print()
print(f'{"*"*10} {" RANK DOS JOGADORES ":^20} {"*"*10}', '
')
for i in sorted(jogadores, key=jogadores.get, reverse=True):
print(f'{p}º lugar: Jogador ({i}) com: {jogadores[i]}')
p += 1

[@lari.2909]

Fiz usando o .get tbm!!!

[@guilhermeboas5518]

muito bom ver que agora eu que estou procurando automatizar os codigos, para colocar os jogadores no dicionario eu utilizei a estruta for como ta abaixo e não coloquei um de cada vez:
jogador = dict()
for c in range(0,4):
jogador[f'jogador{c+1}']= randint(1,6)
assim se tivessem mais jogadores era somente alterar o range ao invés de digitar um por um

[@cra0cristal]

antes de ver a aula, eu tinha resolvido a parte de organizar os resultados da seguinte forma:
ranking = [(v, k) in k, v for jogo.items()]
ranking.sort(reverse=True)

[@rafaelmazza6288]

Você é brabo, Guanabara!

[@patrick_2099]

No caso de empate nos números, os jogadores ficam em posições diferentes. Fiz dessa forma pra que eles compartilhem a mesma posição em caso de empate:
from random import randint
from time import sleep
from operator import itemgetter
jogadores = {}
for j in range(0, 4):
jogadores[f'Jogador {j+1}'] = randint(1, 6)
for k, v in jogadores.items():
print(f'{k} tirou {v}')
sleep(0.5)
ranking = sorted(jogadores.items(), key=itemgetter(1), reverse=True)
print('='*30)
print(' ==RANKING==')
contador = 1
for x in range(0, len(ranking)):
if x == 0:
print(f' {contador}º - {ranking[x][0]} com {ranking[x][1]} pontos.')
elif ranking[x][1] == ranking[x - 1][1]:
print(f' {ranking[x][0]} com {ranking[x][1]} pontos.')
else:
contador += 1
print(f' {contador}º - {ranking[x][0]} com {ranking[x][1]} pontos.')

[@prizmincordik6768]

eu também fiz isto no meu código
from random import randint
from time import sleep
# código que faz os jogadores "jogar o dado"
jogadores = dict()
for c in range(1, int(input('quantos jogadores participarão? ')) + 1):
jogadores[c] = randint(1, 6)
print(f'o jogador {c} tirou {jogadores[c]} no dado')
sleep(0.75)
# código que pega a variável Jogadores e coloca na variável Ranking ordenado em ordem decrescente
ranking = {}
while len(jogadores) > 0:
maior = [0, 0]
for chave, valor in jogadores.items():
if valor > maior[1]:
maior = [chave, valor]
ranking[maior[0]] = maior[1]
del jogadores[maior[0]]
# código que coloca os jogadores que tiraram a mesma coisa no dado na mesma posição do Ranking
aparecido = list()
for chave, item in ranking.items():
novo = True
for item2 in range(0, len(aparecido)):
if item == aparecido[item2][0]:
novo = False
aparecido[item2][1].replace(' e',',')
aparecido[item2][1] += f' e {chave}'
break
if novo:
aparecido.append([item, str(chave)])
# código que transcreve oque temna variável Aparecido para a variável Ranking
ranking = dict()
for item3 in aparecido:
ranking[item3[1]] = item3[0]
#código que mostra o Ranking
print('Ranking: ')
posicao = 1
for chave, valor in ranking.items():
sleep(0.75)
print(f'{posicao}º lugar: {chave}: {valor} pontos')

[@dark.oliveira]

Fiz tudo na unha, pensei que era pra tentar fazer com as ferramentas entregue até agora, e que queria um dicionário ordenado no fim, mas valeu a pena, achei bem desafiador!
from random import randint
from time import sleep
jogadores = dict()
temp = list()
temp2 = dict()
dormir = 0.1
print("Valores Sorteados: ")
for j in range(1, 5):
sleep(dormir)
jogadores['Jogador' + str(j)] = randint(1, 6)
print(f"O Jogador{j} tirou {jogadores['Jogador' + str(j)]}")
temp = list(jogadores.copy())
desordenado = True
while desordenado:
desordenado = False
for e in range(0, 4):
for i in range(e+1, 4):
if jogadores[temp[e]] < jogadores[temp[i]]:
temp[e], temp[i] = temp[i], temp[e]
desordenado = True
for e in temp:
temp2.update({e: jogadores[e]})
jogadores.clear()
jogadores.update(temp2)
print("\tRanking jogadores: ")
cont = 0
for k, v in jogadores.items():
cont += 1
sleep(dormir)
print(f'\tO {cont}º', k, 'com', v)

[@inteligencianaoartificialb3349]

Falou q era pra fazer com dicionários, mas o: "ranking = sorted(nums.items(), key = itemgetter(1), reverse = True)" CRIA UMA LISTA

[@interagetech]

KKKKKKKKKKKKKKKKKK

[@thiagoestudante7227]

é foda kkkkkk

[@medroso1411]

Esse exercicio foi a punição de quem assiste a aula e pula os exercicios,esse exercicio sem esses detalhes explicados seria um inferno na Terra

[@fredsonchaves242]

Uma pequena dúvida.
Foi importado o itemgetter da biblioteca operator. Isso é exclusivo para ordenação de dicionários?

[@ajcs9574]

Exclusivo pra dicionários acho que sim. Pois não funciona em tuplas nem em listas, apesar de que se olhar no docs.python.org/3/library/operator.html é possível fazer isso de outras maneiras

[@stomperhk9107]

A key= apenas existe em dicionários... Então sim, pois não haveira sentido algum usar este itemgetter em listas ou tuplas.

[@capitão_paçoca]

@@stomperhk9107 Na verdade a key do sorted não é a mesma coisa que a key do dicionário

[@stomperhk9107]

@@capitão_paçoca Bem, eu não disse que a key do sorted é a mesma coisa que a key (índice) de dicionários.

[@capitão_paçoca]

@@stomperhk9107 Você disse que a key existe apenas em dicionários.

[@vivianeleite151]

Eu passei os valores da biblioteca para uma lista e ordenei ;)

[@EquipeZueiros]

Guanabara, vou ter q dizer uma coisa.
Vc tem o melhor canal de programação em python.

[@Khufos]

Rapaz esse exercício foi foda pra fazer.
from random import randint
from time import sleep
jogo = {}
jogos = []
cont = 0
raking = []
print('Valores sorteados:')
while cont < 4:
jogo['Jogador'] = randint(0, 6)
cont += 1
jogos = jogo
for k, v in jogos.items():
soma = v
print(f'{k} {cont} tirou {v} no dado')
sleep(1)
raking.append(v)
raking.sort(reverse=True)
print('-=' * 13)
print('== Ranking Dos Jogadores == ')
for pos, c in enumerate(raking):
print(f'{pos+1} Lugar: jogador com {c}')

[@giuliannarlau]

Não era o objetivo, mas achei mais fácil dando append de dicionário em uma lista final.
import random
jogada = {}
final = []
for i in range(4):
jogada['n_jogador'] = i+1
jogada['n_dados'] = random.randint(1, 6)
final.append(jogada.copy())
print(f"jogador{jogada['n_jogador']} tirou {jogada['n_dados']} nos dados")
print(30 * '-')
print(' == RANKING DOS JOGADORES ==')
final = sorted(final, key=lambda k: (k['n_dados']), reverse=True)
for j in final:
print(f" {final.index(j) + 1}º lugar: jogador {j['n_jogador']} com {j['n_dados']}")

[@norman6056]

Mesmo assistindo o video foi complicado execultar corretamente. passei horas procurando oque tava errado.
Isso porque fiquei um tempo sem praticar estava estudando html-5

[@antonioevangelistajunior7476]

Apenas 15 linhas:
from random import randint
from operator import itemgetter
from time import sleep
jogos = {}
print('Valores sorteados:')
for j in range(1, 5):
jogos[f'jogador{j}'] = randint(1, 6)
for k, v in jogos.items():
sleep(1)
print(f' O {k} tirou {v}')
podio = sorted(jogos.items(), key=itemgetter(1), reverse=True)
print('Ranking dos Jogadores:')
for i, v in enumerate(podio):
sleep(1)
print(f' {i+1}º lugar: {v[0]} com {v[1]}')

[@carnevalirog514]

eu usei esse cara aqui "ordplayers = sorted(players, key=players.get, reverse=True)" e não ´precisou importar nada.. hehehe... Granabara é o cara..

[@KarmaKula]

Tudo bem que o Guanabara quer ter view nos exercícios, mas dar um exercício com algo não ensinado fica difícil

[@Gabriel_Bento]

Sim, mas é possível fazer de outras formas =) Bons códigos

[@hvceaser9263]

quem quer aprender nao arruma desculpa. eu cheguei nessa aula nao sabia, ao inves de reclamar eu fui no google digitei como ordena um dicionario e aprendi facil e rapido. e no fim foi o mesmo metodo que o professor ia ensinar no video.

[@gle613]

Nossa Prof: Guanabara, esse deu trabalho mas consegui de duas formas depois de tanto pesquisar após fazer, fiz de duas maneira.
Uma só usando o seus ensinamentos e outra usando biblioteca itemgetter.
Com seus ensinamentos ficou assim:
from random import randint
from time import sleep
jogador = dict()
listaTemporaria = list()
rank = list()
print('Valores sorteados:')
for i in range(1, 5):
sleep(0.5)
jogador["jogador"] = str(f'jogador{i}')
jogador["dados"] = randint(1, 6)
print(f' {jogador["jogador"]} tirou {jogador["dados"]} no dado.')
listaTemporaria.append(jogador.copy())
print('Ranking com os jogadores:')
sleep(0.5)
# ordenar rank
for c in range(0, len(listaTemporaria)):
if (c == 0) or (listaTemporaria[c]["dados"] rank[cont]["dados"]:
rank.insert(cont, listaTemporaria[c])
break
cont += 1
# Imprime
for c in range(0, len(rank)):
sleep(0.5)
print(f' {c+1}º lugar: {rank[c]["jogador"]} com {rank[c]["dados"]}')
Usando biblioteca que vc não explicou ficou assim, e consegui aprimorar mais o programa:
from random import randint
from operator import itemgetter
from time import sleep
jogador = dict()
print('Valores sorteados:')
for c in range(1, 5):
jogador[f'jogador{c}'] = randint(1, 6)
for k, v in jogador.items():
sleep(0.5)
print(f' O {k} tirou: {v}')
rank = sorted(jogador.items(), key=itemgetter(1), reverse=True)
print('Ranking com os jogadores:')
for k, v in enumerate(rank):
sleep(0.5)
print(f' {k+1}º lugar: {v[0]} com {v[1]}')

[@uKaigo]

No key, eu coloquei "key=lambda x: x[1]"

[@marco.nascimento]

Excelente, valeu pela dica! Assim não precisa importar biblioteca

Oi amigo, lembra? Fui banido do Ladonegro '-'

[@velezsilva1]

Muito boa aula a única falha foi a não explicação sobre o itemgetter, eu entendo que esse curso tem um foco voltado principalmente para alunos iniciantes em programação, sendo assim, acredito que esse item deveria ter sido explicado, quem não é programador e está iniciando agora, muitos ficaram sem entender .

[@thales6790]

Não entendi nada a função do itemgetter. Acho justo colocar coisas que ainda não vimos, mas poderia ter uma explicação melhor para a gente aprender a usar, senão vira copiar código.

[@fredsonchaves242]

Concordo com você. A aula ta bacana, se tivesse uma explicação um pouco melhor desta biblioteca e aonde aplicar, ficava show!

[@maverickvortex]

Pesquise, jovem. Essa é ideia... seja curioso!

[@caetanopassos7346]

VC ME SALVA CARA, MEU MAIOR PROBLEMA DE CIÊNCIA DA COMPUTAÇÃO SKSK

[@zonamansa]

eu tentei fzr sem ver o resultado e consegui, porém de um jeito diferente, deu nisso
from random import randint
maior = '', 0
ordem = [{}, {}, {}, {}]
players = {'jogador 1': 0, 'jogador 2': 0, 'jogador 3': 0, 'jogador 4': 0}
for c in range(1, 5):
players[f'jogador {c}'] = randint(1, 6)
print(players)
for c in range(0, 4):
for l, i in players.items():
if l == 'jogador 1':
maior = 'jogador 1', i
elif i > maior[1]:
maior = l, i
ordem[c] = maior
players.__delitem__(maior[0])
maior = '', 0
print(maior)
print(ordem)
lugar = 0
for l in ordem:
lugar += 1
print(f'o número do {l[0]} é {l[1]}, e ele esta em {lugar}° lugar')

[@j10fdeveloper19]

melhor professor, ensina por que sabe

[@robsonferreirapecis9084]

Sinceramente não consegui ordenar o dicionário, dai pesquisei na internet e encontrei o itemgetter, porem não estava conseguindo entender a explicações de como ele funcionava. Fiquei um pouco frustrado por não conseguir achar uma solução e fiquei até achando errado da parte do Guanabara passar um exercício teoricamente impossível de resolver sem ver o vídeo de resolução, mas entendo o porque fazer isso.
Por conta disso, vou postar só a parte de sortear os números, que ficou totalmente diferente da do Guanabara(o restante ficou igual porque fiz baseado no vídeo):
from random import randint
from time import sleep
jogador = {}
print('Valores Sorteados')
for c in range(1, 5):
jogador[f'Jogador{c}'] = randint(1, 6)
for k, v in jogador.items():
sleep(1)
print(f' O {k} tirou o valor {v}')

[@maathmatics]

Não consegui fazer a segunda parte do RANKING tbm

[@rogeffersonmatheus]

Consegui fazer de primeira na raça, felizão ehueheu! Fui descobrir o itemgetter pesquisar por site e outros canais. Acabou que isso mesmo que o professor usou ahahha
from random import randint
from operator import itemgetter
dado = {}
colocação = 1
for c in range(0,1):
dado['jogador1'] = randint(1,6)
dado['jogador2'] = randint(1,6)
dado['jogador3'] = randint(1,6)
dado['jogador4'] = randint(1,6)
print('Valores Sorteados')
for k,v in dado.items():
print(f'{k} tirou {v} no dado.')
print('-='*30)
print(f"=Ranking dos jogadores=")
val = sorted(dado.items(),key=itemgetter(1),reverse=True)
#print(val)
for c in range(0,4):
print(f'{colocação}° lugar: {val[c][0]} com {val[c][1]}. ')
colocação += 1

[@capoarthur]

Explicar função nova que é elementar para fazer o exercício na resolução é sacanagem. Ensina antes!!

[@sanjuro787]

Acho que faz parte do processo de programar vc se consultar pela internet e aprender a consultar foruns como stack overflow,acho que foi essa a intenção do guanabara

[@sanjuro787]

Em um dos primeiros exercicios ele faz isso com o int,eu fiquei maluco tentando achar a solução,ai quando fui ver ele nem explicoukkkkkkkkkkkkkk

[@eduardopinheiro5492]

Muito Obrigado, pela aula

[@STCamposDaniel]

Achei uma sacanagem passar um exercício onde não é possível fazer com o conteúdo da aula, mas enfim. Fiz mesmo assim sem saber dessa biblioteca ae que tu escondeu. Segue a gambiarra, mas funciona PERFEITAMENTE!
from random import randint
lugar=0
jogadores={}
from time import sleep
jogadores = {}
print('=====Valores Sorteados:')
for i in range(1, 5):
jogadores['Jogador {}'.format(i)] = randint(1, 6)
print(' Jogador {} jogou o dado e obteve o valor: {}'.format(i,jogadores['Jogador {}'.format(i)]))
sleep(1)
print('='*40)
for i in range(1, 5):
if jogadores['Jogador 1'] >= jogadores['Jogador 2'] and jogadores['Jogador 1'] >= jogadores['Jogador 3'] and jogadores['Jogador 1'] >= jogadores['Jogador 4'] and jogadores['Jogador 1'] != 0:
lugar+=1
print('Jogador 1 ficou em {}° lugar com {} no dado'.format(lugar,jogadores['Jogador 1']))
jogadores['Jogador 1']=0
if jogadores['Jogador 2'] >= jogadores['Jogador 1'] and jogadores['Jogador 2'] >= jogadores['Jogador 3'] and jogadores['Jogador 2'] >= jogadores['Jogador 4'] and jogadores['Jogador 2'] != 0:
lugar+=1
print('Jogador 2 ficou em {}° lugar com {} no dado'.format(lugar,jogadores['Jogador 2']))
jogadores['Jogador 2']=0
if jogadores['Jogador 3'] >= jogadores['Jogador 1'] and jogadores['Jogador 3'] >= jogadores['Jogador 2'] and jogadores['Jogador 3'] >= jogadores['Jogador 4'] and jogadores['Jogador 3'] != 0:
lugar+=1
print('Jogador 3 ficou em {}° lugar com {} no dado'.format(lugar,jogadores['Jogador 3']))
jogadores['Jogador 3']=0
if jogadores['Jogador 4'] >= jogadores['Jogador 1'] and jogadores['Jogador 4'] >= jogadores['Jogador 3'] and jogadores['Jogador 4'] >= jogadores['Jogador 2'] and jogadores['Jogador 4'] != 0:
lugar+=1
print('Jogador 4 ficou em {}° lugar com {} no dado'.format(lugar,jogadores['Jogador 4']))
jogadores['Jogador 4']=0

[@humilde3949]

Minha resolução que fiz usando um for para adicionar os 4 jogadores que gerou menos linhas no final
#Exercício Python 091: Crie um programa onde 4 jogadores joguem um dado
#tenham resultados aleatórios. Guarde esses resultados em um dicionário em Python.
#No final, coloque esse dicionário em ordem, sabendo que o vencedor tirou o maior número no dado.
from random import randint
from time import sleep
from operator import itemgetter
jogadores = {}
print("Valores sorteado...")
for cont in range(1,5):
dado = randint(1,6)
print(f"Jogador {cont} tirou {dado} no dado")
jogadores[f"Jogador {cont}"] = dado
sleep(2)
ranking = sorted(jogadores.items(), key=itemgetter(1),reverse=True)
print("="*30)
print("RESULTADO FINAL")
for indice, valores in enumerate(ranking):
print(f"{indice + 1}º Lugar: {valores[0]} com {valores[1]}")

[@simonscabello]

nao é exatamente igual ao exercicio mas ficou bem bacana. :)
from random import randint
from time import sleep
valores = dict()
dado = {}
maior = menor = 0
vencedor = perdedor = ''
for c in range(1, 5):
dado["Nome"] = str(input(f'Nome do {c}º jogador: '))
dado["Jogada"] = randint(1, 6)
print(f'Jogando o dado...')
sleep(0.5)
if c == 1:
maior = dado["Jogada"]
menor = dado["Jogada"]
vencedor = dado["Nome"]
else:
if dado["Jogada"] > maior:
maior = dado["Jogada"]
vencedor = dado["Nome"]
elif dado["Jogada"] < menor:
menor = dado["Jogada"]
perdedor = dado["Nome"]
print(f"O vencedor foi {vencedor} tirando o valor {maior} na jogada.
"
f"O menor valor tirado foi de {perdedor} tirando o valor {menor}.")

[@narcizinhorobertinho21]

Otima aula !!

[@guilhermefrancadeoliveira7725]

Compartilhando minha solução
from random import randint
from time import sleep
jogadores = {}
for n in range(1, 5):
jogadores['jogador ' + str(n)] = randint(1, 12)
sleep(1)
print(f'Jogador {n} jogou o dado e obteve o valor: {jogadores["jogador " + str(n)]}')
print(f'Vamos para os resultados...

{"Resultados":~^40}
')
z = 0
for c, n in enumerate(sorted(jogadores.values(), reverse=True)):
for r in jogadores.keys():
if z == n:
break
if jogadores[r] == n:
print(f'O {r} ficou em {c + 1}º lugar')
sleep(0.5)
z = n

[@blackbrouli7369]

Bom pelo que entendi, vc transferiu o dicionario para uma lista, pra ordenar pela lista, e usando o sorted pra botar a lista em ordem, e o que parece esse key=itemgetter é feito pra pegar o valor (no caso os numeros) como principal para o sorted ordenar pelo valor pego por ele,,, e por ultimo fez o reverse=True: pra ja pegar ordenado do maior. Realmente muito inteligente, esse tipo de coisa só é pensado com experiencia mesmo,....
(Fiz certinho.. porem os jogadores fiz em um for, eu ia fazer o resto na unha também porém existe essas facilidades com essas bibliotecas...)
from random import randint
from time import sleep
from operator import itemgetter
grupo = {}
lista = []
for i in range(1, 5):
grupo[f'jogador{i}'] = randint(1, 6)
print('Valores sorteados:')
for k, i in grupo.items():
print(f'O {k} tirou {i} no dado.')
sleep(1)
print('-='*30)
lista = sorted(grupo.items(), key=itemgetter(1), reverse=True)
print(f'{"RANKING":^20}')
for i, v in enumerate(lista):
print(f'{i+1} lugar: {v[0]} com {v[1]}. ')
sleep(1)

[@emanoeldelfino7054]

Minha solução com compreensão de dicionários, usando expressão lambda, perguntando nome dos jogadores e com posições iguais para pontuações iguais no dado:
from random import randint
from time import sleep
jogadores = {input(f'
Nome do jogador {i}: ').capitalize(): randint(1, 6) for i in range(1, 5)}
for k, v in jogadores.items():
sleep(1), print(f'
{k} tirou {v}.'), sleep(1)
ranking = sorted(jogadores.items(), key=lambda item: item[1], reverse=True)
print(), print('-' * 32)
print(f'| {"Ranking dos jogadores":^28} |')
print('-' * 32)
print(f'| Posição | Jogador | Pontos |')
print('-' * 32)
posicao = 1
for num in range(len(ranking)):
if num == 0 or ranking[num][1] == ranking[num - 1][1]:
print(f'| {str(posicao) + "º":^7} | {ranking[num][0]:^9} | {ranking[num][1]:^6} |')
else:
posicao += 1
print(f'| {str(posicao) + "º":^7} | {ranking[num][0]:^9} | {ranking[num][1]:^6} |')
print('-' * 32)
Para quem tiver maior interesse fiz um repositório com todos arquivos de exercícios e aulas que fiz até agora: github.com/emanoeldelfino/pycev

[@italomachado4903]

Legal, só não entendi direito essa linha de código:
if num == 0 or ranking[num][1] == ranking[num - 1][1]:
o if, está verificando se a=a posição 0 da lista é igual a posição 3, certo?
Alguém sabe explicar como a comparação do primeiro valor da lista, está sendo comparado com o segundo valor?

[@linux_jeff]

Bom vídeo. 🙂

[@Viles-]

Eu queria entender o pq de alguém marcar como "Fácil" um exercício que tem como base fundamental um operador que o professor não passou em aula, mas o cara vai lá e diz que foi fácil; ou você já sabia, ou viu no Google ou ESSA PORRA FOI DIFÍCIL, que dificuldade em assumir.

[@prizmincordik6768]

para mim foi realmente fácil, eu consegui criar um método de ordenar sem importar bibliotecca nenhuma, ainda sim consegui criar um código que deixa as pessoa que tiraram a mesma coisa no dado ficar na mesma posição no ranking

[@moisesisraelmorielchagas]

Eu n sabia desse método mas eu consegui resolver por raciocínio lógico. Eu primeiro fiz um dicionário, depois copiei esse dicionário pra uma lista e usei a função ".sort(reverse=True)" depois eu apaguei o dicionário e criei um dicionário na ordem da lista reversa.

[@certsolution]

Criei um laço para não precisar digitar muitas linhas (se fosse o caso) e funcionou beleza.
dic = {}
for c in range(1,5):
dic[f'jogador {c}'] = randint(1,6)
----------

[@marcelo_toller]

Muito bom, obrigado!

[@marco.nascimento]

Exercício bem legal

[@pedroluizsouzapinto1980]

não sabia desse itemgetter, fiz na base do for mesmo e saiu o resultado final igualzinho kkkk

[@tiagooliveira7596]

# Crie um programa onde 4 jogadores joguem um dado e tenham resultados aleatórios. Guarde esses resultados em um dicionário. No final, coloque esse dicionário em ordem, sabendo que o vencedor tirou o maior número no dado;
from random import randint
from time import sleep
jogador = dict()
resultado = list()
for k in range(1, 5):
jogador['nome'] = input(f'Informe o nome do {k}º jogador: ').strip()
jogador['dado'] = randint(1, 6)
print(f'O jogador {jogador["nome"]} tirou {jogador["dado"]}')
resultado.append(jogador.copy())
for cont in range(0, len(resultado) - 1):
for cont2 in range(cont, len(resultado)):
if cont == cont2:
continue
elif resultado[cont]['dado'] < resultado[cont2]['dado']:
temp = resultado[cont].copy()
resultado[cont] = resultado[cont2].copy()
resultado[cont2] = temp.copy()
print(f'Os resultados foram...')
sleep(0.7)
for indice in range(0, len(resultado)):
print(f'{indice + 1}ª lugar ficou o jogador {resultado[indice]["nome"]} com {resultado[indice]["dado"]}')

[@filipefernandes777]

# Guarde esses resultados em um dicionário em Python.
# No final, coloque esse dicionário em ordem, sabendo que o vencedor tirou o maior número no dado.
from time import sleep
from random import randint
jogo = dict()
cont = 0
for player in range(1, 5):
jogo[f'Player {player}'] = randint(1, 6)
for k, v in jogo.items():
print(f'{k} tirou {v} no dado.')
print('='*30)
print('== RANKING DOS PLAYERS ==')
for i in sorted(jogo, key = jogo.get, reverse=True):
cont = cont + 1
sleep(0.5)
print(f'{cont}°Lugar: {i} com {jogo[i]}')

[@AngellBelger]

Tirando o sorted, que copiei do Guanaba, acho que minha solucao ficou um pouco mais bonita, pois eu gerei chaves personalizada através do for, sem ficar digitando(a vantagem de ser preguicoso, é que seu cérebro te forca a achar solucoes mais rápidas), consegui fazer isso por intuicao, deem uma olhada na linha 8. haha
obs:
(Suas aulas sao muito boa guana, gratidao por elas!)
from time import sleep
from random import randint
from operator import itemgetter
player = dict()
ranking = list()
print('{}Hello, world.{}'.format('\033[34m', '\033[m'))
for c in range(1, 5):
player[f'Player{c}'] = randint(1, 6)
for p, v in player.items():
sleep(1)
print(f'{p} = {v}')
ranking = sorted(player.items(), key=itemgetter(1), reverse=True)
print('-' * 40)
print(f'{"Ranking":^40}')
for k, v in enumerate(ranking):
print(f'{k + 1}˚ Lugar: {v[0]}. Valor nos dados: {v[1]}')
sleep()

[@lucasrodrigues6385]

exercício 091:
#### COMO EU TINHA FEITO:
'''
Crie um programa onde 4 jogadores joguem um dado e tenham resultados aleatórios.
Guarde esses resultados em um dicionário em Python.
No final, coloque esse dicionário em ordem, sabendo que o vencedor tirou o maior número no dado.
'''
from random import randint
from time import sleep
jogadores = {}
maiorNumero = 0
for jogador in range(1, 5):
jogadores[f'jogador{jogador}'] = randint(1, 6)
print('Valores sorteados: ')
for jogador, valor in jogadores.items():
print(f'{jogador} tirou {valor} no dado.')
if valor > maiorNumero:
maiorNumero = valor
sleep(1)
print('-='*30)
while maiorNumero != 0:
for indice in range(1, 5):
if jogadores[f'jogador{indice}'] == maiorNumero:
# se o valor for igual ao maior, o jogador é colocado no final da lista
# assim, os menores valores serão os últimos a serem realocados na lista
del jogadores[f'jogador{indice}']
jogadores[f'jogador{indice}'] = maiorNumero
maiorNumero -= 1
lugar = 1
print('RANKING DOS JOGADORES:')
for jogador, valor in jogadores.items():
print(f'\t- {lugar}º lugar: {jogador} com {valor}.')
lugar += 1
sleep(1)
### COMO FIZ COM OPERATOR ITEMGETTER()
'''
Crie um programa onde 4 jogadores joguem um dado e tenham resultados aleatórios.
Guarde esses resultados em um dicionário em Python.
No final, coloque esse dicionário em ordem, sabendo que o vencedor tirou o maior número no dado.
'''
from random import randint
from time import sleep
from operator import itemgetter
jogadores = {}
for jogador in range(1, 5):
jogadores[f'jogador{jogador}'] = randint(1, 6)
print('Valores sorteados:')
for key, value in jogadores.items():
print(f'{key} tirou {value} no dado.')
sleep(1)
ranking = sorted(jogadores.items(), key=itemgetter(1), reverse=True)
print('-='*30)
print('RANKING DOS JOGADORES: ')
for indice, jogador in enumerate(ranking):
print(f'\t- {indice+1}º lugar: {jogador[0]} com {jogador[1]}')
sleep(1)

[@melkbrandao5162]

Show!!

[@George-vh5vi]

from random import randint
from time import sleep
lista = []
lista_organizada = []
lista_organizada_jogador = []
cont = maior = 0
dicio = {'Jogador1': randint(1,6) , 'Jogador2' : randint(1,6),
'Jogador3' : randint(1,6),'Jogador4' : randint(1,6)} # 4 JOGADORES COM VALORES ALEÁTORIOS
lista.append(dicio.copy())
for x in lista:
for v,k in x.items():
if len(lista_organizada) == 0 or k > lista_organizada[-1]:
lista_organizada.append(k)
lista_organizada_jogador.append(v)
else:
for posi in range(len(lista_organizada)):
if k

[@icarodm]

Eu havia pensado só na primeira parte:
from random import randint
from time import sleep
jogo = dict()
for j in range(0, 4):
jogo[f'jogador{j+1}'] = randint(1, 6)
print('Valores sorteados:')
for k, v in jogo.items():
print(f'O {k} tirou {v} no dado.')
sleep(1)
Realmente travei na hora de ordenar. Pensei em jogar em lista, mas só ordenaria os resultados. Acho que sem importar a função lá do módulo, a solução deve dar bem mais linhas.

[@jeanctbra]

Acreditava que teria que ORDENAR EM UM NOVO DICIONÁRIO, quebrei bastante a cabeça para resolver da forma que tinha entendido. NA LÓGICA QUE FIZ:
-(1) eu faço o dicionario (achava que teria que fazer 2 key, assim usei 'Jogador' e 'Dado' no dicionário)
-(2) converto ela para lista com 4 listas dentro
-(3) ordeno as listas internas (considerando a ordem pelo valor sorteado)
-(4) por fim retorno um novo dicionário com a ordem do maior pro menor nos valores dos dados.
!!O codigo ficou bem grande usando o conhecimento que adiquiri ate o momento com o curso:
from random import randint
from time import sleep
jogos = dict()
resultado = list()
ordem = [[0, 0],[0, 0],[0, 0],[0, 0]]
c1 = c = 0
# Seleção dos dados em uma lista com varios dicionários
for i in range(1, 5):
cpu = randint(1, 6)
jogos['Jogador'] = i
jogos['Dado'] = cpu
resultado.append(jogos.copy())
# print resultados
for i in range(0, len(resultado)):
sleep(1)
for j in resultado[i].values():
if c == 0:
c += 1
print(f'O Jogador {j} tirou ', end = '')
else:
print(f'{j}', end = '')
c -= 1
print()
# Extração dos valores do dicionario em uma lista com 4 listas internas
for i in resultado:
for v in i.values():
if c1 == 0:
ordem[c][1] = v
c1 += 1
else:
ordem[c][0] = v
c1 -= 1
c += 1
# Ordenar as listas pelo maior valor do dado
ordem.sort(reverse = True)
resultado.clear()
jogos = dict()
# Criar uma lista com os dicionarios em ordem crescente de valor sorteado
for i in range(0, len(ordem)):
for j in range(len(ordem[0])-1, -1, -1):
if j == 0:
jogos['Dado'] = ordem[i][j]
elif j == 1:
jogos['Jogador'] = ordem[i][j]
resultado.append(jogos.copy())
# print ranking
print('Ranking de jogadores')
c = 0
for i in range(0, len(resultado)):
sleep(1)
for j in resultado[i].values():
if c == 0:
c += 1
print(f'O {i+1}º lugar: Jogador {j} tirou ', end = '')
else:
print(f'{j}', end = '')
c -= 1
print()

[@Ganymedes100]

Alô, mundo!!! Mestre GG, galera... saudações.
Este foi o primeiro exercício/desafio dos 91 que eu não consegui resolver. Em geral, as minhas soluções, como quem olha os comentários pode ver, não tem a ELEGÂNCIA, CLAREZA e OBJETIVIDADE daquelas criadas pelo Mestre GG.. nem eu tenho pretensões grandiosas assim, neste primeiro momento. Adorei o exercício, mas não consegui fazer... pesquisei a existência de métodos possíveis, encontrei o "sorted()", mas ninguém (pelo menos nos meus achados) referiu a importação da função "itemgetter()" do módulo "operator" com clareza. Assistindo a aula e tentando fazer, percebi logo que o dicionário, havia sido salvo numa lista, logo após fazer a "ordenação" e tentar montar o "for" para listar os resultados, porque a estrutura ordenada de saída NÃO ACEITOU o método "items()", que ficou sublinhado indicando o erro de sintaxe. Este exercício VALEU DEMAIS.... (dizem por aí, e eu acho correto, que "SE APRENDE MAIS COM OS ERROS DO QUE COM OS ACERTOS")
Abraços.... (abaixo, a minha solução, após assistir a explicação do Mestre GG sobre o exercício).
#Programa para simular Jogo de Dados entre 4 jogadores
from random import randint
from operator import itemgetter
from time import sleep
jogo = {'jogador1': randint(1,6),
'jogador2': randint(1,6),
'jogador3': randint(1,6),
'jogador4': randint(1,6)}
ranking = dict()
print('-'*40)
print(f'{"JOGO DE DADOS":^40}')
print('-'*40)
print(f'{" Valores Sorteados:"}')
print('-'*40)
for k, v in jogo.items():
print(f'{k} tirou {v} no dado.')
sleep(0.65)
ranking = sorted(jogo.items(),key=itemgetter(1),reverse=True)
print('-'*40)
print(f' Classificação da Partida:')
print('-'*40)
for k, v in enumerate(ranking): # aqui,
# ficou claro que o método "items()" não se aplicava mais a estrutura "ranking"
# criada na linha 09 como DICIONÁRIO (ranking = dict())
print(f' {k+1}° {ranking[k][0]} com {ranking[k][1]}.')
sleep(0.65)
print('-'*40)

[@lucasreis8590]

Top!!

[@diogoferreirafelipe3360]

Quem sabe ensinar é outra história... no começo eu não gostei desse lance de separar a aula da resolução do exercício, mas agora eu to vendo que é bem melhor mesmo, senão as aulas iam ficar gigantescas! Professor, se puder ter uma aula sobre a manipulação de tempo (as Bibliotecas DateTime, Calendar) acho que seria de grande valia para os alunos, pois é um tipo de dado bem importante. Eu leio os textos no site do Python, e até que são compreensíveis, mas tem coisas que não, por exemplo: eu queria pegar duas datas e saber, em anos, quanto tempo se passou, porém ao subtrair uma da outra é retornado um tipo TimeDelta, e eu não entendi nada no texto explicativo no site do Python.

[@lMatheusx]

#Não deu pra fazer o ranking
#091 4 Jogadores irão jogar um dado e ter resultados aleatórios.
#Guarde os resultando em um dic. No final, coloque o dic em ordem,
#sabendo que o vencedor tirou o maior número no dado. (De o a 4).
import random;
values = {'jogador1' : '', 'jogador2' : '', 'jogador3' : '', 'jogador4' : ''};
for i, k in values.items():
values[i] = random.randint(0, 4);
for i, k in values.items():
print(f'{i} has roll up {k} in the dice.');

[@CoderJr.]

Para quem está com dúvida em relação a como ordenar o dicionário pelos valores, de forma decrescente (e prática), tente usar o método sorted.
Exemplo:
for i in sorted(players, key = players.get, reverse = True):
print(i, players[i])
#troque players pelo nome da sua lista e veja que provavelmente retornará o que deseja

e para criar a seq de texto 1° lugar, 2° lugar... com o contador automatico dentro do sorted?

[@leviz4916]

Quero agradecer o mano que falou sobre a lambda :D
from random import randint
dados = {
1:[randint(1, 6)],
2:[randint(1, 6)],
3:[randint(1, 6)],
4:[randint(1, 6)],
}
for i, j in dados.items():
print(f'Jogador {i} tirou {j}')
print('-=' * 30)
# dict transforma os meus dados de volta em um dicionário. dados.items() retorna uma lista de keys e values para serem ordenados.
# key=lambda item: item[1] especifica que a ordenação deve ser feita com base nos values (item[1]) dos pares, caso seja com keys o item tem que ser (item[0]).
new_dados = dict(sorted(dados.items(), key=lambda item: item[1]))
k = 1
print(' == RANKING DOS JOGADORES == ')
for i, j in new_dados.items():
print(f'{k}° lugar: Jogador {i} com {j}.')
k += 1
new_dados = dict(sorted(dados.items(), key=lambda item: item[1], reverse=True))
k = 1
print(' == RANKING DOS JOGADORES REVERSE == ')
for i, j in new_dados.items():
print(f'{k}° lugar: Jogador {i} com {j}.')
k += 1

[@jeovaleite9301]

from random import randint # gerar numeros
from time import sleep #dar um tempo
from operator import itemgetter#colocar os dicionarios dentro das listas em ordem
print('De "enter" para poder começar')
rum = str(input(' ')) #para começar tem que ter um enter
print('ROLANDO OS DADOS...')
sleep(2)
#dicionario com os dados para cada jogador suas jogadas
jogo = {'Jogador1': randint(1, 6),
'Jogador2': randint(1, 6),
'Jogador3': randint(1, 6),
'Jogador4': randint(1, 6)}
#lista para depois colocar os dados do dicionario em ordem
ranking = list()
print(f'\033[1;31m-=-\033[m' * 20)
#coloca dados das chaves ordenados por valor de cada key
for k, v in jogo.items():
print(f'O {k} tirou o número: {v}')
sleep(2)
print(f'\033[1;31m-=-\033[m' * 20)
print(' RANKING DOS JOGADORES')
print(f'\033[1;31m-=-\033[m' * 20)
#Coloca o dicionario em uma lista ordenado do menor para o maior e depois reverte com o reverse=true, e usa a biblioteca para selecionar por qual valor deve ordenar
ranking = sorted(jogo.items(), key=itemgetter(1), reverse=True)
print(ranking)
#coloca os valores das listas por indices e valores printando eles na tela
for i, v in enumerate(ranking):
print(f'{i+1}° lugar {v[0]} com {v[1]}')
sleep(2)
print('FIM DE JOGO')

[@joelcioborges2570]

Guanabara, gostei muito desse desafio, tanto que resolvi fazer minha própria solução. Como eu não tinha a menor ideia de como se ordena um DICIONÁRIO coloquei todo ele em uma LISTA, pois com essa eu sei trabalhar, então, ordenei a e recoloquei em um DICIONÁRIO, foi bem legal e interessante eu achei relativamente fácil e essa foi minha solução:
# ORDENAÇÃO de um DICIONÁRIO
def layout1(n):
print('+ ' + '-' * n + ' +')
def layout2(ci, na):
print('| \033[1;{}m{:^90}\033[m'.format(ci, na), '|')
def layout3(ce, na2):
print(f'| \033[1;{ce}m{na2:

[@ericreis4708]

Vou precisar estudar mais o itemgetter, mas o restante ficou bem parecido

[@jean439]

Esse foi até que tranquilo... Fiz uma pesquisa rápida na internet e achei o comando 'itemgetter' da biblioteca 'operator'. Estudei como funcionava esse comando e apliquei ao meu código.
# Bibliotecas
from random import randint
from time import sleep
from operator import itemgetter
# Dicionário
jogadores = {'Player 1': randint(1, 6),
'Player 2': randint(1, 6),
'Player 3': randint(1, 6),
'Player 4': randint(1, 6)}
# Variáveis
seq = sorted(jogadores.items(), key=itemgetter(1), reverse=True)
cont = 1
# Solução
print('Valores sorteados:')
for k, v in jogadores.items():
print(f' O {k} jogou {v} ')
sleep(0.5)
print()
print('Ranking dos jogadores:')
sleep(0.5)
for k, v in seq:
print(f' {cont}º Lugar: {k} com {v}', end=' ')
cont += 1
sleep(0.5)
print()
print()
sleep(0.8)
print('>')

[@maurosantos3084]

Utilizei essa linha de código pra gerar os 4 números aleatórios e já nomeando os jogadores tbm
for cont in range(1, 6):
jogo[f'Jogador{cont}'] = randint(1, 6)

[@乙乙-z8v]

Além disso, você já poderia fazer o print e o sleep pra mostrar quanto cada jogador tirou na tela.

[@saxvilao]

parabéns.upper()

[@rodrigomarimon6576]

qual a explicação do dicionário ranking ter virado uma lista sem ser dado comando nenhum para isso??

[@mrcs99]

No 9:27 o resultado passa a ser tratado como lista por causa do sorted?

[@bryanhenriquecruzsouza8513]

Olá, Guanabara, tudo certo? Gostaria muito que o senhor ou sua equipe me tirasse uma dúvida que tenho a um bom tempo:
Por que vocês não disponibilizaram ainda todos os mundos do python no site,com a prova e o certificado? Há alguma burocracia por traz? Há alguma previsão?
Desde já agradeço. Sou muito fã do canal e do projeto em si.

[@Pablo-yg4ny]

# Exercício 091 - Jogo de Dados em Python
from random import randint
jogadores = {}
for i in range(4):
jogadores[f'Jogador {i+1}'] = randint(1, 6)
print('Valores sorteados:')
for j in jogadores:
print(f'{j} tirou {jogadores[j]} no dado.')
print(10 * '-=-')
ranking = dict(sorted(jogadores.items(), key=lambda i: i[1], reverse=True))
print(f'== RANKING DOS JOGADORES ==')
for i, j in enumerate(ranking):
print(f'{i+1}º lugar: {j} com {ranking[j]} pontos.')

[@marcoslima7477]

Eu fiz o dicionario principal, copiei para um temporario e limpei o principal, depois fiz um laço de 6 a 1 para comparar quem tirou cada valor, e a medida que ia tirando, ia acrescentando no meu dicionario principal a chave e o valor, de forma a por na ordem dos valores dos dados do maior para menor, sem usar a função ensinada na aula.
from random import randint
from time import sleep
jogadas = dict()
temp = dict()
for c in range(1,5):
jogadas[f'jogador{c}'] = randint(1,6)
print('Valores sorteados:')
for k, v in jogadas.items():
print(f' O {k} tirou {v}')
sleep(1)
temp = jogadas.copy()
jogadas.clear()
for c in range(6, 0, -1):
for k, v in temp.items():
if v == c:
jogadas[k] = v
rank = 1
print('Ranking dos jogadores: ')
for k, v in jogadas.items():
print(f' {rank}º lugar: {k} com {v}')
rank += 1
sleep(1)

[@feli31415]

boa

[@eullertavares1640]

Eu só vim aqui para fazer uma perguntinha mesmo hehe... Ainda estou na aula 03 de python.
Eu sempre pensei em ser programador, mas nunca tive aquela certeza.. Só comecei a pegar gosto pelo assunto quando comecei a fazer um curso onde comecei a estudar linguagem de programação (por enquanto é um pouco complicado), e mais para frente vou receber apostilas de java e visual basic. Eu queria saber se existe um roteiro para se estudar programação, sou novato no assunto e tenho apenas 16 anos? E qual curso da faculdade seguir para se aprofundar mais no assunto?
Desde já, agradeço por suas aula da linguagem python.. Aquele primeiro vídeo foi muito bom, me fez se interessar bastante por python.

[@bryanhenriquecruzsouza8513]

Olá, Euller. Tudo certo?
Tenho 19 anos e estudo programação faz um pouco mais de um ano. Eu aprendi muito com o Guanabara, tanto aqui no curso de python quanto de lógica, porém, se posso te dar uma dica, é que você tente pensar como programador, questione e tente fazer, tente resolver problemas básicos do seu dia a dia. Tipo, meu primo queria desenvolver um programa que sorteasse aleatoriamente quem organizaria as peças de um jogo no fim da partida, e com base nisso fomos desenvolver algo bem simples. A prática não vem apenas de exercícios pronto, mas também daquilo que tu desenvolve pra facilitar a SUA vida. Programar é facilitar vidas, então comece com a sua.

[@eullertavares1640]

vc está focando só no python por enquanto? tem algum material que vc pode indicar para se aprofundar mais no assunto? Logico, sem contar essas aulas maravilhosas do Guanabara.

[@bryanhenriquecruzsouza8513]

sim, tenho estado focado em python, mas ja estudei PHP, MySQL,HTML e C. eu costumo pesquisar e estudar o que preciso para resolver meus problemas diarios como forma de prática. tudo se resume em prática, amigo. se eu posso te dar mais uma dica, procure sites de competição de programação, como codewars e codesignal, pois eles ajudam muito, a unica desvantagem é que na maioria das vezes são em ingles.
Estudo mesmo nao tenho muito como te indicar, pois depende da area que tu quer aplicar o conhecimento. se quer ir pro ramo de games, procure criar interfaces graficas e interativas, se é web, entao procure HTML,CSS,JAVASCRIPT,PHP,SQL, o modulo DJANGO de python, etc.

[@eullertavares1640]

Primeiro vou focar no python.. Depois que estiver aprendido vou pesquisar outra area.. Mas o problema é como eu vou conseguir trabalhar com isso.

[@1977ecruz]

# Desafio 091
# Crie um algoritmo onde 4 jogadores joguem um dado e tenham resultados aleatórios.
# Guarde esses resultados em um dicionário. No final, coloque esse dicionário em ordem, sabendo q o vencedor tirou o maior número.
from random import randint
from time import sleep
from operator import itemgetter
play = {'1_Player': randint(1, 6),
'2_Player': randint(1, 6),
'3_Player': randint(1, 6),
'4_Player': randint(1, 6)}
ranking = []
print('Valores sorteados:
')
for k, v in play.items():
print(f'{k} sorteou {v} no dado.')
sleep(1)
ranking = sorted(play.items(), key=itemgetter(1), reverse=True)
print('
---------- RANKING DOS JOGADORES ----------
')
for i, v in enumerate(ranking):
print(f' - {i+1}º lugar: {v[0]} com {v[1]}.')
sleep(1)
# Valeu Guanabara!!!

[@Angelriva]

Adoro o curso e o prof Gustavo, de verdade gosto mesmo, já é o 2º curso que faço. Porém tem uns exercícios que a gente se quebra tentando resolver até que desiste e vê no vídeo da resolução do exercício o prof dizer que tem "coisa na resolução que ele não ensinou na aula e que a gente só iria conseguir resolver assistindo a resolução".... Foi nessa hora que eu pensei em largar tudo... Pensa no desânimo em ouvir isso.

[@coffeeAndCodes]

Guarda no dicionario e imprimi ao mesmo tempo:
for c in range(0, 4):
jogadores[f'jogador{c}'] = randint(1, 6)
print(f'jogador{c} tirou {jogadores[f"jogador{c}"]} no dado.')
sleep(0.3)

[@bgama18]

Guanabara.
Os exercícios servem para ver se nos conseguirmos escutar com o conteúdo passado em aula.
Se para completarmos o exercício é preciso ver a resposta dele. Perdemos a oportunidade de conseguir achar a resposta por nos mesmos.
Por diversas vezes fiquei bastante irritado por: tentar resolver o exercício, não ter conseguido, já com a sensação ruim de não ter conseguido resolver, ter que ver a resposta, e quando percebo, eu não tinha o conhecimento necessário para executa-lo. É extremante frustrante e desanimador!!!
Entendo que parte do projeto é financiado pelas visualizações dos vídeos. Pensando nisso pensei em algumas soluções:
1 - Criar um tag / indicação nos exercícios e no final da aula, que possam ser resolvidos apenas com o conteúdo mostrado até então. E uma segunda tag com exercidos com conteúdo adicional.
2 - deixar avido na apresentação dos exercidos no final das aulas, e no inicio dos exícios, se tem algum conteúdo estra nas aulas. (sei já faz isso, mas podia ser mais claro.)
3 - dar uma sugestão depois de um exercícios com conteúdo original depois de um exercício com conteúdo. Unitizando os mesmos princípios do primeiro.
Espero que use as minhas soluções para tentar resolver esse problema futuro, e veja o meu comentário com um feedback positivo!
🖖Vida longa e próspera ao Curso em Vídeo!🖖

[@ysraeloliveira1281]

Há algum comando no Python que, dado o valor, ele retorne com a respectiva chave?