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.

[@raventhul21]

*ATUALIZAÇÀO PYTHON 3.6+*
Para quem chegou aqui, meus parabéns. Após uma pesquisada vi que a partir da versão 3.6 fizeram uma atualização (implementada oficialmente no 3.7) na questão de importar o itemgetter. O jeito do Guanabara não é mais o recomendado.
O que você vai colocar de argumento no sorted é o seguinte:
sorted(nome_do_dicionario.items(), key=lambda item: item[1], reverse=True))
O `key=lambda item: item[1]' faz com o sort seja feito a partir dos valores que os jogadores obtiveram. Se quiser fazer com as chaves ao invés dos valores, use item[0]. Assim não precisar importar e fazer uso do itemgetter.
Abaixo vou adicionar meu código, que de certa forma ficou bem próximo do jeito que ele propôs também. Apenas automatizei com for o primeiro dicionário e transformei a lista do sorted em dicionário:
from random import randint
from time import sleep
jogos1 = {}
c = 1
for cont in range(1, 5):
jogada = randint(1, 6)
jogos1["jogador" + str(cont)] = jogada
print('Valores sorteados:')
for k, v in jogos1.items():
print(f'{k} tirou {v} no dado')
sleep(1)
print('-=' * 30)
print(f'{"== RANKING DOS JOGADORES ==":^30}')
jogos2 = dict(sorted(jogos1.items(), key=lambda item: item[1], reverse=True))
for k, v in jogos2.items():
print(f'{c}o. lugar: {k} com {v}.')
c +=1
sleep(1)

[@dudup]

Me ajudou irmão, obrigado !

[@matheusandreasa1679]

me ajudou muito, estava maluco tentando importar esse itemgetter kkkk

[@icarodm]

obrigado! Vou pesquisar mais sobre a função lambda após terminar de ver as aulas de funções do Guanabara.

[@gf9717]

Este método parece ainda mais simples e não cria uma lista.
from random import randint
game = {}
cont = 1
game['jogador1'] = randint(1,6)
game['jogador2'] = randint(1,6)
game['jogador3'] = randint(1,6)
game['jogador4'] = randint(1,6)
for k , v in game.items():
print(f'O {k} tirou {v}')
print('-='*30)
for i in sorted(game, key = game.get, reverse=True):
print(f'{cont}º lugar: {i} com {game[i]}')
cont += 1

[@feli31415]

vlw

[@ideiasmarginais9534]

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

[@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),}

[@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

[@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!!!

[@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

[@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)

[@cleitonoliver6409]

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.

[@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.

[@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 :)

[@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

[@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...

[@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)

[@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

[@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]} ')

[@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!

[@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

[@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.

[@guelliin]

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)

[@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)

[@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)

[@nelsonsoares2281]

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

[@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

[@RodrigoSilva-pj1hv]

Guanabara é o melhor professor do mundo

[@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)

[@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')

[@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']

[@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!!

[@vivianeleite151]

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

[@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

[@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

[@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}')

[@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

[@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 .

[@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

[@carnevalirog514]

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

[@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]}')

[@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

[@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

[@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)
----------

[@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!!!

[@caetanopassos7346]

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

[@EquipeZueiros]

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

[@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')

[@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.

[@capitaopacoca8454]

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

[@stomperhk9107]

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

[@capitaopacoca8454]

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

[@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

[@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}.")

[@pedroluizsouzapinto1980]

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

[@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 '-'

[@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()

[@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.

[@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

[@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?

[@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!

[@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]}')

[@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

[@fisico1815]

fiz duas soluções uma antes de conhecer o lambda e a outra já conhecendo, eu poderia fazer com itemgetter porém ocuparia mais linhas então resolvi fazer pela outra função
antes de conhecer o lambda.
from random import randint
from time import sleep
dicio = dict()
dic = dict()
lista = list()
for jogador in range(1, 5):
dado = randint(1, 6)
lista.append(dado)
dicio[f'jogador[ {jogador} ]'] = dado
sleep(0.5)
print(f'O jogador[ {jogador} ] tirou [ {dado} ] no dado.')
lista.sort()
lista.sort(reverse=True)
print('Ranking de jogadores:')
for pos, elemento in enumerate(lista):
for k, v in dicio.items():
if elemento == v:
sleep(0.5)
print(f'{pos + 1}° lugar: {k} com [ {elemento} ]')
dic[k] = elemento # esse dicionário armazena as chavez e os valores.
del dicio[k] # para não fazer uma chave ou identificador se repetir caso ouver dois números iguais.
break
depois de conhecer o lambda
from random import randint
from time import sleep
dicio = dict()
for pessoa in range(1, 5):
dicio[f'Jogador{pessoa}'] = randint(1, 6)
sleep(0.5), print(f'Jogador{pessoa} o seu dado teve {dicio[f'Jogador{pessoa}']}')
print('Ranking do jogadores:')
dic = sorted(dicio.items(), key = lambda num: num[1], reverse=True)
for pos, valor in enumerate(dic): sleep(0.5), print(f'{pos+1}° - {valor[0]} com {valor[1]}')

[@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')

[@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.

[@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

[@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

[@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.

[@rafaelmazza6288]

Você é brabo, Guanabara!

[@dawndao4740]

Com 8 linhas, e ainda da pra fazer com 7 linhas se eu ordenar no 'for' em vez separado
#091-Jogo de dados em python
import random
dicio={}
for cada in range(0, 4):
dicio[f'Jogador {cada+1}']=random.randint(1, 6)
print(f'{f"Jogador {cada+1}"} tirou {dicio[f"Jogador {cada+1}"]}')
ordenado=sorted(dicio.values(), reverse=True)
for cada, numeros in enumerate(ordenado):
print(f'{cada+1}° lugar: {f"Jogador {cada+1}"} com {numeros}')

[@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)

[@DeNevski]

O meu acabou ficando assim, acabei achando uma forma bem interessante de colocar em ordem decrescente.
from random import randint
from time import sleep
print('='*15)
print(f'{"JOGO DE DADOS"}')
print('='*15)
sleep(1)
game = {'Jogador1':randint(1, 6),
'Jogador2':randint(1,6),
'Jogador3':randint(1,6),
'Jogador4':randint(1,6)
}
for k, v in game.items():
print('Jogando...')
sleep(1.5)
print(f'O {k} jogou o número {v}')
print()
print('='*30)
print('===RANKING DE JOGADORES===')
print('='*30)
cont = 0
for i in sorted(game, key = game.get, reverse=True):
cont += 1
sleep(1)
print(f'{cont}º - {i} tirou o número {game[i]}')

[@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?

[@flaviofachetti3961]

Depois de muitas horas tentando, tive que ir buscar ajuda na internet, mas o resultado saiu :)
from random import randint
import operator
players = dict()
for i in range(0,4):
players[f"player{i}"] = [(randint(1,6))]
for valor in sorted(players, key=players.get):
print(valor, players[valor])
vencedor = max(players.items(), key=operator.itemgetter(1))[0]
print(f'O vencedor foi {vencedor}')

[@j10fdeveloper19]

melhor professor, ensina por que sabe

[@Guilherme-do1cq]

Olha esse exercício me pegou de um jeito, lá ele kkkk 😂, tinha uma função que eu nem sabia o que ela fazia, ai tive que parar para estudar e entender o que ela faz, e entender como que eu podia fazer e o melhor possível o script cheguei nessa conclusão .
from random import randint
from stringcolor import *
l = '-=' * 31
print(cs(f'{" DESAFIO 87 ":=^62}', 'cyan2'))
print(cs(f'
{l}', 'LightSalmon3'))
print(cs(f'{" Sorteador ":-^62}', 'LightSalmon3'))
print(cs(f'{l}
', 'LightSalmon3'))
podio = list()
jogadores = dict()
cont = 1
for n in range(1, 7):
jogadores[f'Jogador{n}'] = randint(1, 6)
for k, v in jogadores.items():
print(f'O {k} Tirou {v}')
print(' ==== Ranking de jogadores ==== ')
jogadores = dict(sorted(jogadores.items(), key = lambda n: n[1], reverse=True))
for k, v in jogadores.items():
print(f'{cont:>6} lugar: {k} com {v}')
cont += 1

[@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()

[@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.

[@rachel77248]

Início: 3:17

[@genesebarbosa]

...sem acreditar que consegui obter o resultado...agora é ver a mágica da aula : ), não dormiria hoje se não conseguisse...só com os ensinamentos dados nos mundos 1,2 e 3. Tudo que vi de programação até hoje na vida começou esse ano com o curso em vídeo.
from random import randint
from time import sleep
dicio=dict()
for c in range(0,4):#laço para lançar as jogadas
dicio['Jogador'+f' {c+1}']=randint(1,6)
for key, value in dicio.items():#laço para mostrar as jogadas
print(f'O {key} tirou {value} no dado.')
sleep(0.5)
lista=[]#lista para receber o dicionário
print(dicio)
valor=0#variavel transitoria para viabilizar a ordenação dos valores
chave=str()#variável transtória para viabilizar a ordenação dos jogadores com base na variável "VALOR"
for k,v in dicio.items():#lançar as chaves e valores em uma lista
lista.append(k)
lista.append(v)
for c in range(1,6,2):#varredura comparativa entre o primeiro valor e o seu sucessor
for v in range(c+2,8,2):#varredura do valor sucessor em relação ao laço anterior
if lista[v]>lista[c]:#se o valor na posicao 3 maior que o da posição 1
valor=lista[c]
chave=lista[c-1]
lista[c]=lista[v]
lista[c-1]=lista[v-1]
lista[v]=valor
lista[v-1]=chave
dicio.clear()
for c in range(0,8,2):
dicio[f'{lista[c]}']=lista[c+1]
print('-----------Ranking------------')
c=1
for k,v in (dicio.items()):
print(f'O {c}º Lugar: {k} com {v}')
sleep(0.5)
c+=1
if c>=5:
break

[@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)

[@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('>')

[@gleissonviolinista6273]

Eu conseguir usar outra função do Python, encontrei pesquisando para resolver esse problema:
Usei a função .get, e depois reverse=True. E em vez de ter que colocar jogador por jogar em um dicionario, resolvir colocar automatica usando o for. Assim diminui o codigo e ficou mais automatizado do que fazer manualmente.
Segue o Codigo:
from random import randint
from time import sleep
"""
jogadores = {}
print("Valores sorteados:")
for c in range(1,5):
jogadores[f'jogador {c}'] = randint(1,6)
print(f" O jagador {c} tirou {jogadores[f'jogador {c}']} no dado")
sleep(1)
print("
")
print("Ranking dos jogadores:")
for n, c in enumerate(sorted(jogadores, key= jogadores.get, reverse=True)):
print(f" {n+1}° lugar: {c} com {jogadores[c]}")
sleep(1)
"""

[@LTWalkthroughs5]

na parte do ranking eu gostei de fazer assim:
cont = 0
print("== RANKING DOS JOGADORES ==")
for j in sorted(jogo, key = jogo.get, reverse=True):
cont += 1
print(f" {cont}° {j}, {jogo[j]}")

[@linux_jeff]

Bom vídeo. 🙂

[@eduardopinheiro5492]

Muito Obrigado, pela aula

[@narcizinhorobertinho21]

Otima aula !!

[@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:

[@GabeShortsz]

analisando um pouco o problema antes de ver a correção, consegui resolver ele sem esse método novo (até porque eu nem conhecia). usei artificios já aprendidos antes no curso:
from random import randint
from time import sleep
jogadores = {'jogador 1': randint(1, 6),
'jogador 2': randint(1, 6),
'jogador 3': randint(1, 6),
'jogador 4': randint(1, 6)}
print('Valores sorteados: ')
for k, v in jogadores.items():
sleep(1)
print(f'O {k} tirou {v}')
print('=-'*15)
print('='*4, 'RANKING DE JOGADORES', '='*4)
print('=-'*15)
cont = 1
for p in range(6,0,-1):
for k, v in jogadores.items():
if v == p:
print(f'{cont}º lugar: {k} com {v}')
cont += 1

[@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

[@artursoda8994]

sem dúvidas, uns dos mais difíceis que já fiz:
from random import randint
lista = []
dic = {}
z = 0
print(f'{" JOGANDO O DADO ":~^40}')
dic['jogador'] = str(f'Jogador 1')
dic['dado'] = int(randint(1, 6))
print(f'O jogador 1 tirou {dic["dado"]}')
lista.append(dic.copy())
for c in range(2, 5):
dic['jogador'] = str(f'Jogador {c}')
dic['dado'] = int(randint(1, 6))
print(f'O jogador {c} tirou {dic["dado"]}')
while True:
if dic['dado'] < lista[0]['dado']:
lista.insert(0, dic.copy())
break
elif dic['dado'] > lista[len(lista) - 1]['dado']:
lista.insert(len(lista), dic.copy())
break
elif dic['dado'] == lista[z]['dado']:
lista.insert(z + 1, dic.copy())
break
elif lista[z]['dado'] < dic['dado'] < lista[z+1]['dado']:
lista.insert(z + 1, dic.copy())
break
z += 1
z = 0
z = 1
print('~'*40)
print(f'{"RANKING DOS JOGADORES":=^40}')
for c in range(3, -1, -1):
print(f'{z}° Lugar: {lista[c]["jogador"]} tirando {lista[c]["dado"]}')
z += 1

[@guilhermeguimaraes5113]

Uma ajuda pra quem está começando
-> Sem usar a biblioteca operador

[@lucastoledo5466]

Não conhecia essa função, e fiz da seguinte forma (Funcionou kkk):
from random import randint
from time import sleep
dados = {}
dados['jogador 1'] = randint(1, 6)
dados['jogador 2'] = randint(1, 6)
dados['jogador 3'] = randint(1, 6)
dados['jogador 4'] = randint(1, 6)
ordem = sorted(dados.values())
ordem.sort(reverse=True)
rank = []
for k, c in dados.items():
print(f'{k} tirou {c} no dado.')
for i, c in dados.items():
for d in range(0, 4):
if c == ordem[d]:
rank.insert(d, i)
break
print('-'*30)
print('===', 'RANKING DE JOGADORES', '===')
sleep(1)
for i, c in enumerate(rank):
print(f'{i+1}º Lugar: {c} com {ordem[i]}')
sleep(1)

[@unknownrobot]

Minha solução não tão enxuta como a do Guanabara, mas funciona. Pesquisei um pouco na documentação do python pra concluir esse exercício:
from random import randint
from time import sleep
jogadores = {'jogador1': randint(1, 6), 'jogador2': randint(1, 6), 'jogador3': randint(1, 6), 'jogador4': randint(1, 6)}
print('Valores sorteados:')
for k, v in jogadores.items():
print(f'{k} tirou {v} no dado')
sleep(1)
print('-=' * 30)
print('{:^33}'.format('== RANKING DOS JOGADORES =='))
lista = [(k, v) for (k, v) in jogadores.items()]
tupla = ()
maior = indice = 0
for i in range(0, 4):
for j in range(len(lista)):
if j == 0:
maior = lista[0][1]
indice = 0
else:
if lista[j][1] > maior:
maior = lista[j][1]
indice = j
elif lista[j][1] == maior:
continue
tupla += (lista[indice],)
del lista[indice]
jogadores = {tupla[0][0]: tupla[0][1], tupla[1][0]: tupla[1][1], tupla[2][0]: tupla[2][1], tupla[3][0]: tupla[3][1]}
cont = 1
for k, v in jogadores.items():
print(f'\t{cont}º lugar: {k} com {v}')
cont += 1
sleep(1)

[@stuartty100]

Minha solução ficou assim:
from random import randint
from time import sleep
resultados = dict()
print(f'Valores sorteados:')
for d in range(1, 5):
resultados[f'jogador{d}'] = randint(1, 6)
print(f' O jogador{d} tirou ', end='')
sleep(1)
print(resultados[f'jogador{d}'])
sleep(1)
print(f'Ranking dos jogadores:')
sleep(1)
count = 1
for i in sorted(resultados, key=resultados.get, reverse=True):
print(f' {count}º lugar: {i} com {resultados[i]}')
sleep(1)
count += 1

[@gabrielyujiwakugawa64]

diciorario = {}
for c in range(1, 5):
diciorario[f'jogador{c}'] = randint(1, 6)

[@gustatofolo6666]

Em 12 linhas:
from random import randint
prov = dict()
qtd = int(input('Quantidade de jogadores: '))
for c in range(0, qtd):
prov[f'Jogador {c + 1}'] = randint(1, 6)
for k, v in prov.items():
print(f'{k}: {v}')
print('RANKING')
cont = 0
for item in sorted(prov, key=prov.get, reverse=True):
print(f'{cont+1}° lugar: {item.lower()} com {prov[item]}')
cont += 1

[@victorgustavokeliscardoso8077]

Eu fiz de uma forma diferente, sem usar o itemgetter, mas ficou bem interessante.
from random import randint
from time import sleep
jogos = []
print('Os valores sorteados são:')
for i in range(1,5):
jogo = {'jogador': i, 'dado': randint(1,6)}
jogos.append(jogo)
print(f' {jogo}')
sleep(0.5)
print('Ranking dos jogadores:')
pos = 1
while len(jogos) != 0:
for i in range(0,len(jogos)):
if i == 0:
max = jogos[0]['dado']
jog = jogos[0]['jogador']
posição = i
elif jogos[i]['dado'] > max:
max = jogos[i]['dado']
jog = jogos[i]['jogador']
posição = i
sleep(0.5)
print(f' O {pos}º lugar: Jogador {jog} com {max}.')
pos += 1
del(jogos[posição])

[@misterney]

Achei um igual, kkkk, também fiz usando apenas o aprendizado atual, sem pesquisas. Quebrei um pouco a cabeça mas logo vou resultado Chegou

[@ericreis4708]

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

[@Marko499]

Fiz um implemento no desafio. No meu código os jogadores jogam os dados até que realmente alguém vença (se houver empate eles jogam de novo o dado). Não me importei com o número de linhas, inclusive adicionei varios sleeps pra ficar legal de assistir a disputa.
from random import randint
from operator import itemgetter
from time import sleep
max = 0
jogador = {'Marcio':randint(1,6),
'Marco':randint(1,6),
'Thalia':randint(1,6),
'Gustavo':randint(1,6)}
ranking = list()
winner = list()
ranking = sorted(jogador.items(), key=itemgetter(1),reverse=True)
print('JOGO DOS DADOS!')
sleep(2)
for c, v in enumerate(ranking):
print(f'{v[0]} tirou {v[1]}')
sleep(1)
if v[1] >= max:
max = v[1]
winner.append(ranking[c])
winner = [list(ele) for ele in winner] #transforma lista de tuplas em lista de listas
while winner[-1][1] < max:
winner.pop()
while len(winner) > 1:
print('Houve um empate entre: ',end="")
for c in range(0,len(winner)):
print(f'{winner[c][0]}...',end="")
sleep(2)
print("

Jogando Dados Novamente...")
sleep(2)
for c in range(0,len(winner)):
winner[c][1] = randint(1,6)
winner = sorted(winner, key=itemgetter(1),reverse=True)
max = 0
for c, v in enumerate(winner):
print(f'{v[0]} tirou {v[1]}')
sleep(1)
if v[1] >= max:
max = v[1]
while winner[-1][1] < max:
winner.pop()
sleep(1)
print('=*'*16)
print(f'{winner[0][0]} foi o vencedor. PARABÉNS!')
print('=*'*16)

[@marcelo_toller]

Muito bom, obrigado!

[@esdrika360]

Fiz diferente, mas vi que essa forma que fiz é a forma atualizada, eu confesso que pesquisei na internet como fazer pra ordenar um dicionário, já que o professor não tinha ensinado. Mas deu bom, aprendi da forma atualizada, quem quiser é esse aqui.
from random import randint
from time import sleep
jogadas = {}
print('Valores sorteados.')
for j in range(1, 5):
jogada = randint(1, 6)
jogadas[f'jogador {j}'] = jogada
sleep(1)
print(f'Jogador {j}: {jogadas[f"jogador {j}"]}')
count = 1
print('
Ranking dos jogadores.')
for v, n in sorted(jogadas.items(), key=lambda item: item[1], reverse=True):
sleep(0.5)
print(f'{count}º - {v} com {n} pontos.')
count += 1

[@dopplegang2986]

from random import randint
from time import sleep
dados = {}
for i in range (1, 6):
dados[f'Player {i}'] = randint(1, 6)
print(f'Player {i} tirou: {dados[f"Player {i}"]}')
sleep(.7)
#print(dados)
print(f'{"Ranking":-^30}')
for v in sorted(dados, key = dados.get, reverse=True):
print (f' - {v}: {dados[v]}')
sleep(.7)
print(f'{"FIM":-^30}')
Basicamente fiz isto (curso de 3 anos atrás, porém dá pra aproveitar tudo)