Exercício Python

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

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

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

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

[@ideiasmarginais9534]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[@gregorihebert637]

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)

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

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

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

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

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

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

[@RodrigoSilva-pj1hv]

Guanabara é o melhor professor do mundo

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

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

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

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

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

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

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

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

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

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

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

[@EquipeZueiros]

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

[@rogeffersonmatheus2810]

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

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

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

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

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

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

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

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

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

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

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

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

[@alissondelimafarias4241]

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

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

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

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

[@gabrielyujiwakugawa64]

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

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

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

[@MrGuitarPE]

Na minha resolução eu só importei o random, e consegui fazer todo o resto. Segue abaixo:
import random
valores = {}
j = 0
for segue in range(4):
jogador = input("Digite seu nome: ")
valor = random.randint(1,6)
valores[jogador] = valor
print()
for k, v in valores.items():
print(f'{k} tirou {v} pontos.')
print()
for i in sorted(valores, key = valores.get, reverse = True ):
j += 1
print(f'{j} Lugar: {i} com {valores[i]} 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

[@Douglas-ji2yo]

Gostei muito da solução do guanabara, mas eu acabei fazendo com dois dicionários onde um tem uma key que é o jogador e uma value que é o numero, no segundo dicionario eu inverti esses items e coloquei uma key número e uma value jogador dai eu criei uma lista com os números sorteados e coloquei eles em uma ordem decrescente dai qnd foi a hr de printar os valores eu peguei a key do segundo dicionário que ia ser mostrado como jogador e peguei a key do primeiro dicionário que ia ser mostrado como o número, slg:
from random import randint
from time import sleep
jogo = dict()
jogador = dict()
ordem = []
print('Valores sorteados:')
for sorteio in range(1, 5):
jogo[f'jogador{sorteio}'] = randint(1, 6)
jogador[jogo[f'jogador{sorteio}']] = f'jogador{sorteio}'
print(f' O jogador{sorteio} tirou {jogo[f"jogador{sorteio}"]}')
ordem.append(jogo[f'jogador{sorteio}'])
sleep(1)
print('Ranking dos jogadores:')
ordem.sort(reverse=True)
for ranking in range(0, 4):
print(f' {ranking+1}º lugar: {jogador[ordem[ranking]]} com {ordem[ranking]}')
sleep(1)

[@Douglas-ji2yo]

Não acredito que meu código ficou certo pois ele ficou complicado de entender e tecnicamento eu não fiz o que guanabara pediu qnd ele falou pra eu ordenar o dicionario

[@eduardopinheiro5492]

Muito Obrigado, pela aula

[@narcizinhorobertinho21]

Otima aula !!

[@roxxteam2]

Fiz 'na mão' colocando em ordem decrescente na hora de adicionar na minha lista e ai só printar a lista em ordem... Também coloquei a opção de escolher a quantidade de jogadores.
#ex091
from random import randint
print("JOGO DE DADO - X JOGADORES - DICIONÁRIOS")
jogo = dict()
partida = []
while True:
jogadores = input("Qual o número de jogadores? ")
if jogadores.isdigit():
jogadores = int(jogadores)
if jogadores > 0:
break
else:
print("valor inválido, digite um valor válido")
for i in range(0, jogadores):
jogo["Nome"] = input("Digite o nome do jogador: ")
jogo["Dado"] = randint(1, 6)
pos = 0
while pos < len(partida) and partida[pos]["Dado"] > jogo["Dado"]:
pos += 1
partida.insert(pos, jogo.copy())
pos = 0
for posição in partida:
print(
f"O {pos+1}º colocado foi {partida[pos]['Nome']} com o número {partida[pos]['Dado']} nos dados!"
)
pos += 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..

[@rafaelmazza6288]

Você é brabo, Guanabara!

[@sanjuro787]

Não usei item getter e consegui o resultado apenas com o sort
from random import randint
count = 0
jogo = dict()
for c in range(4):
jogo[f"Jogador {c + 1}"] = randint(1, 6)
chaves = sorted(jogo.items())
for k, v in chaves:
print(f"{k} tirou {v}")
valores = sorted(jogo.items(), reverse=True)
for k, v in valores:
count = count + 1
print(f"Em {count}° lugar ficou o {k}")

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

[@jml1640]

Meu resultado ficou parecido com o do Prof. Guanabara. Mas, pesquisando sobre como ordenar uma lista (igual a lista "ranking" do vídeo), eu encontrei a função lambda que faz a mesma coisa que o itemgetter mas não precisa importar mais nada. Ficou assim:
from random import randint
from time import sleep
jog = {}
jog_lista = []
lista_ordem = []
print('-' * 30)
for c in range(1, 5):
jog[f'Jogador {c}'] = randint(1, 6)
for k,v in jog.items():
print(f'{k} tirou {v}')
sleep(1.5)
print('-' * 30)
print(f'{"RANKING:":^30}')
sleep(1.5)
# transforma o dicionário em lista com tuplas (cada tupla é um item do dicionário):
jog_lista = list(jog.items())
# ordena a lista (sorted) em ordem decrescente (reverse) usando o 2º elemento de cada tupla como parâmetro (lambda x:x[1]):
lista_ordem = sorted(jog_lista, key=lambda x:x[1], reverse=True)
for i, v in enumerate(lista_ordem):
print(f'{i + 1}º lugar => {v[0]} com {v[1]}')
sleep(1.5)
print()
print(f'{" PROGRAMA ENCERRADO ":=^30}')

[@ericreis4708]

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

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

[@pedroluizsouzapinto1980]

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

[@linux_jeff]

Bom vídeo. 🙂

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

[@marcusbr10]

Primeiramente: Parabéns, Guanabara e equipe!
Segundamente, segue solução diferente e sem usar "itemgetter":
from random import randint
from time import sleep
dicionario = {}
listav = []
for counter in range(1,5):
j = 'jogador'
v = randint(1,6)
dicionario[j+str(counter)] = v
listav.append(str(v)+str(counter))
print(dicionario)
listav.sort(reverse=True)
print(listav)
print('
Valores sorteados:
')
for j, v in dicionario.items():
print(f' O {j} tirou {v}')
sleep(1)
print('-='*30,'
=== Ranking dos jogadores ===')
for pos, item in enumerate(listav):
print(f' {pos+1}º lugar: jogador{item[1]} com {item[0]}.')

[@vivianeleite151]

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

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

[@valerioferreira808]

Quebrei a cabeça com loops (e usando o dicionário que o enunciado pedia), pro output ficar igual ao dele, e saiu assim:
#declarando as variáveis e importando randint:
from random import randint
dado = []
dicio = {}
novodicio = {}
controle = []
controle2 = []
#sorteando os valores dos dados (o range tá de 7 a 11 pq eu tinha tentado fazer outra parada, mas não tinha funcionado, deixei assim mesmo):
for i in range(7,11):
dado.append(randint(1,6))
print(f'O {i-6}º jogador tirou: {dado[i-7]}')
dicio[f'jogador{i-6}'] = dado[i-7]
controle.append(f'jogador{i-6}')
controle2.append(dado[i-7])
#um print() organizando aqui:
print('-'*51)
print(f"{'Resultados':^51}")
print('-'*51)
#aqui eu busquei interligar os itens de ambas as listas:
organ = []
while len(organ) < 5:
for a,b in zip(controle,controle2):
if b == max(controle2):
organ.append(a)
organ.append(b)
controle2.pop(controle2.index(b))
controle.pop(controle.index(a))
#aqui eu fiquei com preguiça de fazer mais um loop pro print(), e como a lista era pequena, fiz na mão mesmo.
print(f'O 1º colocado foi: {organ[0][0:7].capitalize()} {organ[0][7]} - Resultado do dado: {organ[1]}')
print(f'O 2º colocado foi: {organ[2][0:7].capitalize()} {organ[2][7]} - Resultado do dado: {organ[3]}')
print(f'O 3º colocado foi: {organ[4][0:7].capitalize()} {organ[4][7]} - Resultado do dado: {organ[5]}')
for d in controle:
if d not in organ:
print(f'O 4º colocado foi: {d[0:7].capitalize()} {d[7]} - Resultado do dado: {controle2[controle.index(d)]}')
print('-'*51)

[@lorenzobandinelli2638]

Olha, fiz assim antes de ver a resolução... Achei interessante o exercicio porque me fez usar diversas estruturas de repetição diferentes, e trabalhar com listas e dicionários de forma conjunta...
AHH e o código está na versão de teste, onde mostra informação que o programador precisa, mas os jogadores não....
from random import randint
from time import sleep
C = 0
j = {}
d = []
Md = []
for c in range (0,4):
j[f'jogador{c}'] = input(f'quem é o jogador{c+1}?')
d.append(randint(0, 6))
print('-='*30)
for c in range(0,4):
a = d[c]
print(f'{j[f"jogador{c}"]} tirou {a} na roleta')
sleep(1.6)
print('a tabela dos dados ->', d)
for p, v in enumerate(d):
if v == max(d):
print('a posição do maior valor é ->', p)
C += 1
Md.append(p)
print(f'C = {C}')
print('A tabela da posição dos maiores valores é ->', Md)
if C == 1:
print(f'o ganhador foi {j[f"jogador{Md[0]}"]} com {max(d)} pontos')
elif C == 2:
print(f'os jogadores {j[f"jogador{Md[0]}"]} e {j[f"jogador{Md[1]}"]} empataram com {max(d)} pontos')
elif C == 3:
print(f'Eita! os jogadores: {f"jogador{Md[0]}"}, {f"jogador{Md[1]}"} e {f"jogador{Md[2]}"} empataram com {max(d)} pontos')
elif C == 4:
print('UAU, todos empataram... qual a chance disso?')

[@lucasdecarvalho9883]

Meu programa ficou dessa forma:
import random
jogadores = dict()
cont = 1
for valor in range(0,4):
jogadores['jogador ' + str(valor+1)] = random.randint(1,6)
print('Ranking dos participantes:')
for i in sorted(jogadores, key = jogadores.get, reverse=True):
print(f'O {i} tirou {jogadores[i]} e terminou em {cont}°')
cont += 1

[@clarissebossler5921]

15 linhas: (coloquei um f' dentro do colchete que referencia a posição, e funcionou)
resultado = dict()
ranking = list()
from random import randint
from time import sleep
from operator import itemgetter
for c in range(1, 5):
resultado[f'jogador {c}'] = randint(1, 6)
for k, v in resultado.items():
print(f'O {k} tirou {v} no dado.')
sleep(1)
print('{:=^53}'.format('RANKING'))
ranking = sorted(resultado.items(), key=itemgetter(1), reverse=True)
for i, v in enumerate(ranking):
sleep(1)
print(f'O {i + 1}º colocado é o {v[0]}, com resultado {v[1]} no dado.')

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

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

[@melvinsantana2022]

Consegui fazer sem o uso do sorted e do "itemgetter". Achei que ficou muito omaneiro e serviu pra reforçar os meus conhecimentos de leitura de connteúdo numa lista. Vla Guanabara!
print('Exercise 91')
g0 = {}
c1 = 1
from random import randint
from time import sleep
for c in range (1,5):
n0 = randint(1,7)
g0[f'Player [{c}]'] = n0
for k, i in g0.items():
print(f'The {k} = {i}')
sleep(1)
for c in range(6, 0, -1):
for k, i in g0.items():
if i == c:
print(f'{c1}. {k} = {i}')
c1 += 1

[@caetanopassos7346]

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

[@guilherme10119]

Rapaz,esse foi difícil,em!Precisei apelar um pouco para lista,mas concluir sem ver o vídeo.Bati pra caramba a cabeça,pq eu tava indo para um caminho errado e percebi só depois de três dias😅.Pois bem,aqui está minha solução:
from random import randint
import time
jogadores = list()
valor = list()
rank = dict()
c4 = 0
print('Valores sorteados:')
print('===' * 20)
for c in range(0,4):
rank['jogador'] = c + 1
rank['dado'] = randint(1,6)
if rank['dado'] not in valor:
valor.append(rank['dado'])
time.sleep(0.8)
print(f'O jogador {rank["jogador"]} tirou:{rank["dado"]}')
jogadores.append(rank.copy())
valor.sort(reverse=True)
print('===' * 20)
print('Ranking dos jogadores:')
print('===' * 20)
for c2,lista in enumerate(valor):
for c3 in jogadores:
if c3['dado'] == valor[c2]:
c4 += 1
time.sleep(0.8)
print(f'O {c4} lugar ficou com o jogador {c3["jogador"]} com o dado de face {c3["dado"]}')

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

[@guilhermeguimaraes5113]

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

[@marcelo_toller]

Muito bom, obrigado!