Exercício Python

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

[@7cabeca7]

Aguardando ansiosamente por programação em Python por POO!!

[@alexandrefaculdade]

Up

[@sonystalks262]

def notas(*nota,sit=False): """ -> Função para analisar notas e situações de vários alunos :param nota: uma ou mais notas dos alunos (aceita várias) :param sit: valor opcional, indicando se deve ou não adicionar a situação :return: dicionário com várias informações sobre a situação da turma. """ maior = menor = media = soma_notas = 0 situacao = '' dicionario_alunos = dict() for contador, notas_alunos in enumerate(nota): if contador == 0: maior = notas_alunos menor = notas_alunos else: if notas_alunos > maior: maior = notas_alunos if notas_alunos < menor: menor = notas_alunos soma_notas += notas_alunos media = soma_notas / len(nota) dicionario_alunos['Total'] = len(nota) dicionario_alunos['maior'] = maior dicionario_alunos['menor'] = menor dicionario_alunos['média'] = media if sit: if media >= 7: situacao = 'Boa'.upper() elif 6

[@nikolas537]

@@sonystalks262 Corajoso

[@alann7022]

ta a 4 anos esperando já kk

[@Sir_ABSTÊNIO]

@@alann7022 Coitado kkkkkkkkk

[@jml1640]

Eu acrescentei a opção de mostrar os dados do dicionário em forma de tabela também (por isso, o código ficou enorme!). Além disso, o usuário é solicitado a digitar as notas (quantas quiser) e optar se quer ou não a situação e a tabela. def notas(*n, sit=False, tab=False): """ -> Função para analisar funções e situações de vários alunos. :param n: uma ou mais notas dos alunos (aceita várias). :param sit: opcional, indica se deve ou não adicionar a situação da turma. :param tab: opcional, indica se deve ou não mostrar os dados em forma de tabela. :return: dicionário e/ou tabela com os dados solicitados. """ dados = {} total = maior = menor = soma = 0 s = '' for i in n:# laço para obter: total, maior, menor e soma soma += i total += 1 if i == n[0]: maior = i menor = i else: if i > maior: maior = i if i < menor: menor = i media = soma / total# cálculo da média das notas if media < 5:# classificação da situação de acordo com a média de notas. s = 'RUIM' if 5 7: s = 'BOA' dados['total'] = total dados['maior'] = maior dados['menor'] = menor dados['média'] = media if sit == True:# opção caso desejar mostrar a situação da sala, de acordo com a média. dados['situação'] = s if tab == True:# opção caso desejar mostrar os dados em forma de tabela. if sit == True: print() print('=' * 50) print(f'\033[1;34;43m{"ALUNOS DA SALA (NOTAS)":^50}\033[m') print('=' * 50) print(f'{"Total":

[@fabiorodrigues2644]

parabens,ficou otimo

[@terrariaplay5779]

Mesmo sabendo que dava pra usar o Max, min e o sum eu fiz os cálculos sozinho, assim eu treino o raciocínio lógico. E raciocínio lógico é a coisa mais importante na programação

[@tiagoalves135]

Eu fiz pela lógica também, pois esqueci desses comandos skdk

[@quantaburocracia9683]

Boa, eu mesmo pensei que o Guanabara ia meter essa ai na raça. Acabei usando os módulos por preguiça. A verdade é que tô ansioso para terminar o curso, e fazer as provas. Mas vou correr atrás dessa divida praticando bastante com mais calma, e correndo menos, em breve...

[@brasiliano3201]

@@quantaburocracia9683 Também tô com pressa kkk. Daqui uma semana uma empresa vai dar um curso na facu onde estudo, e pode rolar até vaga de emprego. Tô aqui na luta. Provavelmente não vou conseguir nada pq tô no primeiro semestre, e pessoas de semestres mais avançados também vão participar. Mas quem sabe né?

[@quantaburocracia9683]

@Brigada dos Lobos - Sub5channel To focado até hje. Achei um curso pika na Udemy de Django, HTML/CSS e SQL. No momento estudando HTML/CSS.

[@JULES-el1ly]

raciocinio lógico é fazer o caminho mais curto e eficaz para uma situação.

[@devvek1ng]

# Data: 19.06.21 16:45.. (17:10 pausa: deitar rede) 20:13 { revisão 19.06.21 22:55.. # Aula 21 - Funções (Parte 2) # Music: All I Want; def fichaluno(*n, situação=False): """ -> Função para analisar notas e situações de vários alunos. :param n: uma ou mais notas (aceita várias) :param situação: (opcional), indica se deve ou não mostrar a situação do aluno. :return: dicionário com várias informações sobre a situação da turma. """ dados = dict() dados['total'] = len(n) dados['maior'] = max(n) dados['menor'] = min(n) dados['média'] = sum(n)/dados['total'] if situação: if dados['média'] > 7: dados['situação'] = 'BOA' elif 5 < dados['média'] < 7: dados['situação'] = 'RAZOÁVEL' elif dados['média'] < 5: dados['situação'] = 'RUIM' return dados resp = fichaluno(5.5, 2.5, 1.5, situação=True) print(resp)

[@lucasfs]

Quando eu faço usando max/min, o professor faz com IF. Quando eu faço com if, o professor faz com max/min kkkk

[@jessicakelly7041]

Sim kkk fico confusa

[@chihuahua8419]

Pra quem não entendeu porque numa parte do vídeo (quando o Guanabara coloca True em vez de sit=True) aparece True como menor valor, é por causa que no Python o True tem valor int 1 e o False 0, e o programa estava colocando o True no parâmetro *n e o contando como número, sendo que 1 era o menor valor que ele tinha passado.

[@pablodeveloper]

Oi, vi que seu comentário é recente, você pode me ajudar em uma coisa?

[@ytpremium5539]

eu fiz identico, pórem o usuario q digita várias notas e o programa pergunta se desja continuar... coloquei cores tbm... eu adicionei as notas do usuario numa lista mas eu fiquei com duvida no erro q tava aparecendo, não tava aceitando a lista como parametro, ent descobri (de tanto mexer kkk) que era por causa do * que tinha no parametro da função. Então somente removi o * do meu parametro "num" q deu certo, fiquei feliz q conseguir com interação do usuário kkk

[@wagnerbarbosa3054]

def notas(*n, sit=False): """ -> Função para analisar notas e situações de vários alunos. param n: uma ou mais notas dos alunos (aceita várias notas). param sit: valor opcional, indicando se deve ou não adicionar a situação. return: dicionário com várias informações sobre a situação do aluno. """ dic = {'Total': len(n), 'Maior': max(n), 'Menor': min(n), 'Média': round(sum(n)/len(n), 2)} if sit: if dic['Média'] < 6: dic['Situação'] = 'RUIM' elif 6

[@pablodeveloper]

Eu não estava conseguindo fazer porque tinha feito outra lista para poder passar do dicionário, porém esqueci que os próprios números digitados já iriam para a função como lista, mas no final, o que importa é entender. obrigado por mais uma aula!!!

[@luizz4101]

gostei bastante da minha resolução, ficou bem completa e com bastante interação do usuário. Teve 50 linhas mas me sinto grato e esforçado por ter conseguido esses adendos, inclusive, não achei difícil kakakak. Aqui vai meu código: def notas(notas,show=False): """ => Esta função avalia e da informações específicas sobre notas param notas: são as notas a serem avaliadas param show: mostra uma específica informação ou não """ informações= dict() informações['Total']= len(notas) tot= 0 for n in notas: tot += n if n == notas[0]: maior = n menor = n else: if n > maior: maior= n if n < menor: menor = n informações['Maior nota']=maior informações['Menor nota']=menor informações['Média']= tot//len(notas) if show== True: if informações['Média']>= 7: informações['Situação']= 'Aprovados' else: informações['Situação']= 'Reprovados' print (informações) lista= list() while True: n= float (input('Digite a nota do aluno:')) lista.append(n) r= str (input('Continuar? [S/N]')).upper().strip() while r[0] not in 'SN': print ('Você digitou errado, corrija!') r= str (input('Continuar? [S/N]')).upper().strip() if r[0] == 'N': break sit= str (input('Ver situação? [S/N]')).upper().strip() if sit[0] == 'S': sit= True notas(lista,sit) print(help(notas))

[@livesdayrots8584]

To morrendo de vergonha por ter ficado 5 meses longe desse curso, to voltando agora pra finalizar 😁😁😁16/08/2023 esse eu fiz questão de não desistir e só vir ver o video depois de conseguir!!! EXERCICIO#105: def notas(*num, sit=False): cont = maior = menor = media = total = 0 for c in num: cont += 1 if c > maior: maior = c if c < menor or cont == 1: menor = c total += c media = total / cont if sit: print('A situação da turma é: ', end='') if media > 7: print('Boa!') elif media > 5: print('Rasoável') else: print('Ruim!') return print(f'A nota total da turma é {total}, maior nota é {maior}, a menor nota é {menor} e a media da turma é {media}') resp = notas(8, 6, 5, 9, 6, 9, sit=True) print(resp) edit: eu n sabia que tinha que colocar tudo em um dicionário kkkkkkkk, alias eu lembrei dos comandos (max, min e len) quando tava quase acabando e só de teimosia n quis jogar o que eu ja tinha feito fora

[@thiagorazzo3102]

Fiz antes de ver a resolução def notas(*n,sit=0): """ -> Função para anlisar notas e situações de varios alunos: :param n: uma ou mais notas dos alunos (aceita varias) :param sit: valor opcional, indicando se deve ou não adcional-lo a situação :return: retorna o dicionario preenchido com todas informaçõoes """ dic = dict() acum = cont = maior = menor = 0 for c in n: cont += 1 acum += c media = acum/cont if cont == 1: maior = menor = c else: if c > maior: maior = c if c < menor: menor = c dic['Total'] = cont dic['Maior'] = maior dic['Menor'] = menor dic['Media'] = media if sit == True: if media >= 7: dic['Situação'] = 'Boa' elif 5

[@gustavovilioni]

OBRIGADO GUANABARA! Minha solução praticando laços: def notas(*num, sit=False): """ -> Função para analisar notas e situações de vários alunos. :param num: uma ou mais notas dos alunos (aceita várias) :param sit: valor opcional, indicando se deve ou não adicionar a situação :return: dicionário com várias informações sobre a situação da turma. """ dicion = dict() tot = mai = men = 0 for c in range(0, len(num)): if c == 0: mai = men = num[c] else: tot += 1 if num[c] > mai: mai = num[c] if num[c] < men: men = num[c] média = sum(num)/len(num) dicion['total'] = tot+1 dicion['maior'] = mai dicion['menor'] = men dicion['média'] = (f'{média:.2f}') if sit: if média >= 7: situação = 'BOA' elif 5 < média < 7: situação = 'RAZOÁVEL' else: situação = 'RUIM' dicion['situação'] = situação return dicion resp = notas(5.5, 9.5, 10, 6.5, sit=True) print(resp) help(notas)

[@gustavovanuncio]

Deixo aqui meu agradecimento por esse curso incrível!!! Vc e toda a glr do Curso em Vídeo são fodaasss

[@Hector-np3zi]

Esse curso de Python de fato foi um dos melhores

[@LuizFernando-tp7qe]

Aleluia , mestre. Volte com esses exercícios, por favor !!!

[@marcelalima8312]

Meu, travei na parte do sit=True. E também não sabia que poderia por um if só com o parâmetro. Valeu pela aula.

[@antonioevangelistajunior7476]

Chegar no mesmo resultado do Guanabara é uma alegria!

[@alissong.]

Filanemte senhor aleluia , vlw guanabara você é um mito

[@aDDxDD]

Feliz pq deu certo e puto pq peguei o caminho mais longo kkk def notas(*n, sit=False): """ => Função para analisar notas e situação de vários alunos: :param n: uma ou mais notas dos alunos (aceita várias); :param sit: valor opcional, indicando se deve ou não adicionar a situação; :return: dicionário com várias informações sobre a situação da turma. """ dict = {} total = maior = menor = cont = media = 0 situacao = '' for i in range(0, len(n)): total += n[i] if i == 0: maior = menor = n[i] if n[i] > maior: maior = n[i] if n[i] < menor: menor = n[i] cont += 1 media = total / cont if sit: if media > 7: situacao = 'Boa' elif 5 < media < 7: situacao = 'Regular' else: situacao = 'Ruim' dict['Situação'] = situacao dict['Qtd de notas'] = cont dict['Total'] = total dict['Maior'] = maior dict['Menor'] = menor dict['Média'] = media return dict resp = notas(8, 7.5, 6, 9, 10) print(resp)

[@lucafio1907]

minha resolução sem usar as funções do python: def notas(* nts, sit=False): """ -> Função para analisar notas e situações de vários alunos. :param nts: uma ou mais notas dos alunos (aceita várias) :param sit: valor opcional, indicando se deve ou não adicionar a situação :return: dicionário com várias informações sobre a situacão da turma """ dicionario = dict() dicionario['quantidade'] = len(nts) cont = 0 for c in range(0, len(nts)): cont += nts[c] if c == 0: dicionario['maior'] = nts[c] dicionario['menor'] = nts[c] else: if nts[c] > dicionario['maior']: dicionario['maior'] = nts[c] if nts[c] < dicionario['menor']: dicionario['menor'] = nts[c] dicionario['media'] = cont / len(nts) if sit: if dicionario['media'] >= 7: dicionario['situacao'] = 'BOA' elif dicionario['media'] >= 5: dicionario['situacao'] = 'RAZOÁVEL' else: dicionario['situacao'] = 'RUIM' return dicionario print(notas(5.5, 9.5, 10, 6.5, sit=True)) help(notas)

[@danielprado1942]

você quis dizer: sem usar as funções Min() e Max()

[@andremendes4819]

Show brother

[@cajuq]

def notas(*num,sit=False): ''' -> Função para analisar notas e situações de vários alunos. :param num:uma ou mais notas dos alunos (aceita várias) :param sit:valor opcional, indicando se deve ou não adicionar a situaçao :return:dicionário com várias informações sobre a situação da turma. ''' aluno={} aluno['total']=len(num) maior=n=0 for c in range(0,len(num)): if num[c]>maior: maior=num[c] else: maior=maior for i in num: if i7: aluno['situação']='BOA' elif 5

[@vittaday]

Esse exercício top, uniu vários aprendizados :)

[@giovanninovais7612]

Coloquei uns detalhes a mais no exercício. Fiz com que o usuário cadastrasse as 5 notas, e no final perguntei se ele queria que mostrasse a situação ou não, de modo que se a resposta fosse qualquer coisa diferente de S ou N, sim ou não, desse erro e tivesse que digitar novamente, por isso o código ficou um pouco maior. def notas(n, sit): """ -> Função par analisar notas e situações de vários alunos :param n: lista com todas as notas cadastradas :param sit: valor opcional (True ou False), indicando se deve ou não adicionar a situação :return: um dicionário com várias informações sobre a turma """ maiorn = 0 menorn = 0 media = sum(n) / len(n) for p, item in enumerate(n): if p == 0 or item > maiorn: maiorn = item if p == 0 or item < menorn: menorn = item if media < 5: s = 'RUIM' elif 5

[@yahh2580]

o exercício difícil da peste kkkk, mas eu não vou desistir!!!

[@esdrika360]

O meu, pra quem quiser saber dá para adicionar diretamente o dicionário, sem precisar colocar vários r=[' '] def notas(*n, sit=True): """ Em (n) analisa vários parametros de notas (int) Retorna um dicionário contendo o total de notas, maior, menor e média. sit = Opicional, retorna a situação do aluno de acordo com a média. """ r = {'total': len(n), 'maior': max(n), 'menor': min(n), 'media': sum(n) / len(n)} if sit: if r['media'] >= 7: r['situacao'] = 'Aprovado' elif r['media'] >= 6: r['situacao'] = 'Recuperação' else: r['situacao'] = 'Reprovado' return r resp = notas(7, 7, 8, sit=False) print(resp)

[@giolianobraga2555]

Achei uma forma de deixar um pouco melhor :D def notas(num, sit=False): """ -> Função que mostra uma situação geral de notas dos alunos: :param qtdnt: quantidade de notas inseridas; :param maiorn: maior nota inserida; :param menorn: menor nota inserida; :param median: média das notas inseridas; :param sit: situação dos alunos; :return: retorna todos os parametros acima dentro ou não de uma situação """ dictnt = dict() dictnt['total'] = len(num) dictnt['maior'] = max(num) dictnt['menor'] = min(num) dictnt['média'] = sum(num)/len(num) print(type(num)) if sit: if dictnt['média'] >= 9: dictnt['sit'] = 'ÓTIMA' elif dictnt['média'] >= 7: dictnt['sit'] = 'BOA' elif dictnt['média'] >= 5: dictnt['sit'] = 'REGULAR' else: dictnt['sit'] = 'RUIM' return dictnt #Programa Principal nota = list() cont = 1 print('Digite as notas dos alunos!') while True: resp = float(input(f'Digite a nota do {cont}º aluno: ')) nota.append(resp) d = input('Deseja continuar [S/N]? ') cont+=1 if d in 'nN': break print(notas(nota, sit=True))

[@rafaelrodriguessilva9994]

Como sempre, aquele conteúdo de qualidade! Recomendo!!!

[@Gosto_de_Tecnologia]

Oba, o importante é que o curso está continuando...Obrigado professor Guanabara.

[@vinicius010]

Acabei fazendo esse na mão mesmo, sem usar as funções max e min. def notasturma(*alunos, situação = False): """ -> Função para analisar notas e situação de vários alunos. :param alunos: uma ou mais notas dos alunos(aceita várias) :param situação: valor opcional indicando se deve ou não adicionar a situação. :return: dicionário com várias informações sobre a situação da turma. """ turma = dict() c = maior = menor = somanotas = 0 for a in alunos: if c == 0: maior = a else: if a > maior: maior = a if c == 0: menor = a else: if a < menor: menor = a somanotas += a c += 1 turma['Total'] = len(alunos) turma['Maior'] = maior turma['Menor'] = menor turma['Média'] = somanotas // len(alunos) if situação: if turma['Média'] >= 5: turma['Situação'] = 'Razoável' elif turma['Média'] >= 7: turma['Situação'] = 'Excelente' elif turma['Média'] < 5: turma['Situação'] = 'Ruim' return turma a = notasturma(6,2,7,5,0, situação= True) print(a) help(notasturma)

[@miltonferreira5545]

Muito bom estar de volta com o melhor professor....Obaaaaa

[@franciscotadeupezzi3431]

Obrigado! def notas(* n,sit=False): """ -> Função para analizar situação a partir de várias notas de aluno(s). :param n: Uma ou mais notas do(s) aluno(s) :param sit: Valor opcional, indicando se deve ou não acrescentar situação :return: dicionario com várias informações sobre situação do aluno(s) """ tupla = n resp = dict() resp['total'] = len(tupla) resp['maior'] = max(tupla) resp['menor'] = min(tupla) tot = med = 0 for c in tupla: tot += c med = tot / len(tupla) resp['média'] = med if sit == True: if med >= 7: resp['situação'] = 'BOA' elif med < 5: resp['situação'] = 'RUIM' else: resp['situação'] = 'RAZOAVEL' print('-' * 80) return resp #Programa principal resp = notas(5.5, 9.5, 10, 6.5,sit=True) print(resp) help(notas)

[@wilkercarneiro]

def notas(*n, sit=False): """ -> Função para analisar notas e situações de vários alunos. :param n: uma ou mais notas dos alunos (aceita várias) :param sit: valor opcional, indicando se deve ou não adicionar a situação :return: dicionario com varias informações sobre a situação da turma """ c = maior = menor = media = soma = 0 total = len(n) while c < total: if c == 0: maior = n[c] menor = n[c] else: if menor > n[c]: menor = n[c] if maior < n[c]: maior = n[c] soma += n[c] c += 1 media = float(soma / total) print(f'Total de notas: {total}') print(f'Maior nota: {maior}') print(f'Menor nota: {menor}') print(f'Média do aluno: {media}') if sit == True: if media < 5: print('Situação: RUIM!') elif media < 7: print('Situação: MÉDIA!') else: print('Situação: BOA!') resp = notas(5.5, 9.5, 10, 6.5, sit=True)

[@GabAlmBar]

def notas(*n, sit=False): """ -> Função para analisar notas e situações de vários alunos. :param n: uma ou mais notas dos alunos. (aceita várias) :param sit: (opcional) indica se quer incluir ou não a situação. :return: dicionário com várias informações sobre a situação da turma. """ total = len(n) maior = media = menor = 0 for c in range(0, len(n)): media += n[c] if c == 0: maior = n[c] menor = n[c] else: if n[c] > maior: maior = n[c] if n[c] < menor: menor = n[c] media /= total relatorio = {'total': total, 'maior': maior, 'menor': menor, 'media': media} if sit: if media > 7: situacao = 'BOA' elif media > 5: situacao = 'RAZOÁVEL' else: situacao = 'RUIM' relatorio['situacao'] = situacao return relatorio resp = notas(3.5, 2, 6.5, 2, 7, 4, sit=True) print(resp)

[@anonymus851]

Fiz da forma tradicional: def notas(*notas, sit=False): """ -> A função recebe varias notas e devolve informações *notas -> Recebe varias notas. sit -> Mostra a situação de for verdadeiro(opcional) return -> Retorna um dicionario com as seguintes informações: 1 - Total de notas 2 - Maior nota 3 - Menor nota 4 - Media 5 - Situação(opcional) """ info = dict() info["total"] = len(notas) soma = maior = menor = 0 for n in range(0, len(notas)): soma += notas[n] if n == 0: maior = menor = notas[n] else: if notas[n] > maior: maior = notas[n] if notas[n] < menor: menor = notas[n] info["maior"] = maior info["menor"] = menor info["media"] = soma / len(notas) if sit: if info["media"] >= 7: info["situação"] = "Boa" elif info["media"] >= 5 and info["media"] < 7: info["situação"] = "Razoavel" else: info["situação"] = "Ruim" return info # Programa principal result = notas(2, 6, 4, 5, sit=False) print(result) # Ajuda help(notas) print(notas.__doc__)

[@emanoeldelfino7054]

Minha solução ficou bastante similar ao do professor Guanabara, apenas removi o True e False que for colocado de forma errônea na função para não acabar mexendo nos valores: # Repositório com esse e outros exercício em github.com/emanoeldelfino/pycev def notas(*ns, sit=False): """ -> Analisa as notas e situação de vários alunos. :param ns: uma ou mais notas dos alunos (aceita várias). :param sit: valor opcional, indicando se deve ou não adicionar a situação. :return: dicionário com várias informações sobre a situação da turma. """ # Removendo True e False da lista caso tenha usado a função de maneira errada ns = tuple(valor for valor in ns if bool(valor) != valor) print(' ', '-' * 30, sep='') dicio = dict() dicio['total'] = len(ns) dicio['maior'] = max(ns) dicio['menor'] = min(ns) dicio['média'] = round(sum(ns) / len(ns), 3) if sit: if dicio['média'] >= 7: dicio['situação'] = 'BOA' elif dicio['média'] >= 5: dicio['situação'] = 'RAZOÁVEL' else: dicio['situação'] = 'RUIM' return dicio # Programa Principal info = notas(5.5, 2.5, 1.5, sit=True) # notas(3.5, 2, 6.5, 2, 7, 4) print(info) help(notas)

[@educz8491]

fiz assim: def notas(*n): import statistics as s import pandas as pd notas = dict() notas['Quantidade de Notas'] = len(n) notas['Maior Nota'] = max(n) notas['Menor Nota'] = min(n) notas['Média das Notas'] = s.mean(n) notas_df = pd.DataFrame([notas]) return notas_df

[@rspozza]

Excelente vídeo. Parabéns Gustavo.

[@deku-yl7jh]

sempre gosto de fazer os programas com alguma interação, ent ta ai o meu dicionario = {} lista = [] opcao = 0 sit = '' def aluno(notas): ''' -> Analisa as notas de um aluno para notas: lista com as notas return: sem return ''' from time import sleep dicionario['Total'] = len(notas) dicionario['Maior'] = max(notas) dicionario['Menor'] = min(notas) dicionario['Média'] = sum(notas) / len(notas) if sit == 'S': if sum(notas) / len(notas) = sum(notas) / len(notas) > 5: dicionario['Situação'] = 'BOA' else: dicionario['Situação'] = 'PERFEITA' print('-'*60) print('\033[1:37mPROCESSANDO...\033[m') sleep(3) print(dicionario) print('-'*60) print(''' [1] Usar o programa; [2] Entender o programa.''') while True: opcao = int(input('Opção: ')) if opcao == 1 or opcao == 2: break else: print('\033[1:31mEERO! Digite o número de acordo com as opções\033[m') print('-'*60) if opcao == 1: print(f'{"Vamos entender as notas de um aluno.":^60}') nome = str(input('Nome do aluno: ')) num = int(input('Quantas notas você quer analisar? ')) for c in range(1,num+1): lista.append(int(input(f'Nota#{c}: '))) while True: sit = str(input(f'Quer ver a situação de {nome} [S/N]: ')).upper() if sit == 'S' or sit == 'N': break else: print('\033[1:31mERRO! Digite a letra de acordo com as opções\033[m') aluno(lista) else: help(aluno)

[@gabriesantana7997]

Exercício mais fácil de todos consegui fazer em 10 minutos e minha solução ficou igualzinho a dele!

[@PlanetaSagas]

Simplificou tanto... kkkkkkkkkk a minha ficou assim: def calnotas(*num, sit=False): ''' --> Uma função que calcula a média, total e verifica o maior e a menor nota. número em uma listagem. :param num: As notas que serão verificadas. Podem ser utilizadas quantas notas quiser. :param sit: (Opcional) Revela a situação do aluno. :return: retorna os dados para a variável em forma de um dicionário. Variável feita por Helton ''' lista = dict() total = 0 med = 0 menor = 0 maior = 0 for c in num: med += c total += 1 if total == 1: maior = c menor = c else: if c > maior: maior = c elif c < menor: menor = c med = med // total lista['Total'] = f'{total} nota(s)' lista['Média'] = med lista['Maior'] = maior lista['Menor'] = menor if sit: if med = 8: lista['situação'] = 'Boa' else: lista['situação'] = 'Razoável' return lista resp = calnotas(1.5, 1.5, 9, 10, sit=True) print(resp)

[@flesker7693]

Estacou quantos Q's desde a sua postagem?!

[@Antonioalvesjr06]

Valeu Guanabara! Não ligue para as críticas de pessoas dizendo que o lançamento das aulas é demorado. Vai no seu tempo, camarada!

[@luangoncalves9405]

O meu exercicio eu resolvi dessa forma: def notas(*n, situação=False): """ -> :param n: recebe a nota de vários alunos -> :situação: (OPCIONAL) recebe um valor booleano para mostrar ou não a situação dos alunos -> :variavel boletim: É um dicionario que ira receber dados da maior, menor nota, a média da turma e a situação -> :variavel maior: recebe a maior nota -> :variavel menor: recebe a menor nota -> :variavel s: recebe a soma de todas as notas dos alunos para calcular a média da turma -> :round(): É uma funcão que faz o arredondamento de um numero para o inteiro mas proximo ou para o valor de casas decimais sugerido """ boletim = {'total': len(n)} s = 0 for c in range(0,len(n)): if c == 0: maior = menor = n[c] else: if n[c] > maior: maior = n[c] if n[c] < menor: menor = n[c] for p, item in enumerate(n): if n[p] == 0: s += item else: s += item boletim['maior'] = maior boletim['menor'] = menor boletim['média'] = round(s/len(n),1) if situação: if boletim["média"] >= 7: boletim['situação'] = 'BOA' elif boletim["média"] >= 5: boletim['situação'] = 'RAZOAVEL' else: boletim['situação'] = 'RUIM' return boletim resp = notas(6, 3.5, 2.5,situação=True) print(resp) help(notas)

[@marceloguimaraes796]

Isso aí, esse é o curso da tua vida e da nossa 😀😀😀😀

[@thomazkkkkk]

fiquei um pouco desanimado por nao conseguir resolver os ultimos dois exercicios, mas esse eu consegui, deu uma alegriakkk: def notas(*num, sit = False): ''' para num: recebe as notas para sit: True para ver a situação e False para nao vê para return: volta os valores de dados ''' dados = {} dados['total'] = len(num) dados['maior'] = max(num) dados['menor'] = min(num) dados['média'] = sum(num) / len(num) if sit == False: return dados elif sit == True: if dados['média'] < 5: situação = 'PESSIMA' elif dados['média'] > 7: situação = 'RAZOAVEL' else: situação = 'OTIMA' dados['situação'] = situação return dados resp = notas(8, 6, 8, sit= True) print(resp)

[@airtoncoutinhonetopelissar7814]

Pessoal, estou me desenvolvendo bem (sem muitas dificuldades) até aqui... mas tenho me perguntado uma coisa: finalizando o Mundo 3 de Python qual seria o próximo passo mais coerente? Apesar de estar entendendo bem sinto falta de algum exercício aplicado ao mundo profissional/ou a algum projeto... e o Guanabara é fera! Tem algum curso complementar no próprio curso em vídeo? Abçss

[@sirMarbas]

a gente vai trabalhar com interface gráfica mais pra frente ou só terminal?

[@play-tv-top1]

Acho que ele não vai entrar na parte gráfica, que seria os framework pygame, kyvi, entre outros

[@herissonricardo-slackwareo450]

Acredito que vamos usar a biblioteca tkinter.

[@erikiseki]

Sinceramente, se vocês buscassem outros recursos para aprender nesse tempo que o canal não lança vídeos, já estariam bem mais avançados na linguagem e, de quebra, sairiam da dependência do canal.

[@pedrogrechi]

@@erikiseki Alguma indicação?

[@leoa4871]

@@pedrogrechi Há um canal chamado ignorância zero, com um curso de Python bem mais completo e avançado. Sinceramente, a didática do Curso em Vídeo é um pouco melhor, mas tem uma limitação de se prender muito no introdutório e básico. Têm muitos documentos na web bons também. Mas o curso do ignorância zero é ótimo pra avançar no python. Segue a playlist das aulas: kzbin.info/www/bejne/onvNg2xma5llbNE

[@tokageotaku6749]

def notas(*nota, sit=False): """ -> analisa as notas dos alunos informados :param nota: recebe uma ou várias notas :param sit: sit = "True" para informar a situação, por padrão sit = "False" :return: retorna um dicionário com o resultado da análise de dados """ turma = {"maior": max(nota), "menor": min(nota), 'média': (sum(nota) / len(nota))} if sit: if turma['média'] < 6: turma['situação'] = 'RUIM' elif turma['média'] < 7: turma['situação'] = 'RAZOÁVEL' else: turma['situação'] = 'BOA' return turma print(f'\033[96;1;4m{"ANALISANDO E GERANDO DICIONÁRIOS":|^40}\033[0;1;97m') resultado = notas(5, 9, 4, sit=True) print(resultado) help(notas)

[@shadow_lofi]

Eu fiz sem usar o min, max ou o sum. Desenvolvi o raciocínio longo usando if's, minha solução ficou assim: Criando a função def notas(*n, sit=False): """ -> Função para analisar notas e situações de vários alunos. :param n: uma ou mais notas dos alunos (aceita várias) :param sit: valor opcional, indicando se deve ou não adicionar a situação :return: dicionário com várias informações sobre a situação da turma. """ print('-'*20) turma = dict() maior = menor = somanota = 0 turma['total'] = len(n) for c, v in enumerate(n): if c == 0: maior = v menor = v else: if v > maior: maior = v if v < menor: menor = v somanota += v media = somanota / turma['total'] turma['maior'] = maior turma['menor'] = menor turma['média'] = media if sit == True: if media >= 7: turma['situação'] ='BOA' if 7 > media > 5: turma['situação'] = 'RAZOÁVEL' if media < 5: turma['situação'] = 'RUIM' return turma Programa principal. print(notas(3.5, 2, 6.5, 2, 7, 4, sit=True)) help(notas)

[@BrunoCosta-ip1hy]

Minha solução def nota(*notas, sit=False): """ >>Função para analisar notas e situações de vários alunos :param notas: uma ou mais notas dos alunos (aceita várias notas) :param sit: valor opcional, indicando de deve ou não adcionar a situação :return: dicionário com várias informações sobre a situação da turma """ resp = {} qTnotas = 0 maior = 0 somanotas = 0 for i, c in enumerate(notas): if i == 0: maior = c menor = c else: if c > maior: maior = c if c < menor: menor = c somanotas += c #print(f'{i} {c}') qTnotas += 1 resp['total'] = qTnotas resp['maior'] = maior resp['menor'] = menor resp['media'] = somanotas / qTnotas if sit == True: if resp['media']

[@linux_jeff]

Bom vídeo! 🙂

[@LUCAS-ev5op]

fiz assim: def notas(*n, sit=False): """ Função para analisar notas e situações de vários alunos. :param n: uma ou mais notas dos alunos (aceita várias). :param sit: valor opcional, indicando se deve ou não adicionar a situação. :return: dicionário com várias informações sobre a situação da turma. """ resp = { 'total': len(n), 'maior': max(n), 'menor': min(n), 'média': sum(n) / len(n) } if sit: if resp['média'] >= 7: resp['situação'] = 'BOA' elif 5

[@IDK-ov5yx]

Meu código ficou gigante, depois de ver a resolução fiquei meio bravo comigo kKKK mas tá funcional.. def notas(*notas, sit=False): contador = 0 dicionario = {} maior = 0 menor = 0 somaNotas = 0 for c in range(0, len(notas)): contador = contador + 1 somaNotas = somaNotas + notas[c] dicionario['total'] = contador # for acima para contar quantas notas tem e colocar no dicionario, também faz a Soma de todas as notas. for k, v in enumerate(notas): if k == 0: maior = v menor = v if v > maior: maior = v if v < menor: menor = v # for acima para verificar as maiores e menores notas media = somaNotas/len(notas) mediaLimitad = round(media, 2) dicionario['maior'] = maior dicionario['menor'] = menor dicionario['media'] = mediaLimitad if sit: if (mediaLimitad >= 6): dicionario['situação'] = 'ACEITÁVEL' else: dicionario['situação'] = 'RUIM' # cadeia de ifs para mostrar a situação. return dicionario resp = notas(5.5, 2.5, 10, 10, sit=True) print(resp)

[@saxvilao]

parabéns!

[@joaomatheus7081]

Desafio 105 def notas(* notas, sit = True): adSituacao = dict() total = len(notas) adSituacao['Total'] = total maior = max(notas) adSituacao['Maior'] = maior menor = min(notas) adSituacao['Menor'] = menor soma = sum(notas) media = soma / len(notas) adSituacao['Média'] = f'{media :.1f}' if sit: if media >= 7: adSituacao['Situação'] = 'Aprovado' elif media >= 5: adSituacao['Situação'] = 'Razoável' else: adSituacao['Situação'] = 'Reprovado' return adSituacao # Programa principal... resposta = notas(5.6, 10, 8.7, 3.3, sit = True) print(resposta)

[@lMatheusx]

#104 Função grades() que pode receber várias notas de alunos e vai retornar #um dicionário com as seguintes informações: #A quantidade de notas, a maior nota, a menor nota, a média da turma, #A situação (opcional). Adicione também as docStrings def grade(*num, con = False): """ The function grade will return 4 values: Total of grades, average, highest Grade, smallest Grade and a situation if the con were true; """ dic = dict(); total = len(num); average = float(0); for i in range(0, total): if(i == 0): highestNumber = num[i]; smallestNumber = num[i]; else: if(num[i] > highestNumber): highestNumber = num[i]; elif(num[i] < smallestNumber): smallestNumber = num[i]; average += num[i]; average /= len(num); print(total, average, highestNumber, smallestNumber); if(con == True): if(average > 6): situation = 'Good'; elif(average < 6): situation = 'Bad'; return (total, average, highestNumber, smallestNumber, situation); else: return (total, average, highestNumber, smallestNumber); final = {(grade(7.5, 9.3, con = True))}; print(final); help(grade);

[@RyubielGG]

Foi bom esse exercicio, mas fiquei besta a forma fácil que o prof fez, a minha ficou enorme, porém funcionando def notas(* num, sit=False): """ -> Função para analisar notas e situações de vários alunos. :param num: uma ou mais notas dos alunos (aceita várias) :param sit: valor opcional, indicando se deve ou não adicionar a situação :return: dicionário com várias informações sobre a situação da turma. """ total = 0 soma = 0 for c in num: soma += c if total == 0 or c > maior: maior = c if total == 0 or c < menor: menor = c total += 1 media = soma / total retorno = {'total': f'{total}', 'maior': f'{maior}', 'menor': f'{menor}', 'soma': f'{media}', 'media': f'{media}'} if sit: if media >= 7: retorno['situação'] = "BOA" elif media >= 5: retorno['situação'] = "RAZOÁVEL" else: retorno['situação'] = "RUIM" return retorno resp = notas(5.5, 2.5, 6, 6.5, sit=True) print(resp)

[@iuryoliveira8325]

Caraca me senti bem pq consegui fazer direitinho....qdo vejo o do gustavo, vi q o meu ficou mtooooooooo grande! kkkkkkk Mas aquele obrigado mais uma vez professor @guanabara Obs: Eu fiz uma atualização hoje no pycharm (3dez2019) e quando joguei as aspas para fazer o parametro ele n funfou direitinho não. Antes ele aparecia os dados automaticamente, como no vídeo. Ae vai o meu: def notas(* n, sit = False): """ ->Função para analisar as notas dos alunos param n: recebe os valores das notas param sit: valor opcional, para informar notas analisadas return: dicionário com os valores das notas """ dicnotas = {} total = media = totalnotas = 0 maior = menor = n[0] for a in range(0, len(n)): if n[a] > maior: maior = n[a] if n[a] < menor: menor = n[a] totalnotas += n[a] total+=1 media = totalnotas / total dicnotas['total'] = total dicnotas['maior'] = maior dicnotas['menor'] = menor dicnotas['media'] = media if sit == True: if media >= 7: dicnotas['situação'] = 'APROVADO' else: dicnotas['situação'] = 'REPROVADO' return dicnotas #Programa Principal resp = notas(5.5, 9.5, 5, 6.5, sit=True) print(resp)

[@skyler820]

def notas(*nota, sit=False): dic={} dic['quant']=len(nota) dic['maior']=max(nota) dic['menor']=min(nota) soma=0 for cont in nota: soma+=cont media=soma/len(nota) dic['média']=media if sit==True: if media

[@albertoBruno1265]

Minha solução, eu achei fácil, mas tive que sair, dar uma volta e ver exercícios antigos, meu problemas estava em dicionário, preciso praticar mais. def notas(*notas, sit=False): """ -> Função para analisar notas e situações de uma classe. :param notas: Recebe uma ou mais notas de alunos. :param sit: (Opcional) Mostra ou não a situação da classe :return: Dicionário com às notas, a nota máxima, a nota mínima, a média da classe e a situação desta classe """ boletim = dict() print(sum(notas)) boletim["Quantidade"] = len(notas) boletim["Maior nota"] = max(notas) boletim["Menor nota"] = min(notas) boletim["Média sala"] = sum(notas)/len(notas) if sit: if boletim["Média sala"] >= 9: boletim["Situação"] = 'MUITO BOA' elif boletim["Média sala"] >= 7: boletim["Situação"] = 'BOA' elif boletim["Média sala"] >= 5: boletim["Situação"] = 'REGULAR' else: boletim["Situação"] = 'RUIM' return boletim resp = notas(7.5, 4.7, 6.3, 9.5, sit=True) print(resp) help(notas)

[@reyk3443]

Essa parte de funções ta bem facil: def notas(*n, sit=False): """ :param n: São as notas dos alunos :param sit: Informa a situação do aluno :return: dicionário com várias informações sobre a situacão do aluno """ dict = {'Total': len(n), 'Maior': max(n), 'Menor': min(n), 'Média': sum(n) / len(n)} if sit: if 5 = 7: dict['Situação'] = 'Boa' print('~'*50) return dict resp = notas(5.5, 8, 5.6, 10, sit=True) print(resp)

[@herissonricardo-slackwareo450]

Aula muito bem elaborada professor, tá de parabéns!! Gostaria de saber quando vamos começar a usar o modulo tkinter.

[@David73_]

Fiz assim: def nota(*nota,sit = False): """Função pra analisar a nota e a situação de vários alunos, também para descobrir a maior nota, a media e a menor nota --->sit = True caso queria mostrar a situação dos alunos --->sit = False caso não queria mostrar a situação dos alunos """ dicionário = {'total' : len(nota),'media' : round(sum(nota)) / len(nota),'maior' : max(nota),'menor' : min(nota)} if sit == True: if dicionário['media'] >= 7: dicionário['situacao'] = 'Boa' elif dicionário['media']

[@jogaridu8776]

Minha solução com mais alguns apetrechos Ex 105: def notas(*args, sit=False): """ -> Função para analisar notas e situações de vários alunos. :param args: Uma ou mais notas dos alunos (aceita várias) :param sit: valor opcional, indicando se deve ou não adicionar a situação :return: dicionário com várias informações sobre a situação da turma """ try: turma = {'total': len(args), 'maior': max(args), 'menor': min(args), 'média': round(sum(args) / len(args), 2)} if sit == True: if turma.get('média') > 7: turma.update({'situação': 'BOM'}) elif turma.get('média') < 4: turma.update({'situação': 'RUIM'}) else: turma.update({'situação': 'RAZOÁVEL'}) except TypeError: return 'Por favor insira um número como nota' return turma print(notas(5.5, 9.5, 6.5, 10, sit=True))

[@slim.onion.]

Incrível , melhor professor ♥️♥️♥️

[@lucasneves1030]

def notas(*notas, situacao=False): """ Calcula diversas informações sobre um conjunto de notas de alunos. Args: *notas: Parâmetro variável que permite fornecer várias notas. situacao (bool, opcional): Indica se a situação dos alunos será incluída no dicionário. Por padrão, é False. Returns: dict: Dicionário com as seguintes informações: - 'quantidade': Quantidade de notas. - 'maior': Maior nota. - 'menor': Menor nota. - 'média': Média da turma. - 'situação' (opcional): Situação dos alunos (Aprovado, Reprovado, etc.). """ resultado = { 'quantidade': len(notas), 'maior': max(notas), 'menor': min(notas), 'média': sum(notas) / len(notas), } if situacao: media = resultado['média'] if media >= 7: resultado['situação'] = 'Aprovado' elif media >= 5: resultado['situação'] = 'Recuperação' else: resultado['situação'] = 'Reprovado' return resultado resultado = notas(8, 9.5, 7, 8.2, situacao=True) print(resultado) help(notas)

[@certsolution]

Antes de olhar a resposta, fiz um monte de gambiarras mas consegui resolver a questão do True/False. Agora, vou assistir para aprender como se faz de verdade, eh, eh ''' Crie um programa que tenha a função notas(), a qual pode receber várias notas de alunos e vai retornar um dicionário com as seguintes informações: - quantidade de notas; = a maior nota - a menor nota - a média da turma - a situação (opcional) Adicione também o docstrings da Função ''' def notas(*num, sit=False): totnotas = [] dic = {} somanotas = 0 totnotas = [num] for v in num: somanotas += v media = somanotas/len(num) if media > 7: dic = {'Total': len(num), 'Maior': max(num), 'Menor': min(num), 'Media': media} elif media < 5: dic = {'Total': len(num), 'Maior': max(num), 'Menor': min(num), 'Media': media} else: dic = {'Total': len(num), 'Maior': max(num), 'Menor': min(num), 'Media': media} if sit: if media > 7: dic = {'Total': len(num), 'Maior': max(num), 'Menor': min(num), 'Media': media, 'Situação':'Boa'} elif media < 5: dic = {'Total': len(num), 'Maior': max(num), 'Menor': min(num), 'Media': media, 'Situação': 'Péssima'} else: dic = {'Total': len(num), 'Maior': max(num), 'Menor': min(num), 'Media': media, 'Situação': 'Razoável'} return dic ''' Carrega um dicionário através de parâmetros digitados ''' resp = notas(1, 6, 4, 1, 9, sit=True) print(resp) #help(notas)

[@gogh-lk5dd]

Meu jeito: def notas(*n, sit=False): """ Mostra a quantidade de notas, a maior e menor nota, e a média. Também possui um parâmetro opcional para mostrar a situação (boa, razoável e ruim). :param n: notas :param sit: True para ver situação :return: retorna o dicionário completo """ ficha = {'Total de notas': len(n), 'Maior nota': max(n), 'Menor nota': min(n), 'Média': round(sum(n) / len(n), 1)} if sit: if ficha['Média'] > 7: ficha['Situação'] = 'Boa' elif ficha['Média'] < 5: ficha['Situação '] = 'Ruim' else: ficha['Situação '] = 'Razoável' return ficha resp = notas(1, 5, 10, sit=True) print(resp)

[@leandrosannin]

Pythonnnnnnnnnnnnnnnnnnnnnnnnnn FINALMENTEEEEEEEEEEEEEEEEE!!!!!!!!!!!!!

[@romariosilva1405]

me bati pra fazer, fiz e refiz pra fica do jeito certo def notas(*nota,sit=False): r = dict() r['total'] = len(nota) r['maior'] = max(nota) r['menor'] = min(nota) r['media'] = round(sum(nota) / len(r),1) if sit: if r['media'] >= 7: r['situaçao'] = 'Boa' elif 6

[@Vascodagama999]

o meu ficou assim def analise(*nota, sit=False): resumo = {'total': {len(nota)}, 'maior': max(nota), 'menor': min(nota), 'média': round(sum(nota)/len(nota)), 'situação': "Bom" if sum(nota)/len(nota) >= 6 else "Ruim"} if sit: return resumo else: return dict(list(resumo.items())[0:4])

[@gomesbruno201]

A volta do mito

[@luanwid]

Fiz de forma mais conpleta, utilizando while pra adicionar valores def notas(*n, situa=False): """ Calcula a media da turma e coloca em um dicionario. param n: Pega uma lista com varios valores dentro. param situa: Da a opção de colocar ou não a situação da turma no dicionario. Return: Retorna um dicionario. """ maior = 0 menor = 0 soma = 0 media = 0 notasAluno = {} for c in n: compri = len(c) for d in range(0, compri): if d == 0: maior = c[d] menor = c[d] else: if maior < c[d]: maior = c[d] if menor > c[d]: menor = c[d] for i in c: soma += i media = soma / compri notasAluno['Total'] = compri notasAluno['Maior'] = maior notasAluno['Menor'] = menor notasAluno['Media'] = media if situa: if media == 7.0: notasAluno['Situação'] = 'Ta na media' if media > 7.0: notasAluno['Situação'] = 'Ta muito boa' if media < 7.0: notasAluno['Situação'] = 'Ta muito ruim' return notasAluno lista = [] while True: n = float(input('Nota do aluno: ')) lista.append(n) usuario = str(input('Quer continuar? [S/N]: ')).upper()[0] if usuario == 'N': break print(notas(lista, situa=True)) help(notas) OBRIGADO Gustavo Guanabara!

[@fabricioaraujo81]

Fiz essa brincadeira com a opção do usuário digitar as notas e escolher se quer ou não a situação def notas(*arg, sit=False): dicionario = { 'quantidade de notas': len(arg), 'maior nota': max(arg), 'menor nota': min(arg), 'média da turma': sum(arg) / len(arg), } if sit: if dicionario['média da turma'] > 7: dicionario['situação'] = 'BOA' elif dicionario['média da turma'] > 5: dicionario['situação'] = 'MÉDIA' elif dicionario['média da turma']

[@Illuzzi76]

O meu ficou parecido :) def notas(*n, sit=False): r = {} r = {'total': sum(n), 'maior': max(n), 'menor': min(n), 'media': sum(n) / len(n)} if r['media'] = 10 and sit: r['situação'] = 'bom' return r resp = notas(5.3, 2.5, 1.5, sit=True) print(resp)

[@anabeatriz8835]

TÔ TÃO FELIZ

[@karlasilva9357]

def notas(*n, sit=False): """ -> Funçaõ para analisar notas e situação de vários alunos :param n: uma ou mais notas dos alunos (aceita várias) :param sit: valor opcional, indicando se deve ou não adicionar a situação :return: dicionário com várias informações sobre a situação da turma """ resp = {"total": len(n), "maior": max(n), "menor": min(n), "média": sum(n)/len(n)} if sit: if resp["média"] >= 7: resp["situação"] = "APROVADO" elif resp["média"] >= 5: resp["situação"] = "RECUPERAÇÃO" else: resp["situação"] = "REPROVADO" return resp #Programa principal resp = notas(3.5, 9, 6.5, sit=True) print(resp) help(notas)

[@prey_boy]

def notas(*notas,sit=False): ''' --> Função para analisar notas e situações de vários alunos parametro Nota = Uma ou mais notas dos alunos (Aceita várias) parametro Sit = Valor opicional, indicando se deve ou não adicionar a situação return = Dicionário com várias informações sobre a situação da turma. ''' dic_notas = dict() dic_notas['total'] = len(notas) dic_notas['maior'] = max(notas) dic_notas['menor'] = min(notas) dic_notas['media'] = sum(notas)/len(notas) if sit: if dic_notas['media'] >= 7: dic_notas['situacao'] = 'Boa' elif dic_notas['media'] < 7: dic_notas['situacao'] = 'Ruim' return dic_notas resp = notas(2, 3, 10, 6.5, sit=True) print(resp)

[@alexandreoliveira2756]

def notas(): """A função notas retorna, para uma lista de notas escolares inseridas pelo usuário, um dicionário contendo o seguinte conteúdo: -Quantidade de notas -A maior nota -A menor nota -A média da turma -A situação (opcional para o usuário) Com cada índice do dicionário tendo o título correspondente acima. :return: """ no = [] maior = t = x = 0 menor = 10 n = int(input('Quantas notas tem? ')) for i in range(n): no.append(int(input(f'Digite a {i + 1}ª nota: '))) if maior < no[i]: maior = no[i] if menor > no[i]: menor = no[i] t += no[i] if no[i] < 7: x += 1 dic={} dic['Quantidade de notas']=n dic['maior nota']=maior dic['menor nota']=menor dic['média da turma']=t/n op=input('Você quer saber a situação da turma? [S/N] ').upper() if op=='S': if x >= n / 3: dic['Situação'] = 'Tá tensa' else: dic['Situação'] = 'Tá sussa' return dic print('-='*15) print(notas())

[@inexus4366]

mano, era só usara função max

[@gabrielchubiscogregrgg7036]

primeira vez que meu programa fica menor que o do Gustavo :D

[@raphaelangel8294]

bem tranquila em def notas_aluno(*notas, sit): """ FUNCAO NOTAS ALUNOS :parametro1: *notas - e como uma tupla que vai mostrar as notas dos alunos, podendo inserir quantos valores quiser. :parametro2: sit - operador boleano para identificar a situacao da turma (BOA, MEDIA, RUIM) RETURN: vai retornar um dicionário com informações da turma: Quantidade de notas; Maior nota; Menor nota; Media da turma; Situacao da turma se sit == True """ alunos, cont, maior, menor, media = {}, 0, 0, 0, 0 for ind, vale in enumerate(notas): if ind == 0: maior = vale menor = vale else: if vale > maior: maior = vale if vale < menor: menor = vale cont += 1 media = sum(notas) / cont alunos['quantidade'] = cont alunos['maior'] = maior alunos['menor'] = menor alunos['media'] = media if sit: if alunos['media'] >= 7: alunos['situação'] = 'BOA' elif alunos['media']

[@jacksonbarbosa1752]

Finamente Guanabara, moço , demorou hien. Vlw . ver se não demora mais cara pf.

[@Kaique120]

# Faça um programa que tenha uma função notas() que pode receber várias notas de alunos e vai retornar um dicionário com as seguintes informações: # - Quanidade de notas # - A maior nota # - A menor nota # - A média da turma # - Situação ( opcional ) = acima de 7 boa, 6 = razoavel 4 = ruim # Adcione também as docstrings a função def notas(a, b=True): info = dict() info['Quantidade de notas'] = len(a) info['A maior nota'] = max(a) info['A menor nota'] = min(a) info['Média'] = sum(a)/len(a) if b == True: if info['Média'] >= 7: info['Situação'] = 'boa' elif info['Média'] >= 5: info['Situação'] = 'Razoavel' else: info['Situação'] = 'Ruim' return info pro = list() while True: a = int(input('Várias notas: ')) if a == 0: break pro.append(a) print(notas(pro))

Minha solução: Obs: inicialmente eu apliquei com o *num, mas normalmente prefiro trabalhar com inputs e essa foi a melhor forma que eu encontrei pra aplicar: def notas(sit=False): """ -> Função para analisar a situação de notas da turma. :nt[]: lista que receberá a nota de cada aluno. :param sit: Valor opcional, idicando se deve ou não adicionar a situação :return: divionário com várias informações sobre a situação da turma """ nt = [] while True: nota = int(input('Digite a nota do aluno: ')) nt.append(nota) esc = str(input('Deseja adicionar mais notas? [S/N] ')).strip().lower() if esc == 'n': break media = sum(nt) / len(nt) turma = {'total': len(nt), 'maior': max(nt), 'menor': min(nt), 'média': media} if sit: if media < 4: turma['situação'] = 'Ruim' elif 4

[@nextS2]

n creio q eu fiquei o curso todo fazendo If c > maior: maior = c pra no final o guanabara mostrar um comando que faz exatamente isso

[@carlosleter]

def notas(*n, sit=False): """ → Função para analisar notas e situações de vários alunos :param n: aceita uma ou várias notas :param sit: (Opcional), indica se deve ou não mostrar a situação :return: retorna um dicionário com as informações preenchidas. """ d = {'Total': len(n), 'Maior': max(n), 'Menor': min(n), 'Média': sum(n) / len(n)} if sit: if d['Média'] < 5: d['Situação'] = 'REPROVADO' elif d['Média'] < 7: d['Situação'] = 'RECUPERAÇÃO' else: d['Situação'] = 'APROVADO' return d r = notas(5.2, 9.5, 8.2, 7.5, sit=True) print(r) print('-'*80) help(notas)

[@rockemback123]

def notas(*args, sit=False): """ -> Função para analisar notas e a situação do aluno. :param args: Uma nota ou mais dos alunos(aceita várias notas). :param sit: Mostra a situação do aluno, Reprovado, Recuperação ou Aprovado. (OPCIONAL) :return: Retorna um dict com as informações passadas dos alunos da turma. """ resposta = {} resposta['total'] = len(args) resposta['maior'] = max(args) resposta['menor'] = min(args) resposta['média'] = (sum(args)) / len(args) if sit: if resposta['média'] < 5: resposta['situação'] = 'Reprovado' elif resposta['média'] < 7: resposta['situação'] = 'Recuperação' else: resposta['situação'] = 'Aprovado' return resposta resp = notas(2, 7.9, 9.9, 8.2, sit=True) print(resp)

[@marcosdg]

Finalmente!!!! Ehhhh vivvvaaaaaaaaaaaaaa!!!!!!

[@Hebaran]

Ficou assim: from os import system system('cls') def notes(*student_notes, situation=False): """ -> Função para analizar a(s) nota(s) e a situação de um ou mais alunos(as). :param n: Uma ou mais notas do(s) alunos(as). :param situation: [Parâmetro opcional (Defalt=False)] Mostrar ou não a situação do(s) alunos(as). :return: Retorna um dicionário com várias informações sobre um ou mais alunos(as). """ student_stats = { 'Total': 0, 'Maior': 0, 'Menor': 0, 'Média': 0 } for note in student_notes: student_stats['Total'] += 1 student_stats['Média'] += note if note > student_stats['Maior'] or student_stats['Total'] == 1: student_stats['Maior'] = note if note < student_stats['Menor'] or student_stats['Total'] == 1: student_stats['Menor'] = note student_stats['Média'] /= student_stats['Total'] student_stats['Média'] = '{0:.2f}'.format(student_stats['Média']) student_stats['Média'] = float(student_stats['Média']) if situation: if student_stats['Média'] < 5: student_stats['Situação'] = 'RUIM' elif student_stats['Média'] < 7: student_stats['Situação'] = 'RAZOÁVEL' else: student_stats['Situação'] = 'BOA' return student_stats answer = notes(5.5, 9.5, 10, 6.5, situation=True) print(answer)

[@paulohenriqueoliveira4605]

def notas(*notas, situacao=False): """ -> Função para analisar notas e situações de vários alunos. :param notas: uma ou mais notas dos alunos (aceita várias) :param situacao: valor opcional, indicando se deve ou não adicionar a situação :return dicionário com várias informações sobre a situação da turma. """ media = sum(notas)/len(notas) n = {'total': len(notas), 'maior': max(notas), 'menor': min(notas), 'média': media} if situacao == True: if media > 7: situacao = 'Boa' elif media < 7 and media > 5: situacao = 'Razoável' else: situacao = 'Ruim' n.update({'situação': situacao}) return n # main program resp = notas(3.5, 2, 6.5, 9, 10, 8.8, 5, 9, situacao=True) print(resp) help(notas)

[@miickeypdrp5819]

inf = {} def dados(*notas, s=False): """ -> funcao para analisar a situacao de varios alunos. :arg1: notas = quantas notas voce quiser. :arg2: s = situacao dos alunos. :return: as informacoes e situacao de varios alunos. """ m = 0 inf["total"] = len(notas) inf["maior"] = max(notas) inf["menor"] = min(notas) inf["média"] = sum(notas)/len(notas) if s: if inf["média"] >= 10: inf["situação"] = "boa" elif inf["média"] >= 5: inf["situação"] = "razoável" else: inf["situação"] = "ruim" else: inf["média"] = sum(notas)/len(notas) from random import randint dados(randint(1, 15),randint(1, 15),randint(1, 15), s=True) print(inf)

[@renan1231]

def notas(*n, sit=False): """ -> Função para analisar notas e situações de vários alunos. Param n: uma ou mais notas dos alunos (aceita várias). :param sit: valor opcional, indicando se deve ou não mostrar situação. Return: dicionário com várias informações sobre a situação da turma. """ resultado = {"total": len(n), "maior": max(n), "menor": min(n), "média": (sum(n)) / len(n)} if sit: if 5 < resultado["média"] < 7: resultado["situação"] = 'RAZOÁVEL' elif resultado["média"] < 5: resultado["situação"] = 'RUIM' else: resultado["situação"] = 'BOA' return resultado print(notas(5.5, 9.5, 10, 6.5, sit=True))

[@1977ecruz]

# Desafio 105 # Crie um algoritmo q tenha uma função notas() q pode receber várias notas de alunos e vai retornar um dicionário com as seguintes info.: # A) Qtd de notas; B) A maior nota; C) A menor nota; D) A média da turma; C) A situação opcional; D) Adicionar as docstrings. def notas(*n, sit=False): """ F) -> Função para analisar notas e situações de vários alunos: Parâmetro n: Uma ou mais notas dos alunos (aceita várias); Parâmetro sit: Valor opcional, indicando se deve ounão adicionar a situação; Return: Dicionário com várias informações sobre a situação da turma. """ r = {} r['A) Qtd de notas'] = len(n) r['B) Maior nota'] = max(n) r['C) Menor nota'] = min(n) r['D) Média'] = sum(n) / len(n) if sit: if r['D) Média'] >= 7: r['E) Situação'] = 'Boa' if r['D) Média'] >= 5: r['E) Situação'] = 'Razoável' else: r['E) Situação'] = 'Ruim' return r # Programa principal res = notas(5.5, 2.5, 8.5, sit=True) print(res) help(notas) # Valeu Guanabara!!!

[@Djheffeson]

NÃO ACREDITO QUE VOLTOU AAAAAAAAAAAAAAAAAAAAAAAA

[@RsantZp]

mesmo colocando [ if situação: ], sem declarar True, a estrutura já sabe que eu quero dizer "Se situação for Verdadeira.... "

[@atumnalataecachorra2313]

def notas(*num, Sit): """-> Analisa a nota e situação de um aluno :param num: uma ou mais notas do aluno (aceita várias) :param sit: opcional, indica se deve ou não mostrar a situação do aluno :return: dicionário com as notas (e talvez a situação) do aluno""" resultado = {'Total': len(num), 'Maior': max(num), 'Menor': min(num), 'Média': (sum(num)/(len(num)))} if Sit: if resultado['Média'] >= 7: resultado['Sit'] = 'APROVADO' else: resultado['Sit'] = 'REPROVADO' return resultado x = notas(5.5, 9.5, 10, 6.5, Sit=True) print(x)

[@certsolution]

Continuo a me enrolar com os conceitos True e False, vôte! Consegui, ao menos (mesmo que cheio de gambiarras, reconheço) a pôr a questão dos números para funcionar, mas a questão do condicional está me complicando. Vou olhar como o Guanabara resolve e aprender. ''' Crie um programa que tenha a função notas(), a qual pode receber várias notas de alunos e vai retornar um dicionário com as seguintes informações: - quantidade de notas; = a maior nota - a menor nota - a média da turma - a situação (opcional) Adicione também o docstrings da Função ''' def notas(*num, sit=False): totnotas = [] dic = {} somanotas = 0 totnotas = [num] for v in num: somanotas += v media = somanotas/len(num) if media > 7: dic = {'Total': len(num), 'Maior': max(num), 'Menor': min(num), 'Media': media, 'Situação':'Boa'} elif media < 5: dic = {'Total': len(num), 'Maior': max(num), 'Menor': min(num), 'Media': media, 'Situação': 'Péssima'} else: dic = {'Total': len(num), 'Maior': max(num), 'Menor': min(num), 'Media': media, 'Situação': 'Razoável'} return dic ''' Carrega um dicionário através de parâmetros digitados ''' resp = notas(1, 6, 4, 1, 9, sit=True) print(resp)

[@wellington_Lacerda]

Depois de terminar o curso irei refazer denovo, tem muitos códigos que e Eu já me esqueci

[@lucianoleitte1918]

Esperando Estrutura de dados ou quem sabe alguma coisa na área de inteligencia artificial.