Exercício Python

แชร์
ฝัง
  • เผยแพร่เมื่อ 30 ต.ค. 2024

ความคิดเห็น • 922

  •  4 หลายเดือนก่อน +2

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

  • @raventhul21
    @raventhul21 2 ปีที่แล้ว +154

    *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
      @dudup 2 ปีที่แล้ว +2

      Me ajudou irmão, obrigado !

    • @matheusandreasa1679
      @matheusandreasa1679 ปีที่แล้ว +1

      me ajudou muito, estava maluco tentando importar esse itemgetter kkkk

    • @icarodm
      @icarodm ปีที่แล้ว +1

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

    • @gf9717
      @gf9717 ปีที่แล้ว +11

      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
      @feli31415 ปีที่แล้ว

      vlw

  • @RadioactiveGamesOficial
    @RadioactiveGamesOficial 6 ปีที่แล้ว +410

    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
      @MrDavidribeiro570 6 ปีที่แล้ว +1

      UP

    • @ricardopouza4198
      @ricardopouza4198 6 ปีที่แล้ว +2

      Na Udemy tem alguns cursos bons e e bem barato.

    • @TurokTurk
      @TurokTurk 6 ปีที่แล้ว +1

      UP

    • @herissonricardo-slackwareo450
      @herissonricardo-slackwareo450 6 ปีที่แล้ว +35

      @@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
      @halaintrabulsi7722 6 ปีที่แล้ว +2

      concordo plenamente.

  • @paulodosanjos7253
    @paulodosanjos7253 2 ปีที่แล้ว +58

    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
      @hydraxler5537 2 ปีที่แล้ว +3

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

    • @XDanRJ
      @XDanRJ 2 ปีที่แล้ว +1

      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
      @edicaokss488 2 ปีที่แล้ว +1

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

    • @paulodosanjos7253
      @paulodosanjos7253 2 ปีที่แล้ว +1

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

    • @steel9203
      @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
    @amandamendonca2494 3 ปีที่แล้ว +62

    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
      @interagetech 3 ปีที่แล้ว +2

      concordo 100%

    • @hydraxler5537
      @hydraxler5537 2 ปีที่แล้ว +3

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

  • @ideiasmarginais9534
    @ideiasmarginais9534 6 ปีที่แล้ว +53

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

  • @MusicaPoesia
    @MusicaPoesia 5 ปีที่แล้ว +44

    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
      @jml1640 4 ปีที่แล้ว

      Bacana!

    • @jezreelmoraes5864
      @jezreelmoraes5864 4 ปีที่แล้ว +8

      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_
      @finnzao_ 4 ปีที่แล้ว +3

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

    • @lucapohl-angel4618
      @lucapohl-angel4618 3 ปีที่แล้ว +3

      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
      @ianrl100 3 ปีที่แล้ว +1

      @@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
    @guilhermemenezes5398 3 ปีที่แล้ว +206

    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
      @alexandremoreira8776 3 ปีที่แล้ว +13

      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
      @thiagoestudante7227 2 ปีที่แล้ว +4

      sim faltou mesmo

    • @terrornaweb9739
      @terrornaweb9739 2 ปีที่แล้ว +2

      Sentir a mesma coisa :(

    • @thor_kryptonite1940
      @thor_kryptonite1940 2 ปีที่แล้ว +1

      tbm

    • @MonkeyDLuffy-xp5dg
      @MonkeyDLuffy-xp5dg 2 ปีที่แล้ว +16

      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
    @MatheusAzevedo-ni9vb 2 ปีที่แล้ว +7

    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
      @cleitonoliver6409 ปีที่แล้ว +2

      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
    @playerboxiptv8346 6 ปีที่แล้ว +79

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

    • @marco.nascimento
      @marco.nascimento 6 ปีที่แล้ว +4

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

    • @playerboxiptv8346
      @playerboxiptv8346 6 ปีที่แล้ว +3

      Quero aprender Machine Learning e Deep Learning =(

    • @jeanmichael2917
      @jeanmichael2917 5 ปีที่แล้ว +6

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

    • @DznSkips
      @DznSkips 4 ปีที่แล้ว

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

    • @igor_707
      @igor_707 2 ปีที่แล้ว

      O pyautogui é muito bom para automações

  • @aDDxDD
    @aDDxDD 4 ปีที่แล้ว +16

    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
      @lucianolopezdossantos 4 ปีที่แล้ว +1

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

    • @stomperhk9107
      @stomperhk9107 4 ปีที่แล้ว

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

    • @lucapohl-angel4618
      @lucapohl-angel4618 3 ปีที่แล้ว

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

  • @joaoneto1399
    @joaoneto1399 5 ปีที่แล้ว +12

    - 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
      @rodrigomarimon6576 ปีที่แล้ว

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

  • @ildebrandobastos7602
    @ildebrandobastos7602 10 หลายเดือนก่อน +1

    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
    @augustoalvesserpa1797 3 ปีที่แล้ว +5

    # 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
    @GustavoCosta-jr1mh 4 ปีที่แล้ว

    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
      @GustavoCosta-jr1mh 4 ปีที่แล้ว

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

  • @HawkNyon
    @HawkNyon 2 ปีที่แล้ว +3

    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
    @guilhermeboas5518 11 หลายเดือนก่อน +1

    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
    @Enzoerb 5 ปีที่แล้ว +44

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

    • @jeaninove1881
      @jeaninove1881 4 ปีที่แล้ว +3

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

    • @olokinhomewwww550
      @olokinhomewwww550 4 ปีที่แล้ว

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

    • @Enzoerb
      @Enzoerb 4 ปีที่แล้ว

      @@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
    @maikyrayan ปีที่แล้ว +1

    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
    @ABCDEF-qx8iw 4 ปีที่แล้ว +7

    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
      @MarcosAntonio-rb8or 4 ปีที่แล้ว

      Pq tu fez com lista mano?

    • @lucasb.1941
      @lucasb.1941 4 ปีที่แล้ว +2

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

    • @tijolinhostt1529
      @tijolinhostt1529 4 ปีที่แล้ว +1

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

    • @coisasbostas1648
      @coisasbostas1648 4 ปีที่แล้ว

      @@tijolinhostt1529 Né kkkkkk

    • @allanmessiasdecoelho6039
      @allanmessiasdecoelho6039 4 ปีที่แล้ว

      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
    @franciscotadeupezzi3431 4 ปีที่แล้ว +1

    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
    @patrick_2099 6 ปีที่แล้ว +28

    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
      @prizmincordik6768 5 ปีที่แล้ว +1

      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
    @nelsonsoares2281 5 ปีที่แล้ว +4

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

  • @rodrigoortega1092
    @rodrigoortega1092 6 ปีที่แล้ว +1

    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
    @giuliannarlau ปีที่แล้ว +8

    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
    @andrerossi6026 4 ปีที่แล้ว +1

    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
    @cra0cristal 6 ปีที่แล้ว +5

    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
    @velezsilva1 4 ปีที่แล้ว +2

    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
    @inteligencianaoartificialb3349 4 ปีที่แล้ว +14

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

  • @icarodm
    @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
    @julianacdo 2 ปีที่แล้ว +6

    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
    @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
    @LucasKetelhut 4 ปีที่แล้ว +4

    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
    @dark.oliveira 5 ปีที่แล้ว +2

    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
    @antonioevangelistajunior7476 4 ปีที่แล้ว +3

    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
    @norman6056 2 ปีที่แล้ว +1

    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
    @mekyleibelchior5624 5 ปีที่แล้ว +5

    """
    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
      @lari.2909 2 ปีที่แล้ว

      Fiz usando o .get tbm!!!

  • @gle613
    @gle613 4 ปีที่แล้ว

    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
    @RodrigoSilva-pj1hv 6 ปีที่แล้ว +10

    Guanabara é o melhor professor do mundo

  • @flaviofachetti3961
    @flaviofachetti3961 2 ปีที่แล้ว +1

    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
    @robsonferreirapecis9084 5 ปีที่แล้ว +5

    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
      @maathmatics 2 ปีที่แล้ว

      Não consegui fazer a segunda parte do RANKING tbm

  • @certsolution
    @certsolution 3 ปีที่แล้ว

    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
    @KarmaKula 4 ปีที่แล้ว +6

    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
      @Gabriel_Bento 3 ปีที่แล้ว +1

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

    • @hvceaser9263
      @hvceaser9263 3 ปีที่แล้ว +1

      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
    @Khufos 4 ปีที่แล้ว

    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
    @STCamposDaniel 4 ปีที่แล้ว +9

    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
    @blackbrouli7369 5 ปีที่แล้ว

    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
    @simonscabello 4 ปีที่แล้ว +5

    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
    @DeNevski ปีที่แล้ว +1

    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
    @zonamansa 3 ปีที่แล้ว +4

    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
    @leviz4916 2 หลายเดือนก่อน

    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
    @EquipeZueiros 6 ปีที่แล้ว +3

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

  • @rogeffersonmatheus2810
    @rogeffersonmatheus2810 2 ปีที่แล้ว

    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
    @fredsonchaves242 5 ปีที่แล้ว +7

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

    • @ajcs9574
      @ajcs9574 4 ปีที่แล้ว +1

      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
      @stomperhk9107 4 ปีที่แล้ว

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

    • @capitaopacoca8454
      @capitaopacoca8454 3 ปีที่แล้ว

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

    • @stomperhk9107
      @stomperhk9107 3 ปีที่แล้ว

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

    • @capitaopacoca8454
      @capitaopacoca8454 3 ปีที่แล้ว

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

  • @gleissonviolinista6273
    @gleissonviolinista6273 3 ปีที่แล้ว

    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
    @emanoeldelfino7054 4 ปีที่แล้ว +9

    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
      @italomachado4903 3 ปีที่แล้ว

      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
    @LTWalkthroughs5 2 ปีที่แล้ว

    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
    @capoarthur 3 ปีที่แล้ว +6

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

    • @sanjuro787
      @sanjuro787 2 ปีที่แล้ว

      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
      @sanjuro787 2 ปีที่แล้ว

      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
    @jeanctbra 3 ปีที่แล้ว +1

    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
    @uKaigo 6 ปีที่แล้ว +10

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

    • @marco.nascimento
      @marco.nascimento 6 ปีที่แล้ว +1

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

    •  6 ปีที่แล้ว

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

  • @jean439
    @jean439 3 ปีที่แล้ว

    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
    @guilhermefrancadeoliveira7725 5 ปีที่แล้ว +3

    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
    @Ganymedes100 3 ปีที่แล้ว

    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
    @thales6790 5 ปีที่แล้ว +4

    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
      @fredsonchaves242 5 ปีที่แล้ว

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

    • @alissondelimafarias4241
      @alissondelimafarias4241 4 ปีที่แล้ว

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

  • @maurosantos3084
    @maurosantos3084 2 ปีที่แล้ว

    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
      @乙乙-z8v 2 ปีที่แล้ว +1

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

  • @Viles-
    @Viles- 5 ปีที่แล้ว +3

    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
      @prizmincordik6768 5 ปีที่แล้ว

      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
      @moisesisraelmorielchagas 4 ปีที่แล้ว

      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
    @artursoda8994 3 ปีที่แล้ว

    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
    @gabrielyujiwakugawa64 ปีที่แล้ว

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

  • @stuartty100
    @stuartty100 6 หลายเดือนก่อน +1

    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
    @jeovaleite9301 ปีที่แล้ว +1

    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
    @MrGuitarPE 2 ปีที่แล้ว

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

  • @Douglas-ji2yo
    @Douglas-ji2yo 4 ปีที่แล้ว +2

    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
      @Douglas-ji2yo 4 ปีที่แล้ว

      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
    @eduardopinheiro5492 5 ปีที่แล้ว

    Muito Obrigado, pela aula

  • @narcizinhorobertinho21
    @narcizinhorobertinho21 3 ปีที่แล้ว

    Otima aula !!

  • @roxxteam2
    @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
    @carnevalirog514 4 ปีที่แล้ว

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

  • @rafaelmazza6288
    @rafaelmazza6288 ปีที่แล้ว

    Você é brabo, Guanabara!

  • @sanjuro787
    @sanjuro787 2 ปีที่แล้ว

    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
    @dawndao4740 ปีที่แล้ว +1

    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
    @jml1640 4 ปีที่แล้ว

    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
    @ericreis4708 ปีที่แล้ว

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

  • @dopplegang2986
    @dopplegang2986 3 ปีที่แล้ว

    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
    @pedroluizsouzapinto1980 5 ปีที่แล้ว +1

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

  • @linux_jeff
    @linux_jeff 8 หลายเดือนก่อน

    Bom vídeo. 🙂

  • @gustatofolo6666
    @gustatofolo6666 4 ปีที่แล้ว

    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
    @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
    @vivianeleite151 4 ปีที่แล้ว +1

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

  • @AngellBelger
    @AngellBelger 4 ปีที่แล้ว

    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
    @valerioferreira808 3 ปีที่แล้ว

    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
    @lorenzobandinelli2638 4 ปีที่แล้ว

    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
    @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
    @clarissebossler5921 4 ปีที่แล้ว

    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
    @genesebarbosa 3 ปีที่แล้ว +1

    ...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
    @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
    @melvinsantana2022 6 ปีที่แล้ว

    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
    @caetanopassos7346 3 ปีที่แล้ว

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

  • @guilherme10119
    @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
    @medroso1411 2 ปีที่แล้ว

    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
    @guilhermeguimaraes5113 3 ปีที่แล้ว +1

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

  • @marcelo_toller
    @marcelo_toller 2 ปีที่แล้ว

    Muito bom, obrigado!