5
respostas

[Projeto] HORA DA PRÁTICA

Bom Dia, segue resolução dos Exercícios

Link Notebook: https://colab.research.google.com/drive/11IvgrozBzLdkJ_hd8nMkaUZIgzJIIIuy?usp=sharing

  1. Faça um programa que tenha a seguinte lista contendo os valores de gastos de uma empresa de papel [2172.54, 3701.35, 3518.09, 3456.61, 3249.38, 2840.82, 3891.45, 3075.26, 2317.64, 3219.08]. Com esses valores, faça um programa que calcule a média de gastos. Dica: use as funções built-in sum() e len().
# AREA DE VARIÁVEIS

gastos = [2172.54, 3701.35, 3518.09, 3456.61, 3249.38, 2840.82, 3891.45, 3075.26, 2317.64, 3219.08]

soma_gastos = sum(gastos)
quantidade_gastos = len(gastos)

# PROCESSAMENTO
media_gastos = soma_gastos / quantidade_gastos

# SAÍDA
print("RESULTADO----------------------------------------------------")
print(f"A média de gastos da empresa é.......: R$ {media_gastos:.2f}")
print("-------------------------------------------------------------")
  1. Com os mesmos dados da questão anterior, defina quantas compras foram realizadas acima de 3000 reais e calcule a porcentagem quanto ao total de compras.
# AREA DE VARIÁVEIS
# Reutilizamos a lista 'gastos' já definida na célula anterior.

# PROCESSAMENTO
compras_acima_3000 = 0
for gasto in gastos:
    if gasto > 3000:
        compras_acima_3000 += 1

total_compras = len(gastos)

if total_compras > 0:
    porcentagem_acima_3000 = (compras_acima_3000 / total_compras) * 100
else:
    porcentagem_acima_3000 = 0

# SAÍDA
print("RESULTADO----------------------------------------------------")
print(f"Número de compras acima de R$ 3000,00..............: {compras_acima_3000}")
print(f"Porcentagem de compras acima de R$ 3000,00.........: {porcentagem_acima_3000:.2f}%")
print("--
  1. Faça um código que colete em uma lista 5 números inteiros quaisquer e imprima a lista. Exemplo: [1,4,7,2,4].
# AREA DE VARIÁVEIS
lista_numeros_input = []

# PROCESSAMENTO

print("Por favor, digite 5 números inteiros:")
for i in range(5):
    while True:
        try:
            numero = int(input(f"Digite o {i+1}º número: "))
            lista_numeros_input.append(numero)
            break
        except ValueError:
            print("Entrada inválida. Por favor, digite um número inteiro.")

# SAÍDA

print("\nNUMEROS INTEIROS---------------------------------------------")
print(f"A lista de números inteiros coletados é: {lista_numeros_input}")
print("---------------------------------------------------------------")
  1. Colete novamente 5 inteiros e imprima a lista em ordem inversa à enviada.
# AREA DE VARIÁVEIS
lista_numeros_inversa = []

# PROCESSAMENTO
print("Por favor, digite 5 números inteiros novamente para a lista inversa:")
for i in range(5):
    while True:
        try:
            numero = int(input(f"Digite o {i+1}º número: "))
            lista_numeros_inversa.append(numero)
            break
        except ValueError:
            print("Entrada inválida. Por favor, digite um número inteiro.")

lista_numeros_inversa.reverse() # Inverte a ordem da lista

# SAÍDA
print("\nLISTA INVERSA---------------------------------------------------------")
print(f"A lista de números inteiros em ordem inversa é: {lista_numeros_inversa}")
print("------------------------------------------------------------------------")
  1. Faça um programa que, ao inserir um número qualquer, cria uma lista contendo todos os números primos entre 1 e o número digitado.
# AREA DE VARIÁVEIS
lista_primos = []
numero_limite = 0

# FUNÇÃO PARA VERIFICAR SE UM NÚMERO É PRIMO
def is_prime(num):
    if num <= 1:
        return False
    if num == 2:
        return True
    if num % 2 == 0:
        return False
    i = 3
    while i * i <= num:
        if num % i == 0:
            return False
        i += 2
    return True

# PROCESSAMENTO
print("Por favor, digite um número inteiro para encontrar os primos até ele:")
while True:
    try:
        numero_limite = int(input("Digite o número limite: "))
        if numero_limite < 1:
            print("Por favor, digite um número inteiro maior ou igual a 1.")
        else:
            break
    except ValueError:
        print("Entrada inválida. Por favor, digite um número inteiro.")

for num in range(2, numero_limite + 1):
    if is_prime(num):
        lista_primos.append(num)

# SAÍDA
print("\nLISTA DE NUMEROS PRIMOS")
print(f"A lista de números primos entre 1 e {numero_limite} é: {lista_primos}")
5 respostas
  1. Escreva um programa que peça uma data informando o dia, mês e ano e determine se ela é válida para uma análise.
from datetime import datetime

# AREA DE VARIÁVEIS
dia = 0
mes = 0
ano = 0

# PROCESSAMENTO
print("Por favor, digite uma data para verificar sua validade:")

while True:
    try:
        dia = int(input("Digite o dia (ex: 15): "))
        if not (1 <= dia <= 31):
            print("Dia inválido. Por favor, digite um número entre 1 e 31.")
            continue

        mes = int(input("Digite o mês (ex: 7): "))
        if not (1 <= mes <= 12):
            print("Mês inválido. Por favor, digite um número entre 1 e 12.")
            continue

        ano = int(input("Digite o ano (ex: 2023): "))

        try:
            data_analise = datetime(ano, mes, dia)
            print("\nDATAVALIDA")
            print(f"A data {dia:02d}/{mes:02d}/{ano} é uma data válida para análise.")
            break
        except ValueError:
            print(f"A data {dia:02d}/{mes:02d}/{ano} não é uma data válida (ex: Fevereiro tem 29 dias em ano bissexto, 28 em outros). Por favor, tente novamente.")

    except ValueError:
        print("Entrada inválida. Por favor, digite números inteiros para dia, mês e ano.")

Momento dos projetos

  1. Para um estudo envolvendo o nível de multiplicação de bactérias em uma colônia, foi coletado o número de bactérias por dia (em milhares) e pode ser observado a seguir: [1.2, 2.1, 3.3, 5.0, 7.8, 11.3, 16.6, 25.1, 37.8, 56.9]. Tendo esses valores, faça um código que gere uma lista contendo o percentual de crescimento de bactérias por dia, comparando o número de bactérias em cada dia com o número de bactérias do dia anterior. Dica: para calcular o percentual de crescimento usamos a seguinte equação: 100 * (amostra_atual - amostra_passada) / (amostra_passada).
# AREA DE VARIÁVEIS
numero_bacterias = [1.2, 2.1, 3.3, 5.0, 7.8, 11.3, 16.6, 25.1, 37.8, 56.9]
percentual_crescimento = []

# PROCESSAMENTO
# Iterar a partir do segundo dia (índice 1) para comparar com o dia anterior
for i in range(1, len(numero_bacterias)):
    amostra_atual = numero_bacterias[i]
    amostra_passada = numero_bacterias[i-1]

    # Calcular o percentual de crescimento
    if amostra_passada != 0:
        crescimento = 100 * (amostra_atual - amostra_passada) / amostra_passada
        percentual_crescimento.append(crescimento)
    else:
        # Lidar com o caso de amostra_passada ser zero para evitar divisão por zero
        percentual_crescimento.append(float('inf')) # Infinito, ou outro valor indicativo

# SAÍDA
print("\nRESULTADO")
print(f"Número de bactérias por dia (em milhares): {numero_bacterias}")

# Formata cada elemento da lista para duas casas decimais
percentual_crescimento_formatado = [f"{p:.2f}%" for p in percentual_crescimento]

print("\nTABELA DE CRESCIMENTO BACTERIANO")
print("------------------------------------------------------------------------")
print(f"{'Número de Bactérias (milhares)':<30} | {'% Crescimento por Dia':<25}")
print("------------------------------------------------------------------------")

# Imprime a primeira linha (dia 1) sem percentual de crescimento
print(f"{numero_bacterias[0]:<30.2f} |")

# Imprime as linhas restantes com o percentual de crescimento
for i in range(len(percentual_crescimento_formatado)):
    print(f"{numero_bacterias[i+1]:<30.2f} | {percentual_crescimento_formatado[i]:<25}")

print("------------------------------------------------------------------------")
  1. Para uma seleção de produtos alimentícios, precisamos separar o conjunto de IDs dados por números inteiros sabendo que os produtos com ID par são doces e os com ID ímpar são amargos. Monte um código que colete 10 IDs. Depois, calcule e mostre a quantidade de produtos doces e amargos.
# AREA DE VARIÁVEIS
ids_coletados = []
doces_count = 0
amargos_count = 0

# PROCESSAMENTO
print("Por favor, digite 10 IDs de produtos alimentícios:")
for i in range(10):
    while True:
        try:
            product_id = int(input(f"Digite o {i+1}º ID: "))
            ids_coletados.append(product_id)
            break
        except ValueError:
            print("Entrada inválida. Por favor, digite um número inteiro para o ID.")

for product_id in ids_coletados:
    if product_id % 2 == 0:
        doces_count += 1
    else:
        amargos_count += 1

# SAÍDA
print("\nALIMENTOS--------------------------------------------------")
print(f"IDs coletados: {ids_coletados}\n")
print(f"Quantidade de produtos doces (ID par)........: {doces_count}")
print(f"Quantidade de produtos amargos (ID ímpar)....: {amargos_count}")
print("--------------------------------------------------------------")
  1. Desenvolva um programa que informa a nota de um(a) aluno(a) de acordo com suas respostas. Ele deve pedir a resposta desse(a) aluno(a) para cada questão e é preciso verificar se a resposta foi igual ao gabarito. Cada questão vale um ponto e existem as alternativas A, B, C ou D.
# AREA DE VARIÁVEIS
gabarito = ['A', 'B', 'C', 'D', 'A'] # Exemplo de gabarito com 5 questões
respostas_aluno = []
nota_final = 0

# PROCESSAMENTO
print("\\nPor favor, digite a resposta do aluno para cada questão (A, B, C ou D):")

for i in range(len(gabarito)):
    while True:
        resposta = input(f"Questão {i+1}: ").upper()
        if resposta in ['A', 'B', 'C', 'D']:
            respostas_aluno.append(resposta)
            break
        else:
            print("Resposta inválida. Por favor, digite A, B, C ou D.")

# Corrigir as respostas e calcular a nota
for i in range(len(gabarito)):
    if respostas_aluno[i] == gabarito[i]:
        nota_final += 1

# SAÍDA
print("\nGABARITEI")
print(f"Gabarito: {gabarito}")
print(f"Respostas do Aluno...: {respostas_aluno}")
print(f"Nota final do aluno..: {nota_final} de {len(gabarito)}")
  1. Um instituto de meteorologia deseja fazer um estudo de temperatura média de cada mês do ano. Para isso, você precisa fazer um código que colete e armazene essas temperaturas médias em uma lista. Depois, calcule a média anual das temperaturas e mostre todas as temperaturas acima da média anual e em que mês elas ocorreram, mostrando os meses por extenso (Janeiro, Fevereiro, etc.).
# AREA DE VARIÁVEIS
meses_por_extenso = [
    "Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho",
    "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"
]
temperaturas_medias = []

# PROCESSAMENTO
print("Por favor, digite a temperatura média para cada mês do ano:")
for i in range(12):
    while True:
        try:
            temp = float(input(f"Temperatura média de {meses_por_extenso[i]}: "))
            temperaturas_medias.append(temp)
            break
        except ValueError:
            print("Entrada inválida. Por favor, digite um número para a temperatura.")

# Calcular a média anual
soma_temperaturas = sum(temperaturas_medias)
media_anual = soma_temperaturas / len(temperaturas_medias)

# SAÍDA
print("\nTEMPERATURAS\n")
print(f"Temperaturas médias coletadas: {temperaturas_medias}")
print(f"Média anual das temperaturas: {media_anual:.2f}°C")

print("\nMeses com temperatura acima da média anual:")
for i in range(len(temperaturas_medias)):
    if temperaturas_medias[i] > media_anual:
        print(f"{meses_por_extenso[i]}: {temperaturas_medias[i]:.2f}°C")
  1. Uma empresa de e-commerce está interessada em analisar as vendas dos seus produtos. Os dados das vendas foram armazenados em um dicionário:
{'Produto A': 300, 'Produto B': 80, 'Produto C': 60, 'Produto D': 200, 'Produto E': 250, 'Produto F': 30}

Escreva um código que calcule o total de vendas e o produto mais vendido.

import collections

# AREA DE VARIÁVEIS
vendas_produtos = {
    'Produto A': 300, 'Produto B': 80, 'Produto C': 60,
    'Produto D': 200, 'Produto E': 250, 'Produto F': 30
}

total_vendas = 0
produto_mais_vendido = ''
maior_venda = 0

# PROCESSAMENTO
total_vendas = sum(vendas_produtos.values())

# Encontrar o produto mais vendido
# collections.Counter pode ser usado para encontrar o item mais comum, 
# mas aqui precisamos do maior valor de venda
# Podemos iterar diretamente ou usar max() com uma chave
produto_mais_vendido = max(vendas_produtos, key=vendas_produtos.get)
maior_venda = vendas_produtos[produto_mais_vendido]

# SAÍDA
print("MAIS VENDAS---------------------------------------------------")
print(f"Total de vendas.....: R$ {total_vendas:.2f}")
print(f"Produto mais vendido: {produto_mais_vendido} (R$ {maior_venda:.2f})")
print("--------------------------------------------------------------")
  1. Uma pesquisa de mercado foi feita para decidir qual design de marca infantil mais agrada as crianças. A pesquisa foi feita e o votos computados podem ser observados abaixo:
Tabela de votos da marca
Design 1 - 1334 votos
Design 2 - 982 votos
Design 3 - 1751 votos
Design 4 - 210 votos
Design 5 - 1811 votos

Adapte os dados fornecidos para uma estrutura de dicionário. A partir dele, informe o design vencedor e a porcentagem de votos recebidos.

# AREA DE VARIÁVEIS
votos_design = {
    'Design 1': 1334,
    'Design 2': 982,
    'Design 3': 1751,
    'Design 4': 210,
    'Design 5': 1811
}

design_vencedor = ''
votos_vencedor = 0
total_votos = 0
percentual_vencedor = 0.0

# PROCESSAMENTO
total_votos = sum(votos_design.values())

# Encontrar o design vencedor
design_vencedor = max(votos_design, key=votos_design.get)
votos_vencedor = votos_design[design_vencedor]

# Calcular a porcentagem de votos do vencedor
if total_votos > 0:
    percentual_vencedor = (votos_vencedor / total_votos) * 100

# SAÍDA
print("RESULTADO----------------------------------------------------")
print(f"Total de votos computados: {total_votos}")
print(f"Design Vencedor: {design_vencedor}")
print(f"Votos do Design Vencedor: {votos_vencedor}")
print(f"Porcentagem de votos do vencedor: {percentual_vencedor:.2f}%")
print("--------------------------------------------------------------")
  1. As pessoas colaboradoras de um setor da empresa que você trabalha vão receber um abono correspondente a 10% do salário devido ao ótimo desempenho do time. O setor financeiro solicitou sua ajuda para a verificação das consequências financeiras que esse abono irá gerar nos recursos. Assim, foi encaminhada para você uma lista com os salários que receberão o abono: [1172, 1644, 2617, 5130, 5532, 6341, 6650, 7238, 7685, 7782, 7903]. O abono de cada colaborador(a) não pode ser inferior a 200. Em código, transforme cada um dos salários em chaves de um dicionário e o abono de cada salário no elemento. Depois, informe o total de gastos com o abono, quantos(as) colaboradores(as) receberam o abono mínimo e qual o maior valor de abono fornecido.
# AREA DE VARIÁVEIS
salarios = [1172, 1644, 2617, 5130, 5532, 6341, 6650, 7238, 7685, 7782, 7903]
percentual_abono = 0.10 # 10%
abono_minimo = 200

abonos_por_salario = {}
total_gastos_abono = 0
colaboradores_abono_minimo = 0
maior_abono_fornecido = 0

# PROCESSAMENTO
for salario in salarios:
    abono_calculado = salario * percentual_abono
    abono_final = max(abono_calculado, abono_minimo)
    abonos_por_salario[salario] = abono_final

    total_gastos_abono += abono_final

    if abono_final == abono_minimo:
        colaboradores_abono_minimo += 1

    if abono_final > maior_abono_fornecido:
        maior_abono_fornecido = abono_final

# SAÍDA
print("RESULTADO----------------------------------------------------")
print("Abonos por Salário (Salário: Abono):")
for salario, abono in abonos_por_salario.items():
    print(f"R$ {salario:.2f}: R$ {abono:.2f}")
print("--------------------------------------------------------------")
print(f"Total de gastos com abono: R$ {total_gastos_abono:.2f}")
print(f"Colaboradores que receberam o abono mínimo (R$ {abono_minimo:.2f}): {colaboradores_abono_minimo}")
print(f"Maior valor de abono fornecido: R$ {maior_abono_fornecido:.2f}")
print("--------------------------------------------------------------")
  1. Uma equipe de cientistas de dados está estudando a diversidade biológica em uma floresta. A equipe fez a coleta de informações sobre o número de espécies de plantas e animais em cada área dessa floresta e armazenou essas informações em um dicionário. Nele, a chave descreve a área dos dados e os valores nas listas correspondem às espécies de plantas e animais nas áreas, respectivamente.
{'Área Norte': [2819, 7236],
 'Área Leste': [1440, 9492],
 'Área Sul': [5969, 7496],
 'Área Oeste': [14446, 49688],
 'Área Centro': [22558, 45148]}

Escreva um código para calcular a média de espécies por área e identificar a área com a maior diversidade biológica. Dica: use as funções built-in sum() e len().

# AREA DE VARIÁVEIS
diversidade_biologica = {
    'Área Norte': [2819, 7236],
    'Área Leste': [1440, 9492],
    'Área Sul': [5969, 7496],
    'Área Oeste': [14446, 49688],
    'Área Centro': [22558, 45148]
}

totais_especies_por_area = {}
media_especies_por_area = 0
area_maior_diversidade = ''
maior_diversidade = 0

# PROCESSAMENTO
for area, especies in diversidade_biologica.items():
    total_especies_area = sum(especies)
    totais_especies_por_area[area] = total_especies_area

    if total_especies_area > maior_diversidade:
        maior_diversidade = total_especies_area
        area_maior_diversidade = area

# Calcular a média de espécies por área (considerando a média dos totais de cada área)
if len(totais_especies_por_area) > 0:
    media_especies_por_area = sum(totais_especies_por_area.values()) / len(totais_especies_por_area)

# SAÍDA
print("RESULTADO----------------------------------------------------")
print("Total de espécies por área:")
for area, total in totais_especies_por_area.items():
    print(f"{area}: {total} espécies")
print("--------------------------------------------------------------")
print(f"Média de espécies por área: {media_especies_por_area:.2f}")
print(f"Área com a maior diversidade biológica: {area_maior_diversidade} ({maior_diversidade} espécies)")
print("--------------------------------------------------------------")
  1. O setor de RH da sua empresa te pediu uma ajuda para analisar as idades de colaboradores(as) de 4 setores da empresa. Para isso, foram fornecidos os seguintes dados:
{'Setor A': [22, 26, 30, 30, 35, 38, 40, 56, 57, 65],
 'Setor B': [22, 24, 26, 33, 41, 49, 50, 54, 60, 64],
 'Setor C': [23, 26, 26, 29, 34, 35, 36, 41, 52, 56],
 'Setor D': [19, 20, 25, 27, 34, 39, 42, 44, 50, 65]}

Sabendo que cada setor tem 10 colaboradores(as), construa um código que calcule a média de idade de cada setor, a idade média geral entre todos os setores e quantas pessoas estão acima da idade média geral.

# AREA DE VARIÁVEIS
idades_colaboradores = {
    'Setor A': [22, 26, 30, 30, 35, 38, 40, 56, 57, 65],
    'Setor B': [22, 24, 26, 33, 41, 49, 50, 54, 60, 64],
    'Setor C': [23, 26, 26, 29, 34, 35, 36, 41, 52, 56],
    'Setor D': [19, 20, 25, 27, 34, 39, 42, 44, 50, 65]
}

medias_por_setor = {}
idades_geral = []
media_geral = 0
colaboradores_acima_media_geral = 0

# PROCESSAMENTO
# Calcular a média de idade de cada setor e coletar todas as idades
for setor, idades in idades_colaboradores.items():
    media_setor = sum(idades) / len(idades)
    medias_por_setor[setor] = media_setor
    idades_geral.extend(idades)

# Calcular a idade média geral entre todos os setores
if len(idades_geral) > 0:
    media_geral = sum(idades_geral) / len(idades_geral)

# Contar quantas pessoas estão acima da idade média geral
for idade in idades_geral:
    if idade > media_geral:
        colaboradores_acima_media_geral += 1

# SAÍDA
print("RESULTADO----------------------------------------------------")
print("Média de idade por setor:")
for setor, media in medias_por_setor.items():
    print(f"{setor}: {media:.2f} anos")
print("--------------------------------------------------------------")
print(f"Idade média geral entre todos os setores: {media_geral:.2f} anos")
print(f"Número de colaboradores(as) acima da idade média geral: {colaboradores_acima_media_geral}")
print("--------------------------------------------------------------")

Olá, Luiz. Como vai?

Parabéns por compartilhar as suas resoluções com a comunidade! Analisando o seu Notebook, o que mais chama a atenção é a excelente organização do seu código. Dividir os scripts em blocos claros de Variáveis, Processamento e Saída é uma ótima prática que facilita muito a leitura e a manutenção do código, algo fundamental no dia a dia da Ciência de Dados. Além disso, você mandou muito bem ao utilizar o parâmetro key=votos_design.get na função max() no exercício da pesquisa de mercado!

Como você já está com uma base lógica muito sólida, vou deixar duas dicas de abordagens "pythônicas" (formas mais nativas e otimizadas de escrever em Python) para você adicionar ao seu cinto de ferramentas:

1. Contagens com condições (Exercício do RH)
No último exercício, para contar quantas pessoas estavam acima da média, você utilizou um laço for com um if e uma variável contadora. Na análise de dados, é muito comum utilizarmos expressões geradoras junto com a função sum() para resolver isso em uma única linha de forma muito eficiente.

Veja como ficaria:

# O Python interpreta valores Verdadeiros (True) como 1 e Falsos (False) como 0.
# Portanto, podemos somar diretamente as condições que retornam True.
colaboradores_acima_media_geral = sum(idade > media_geral for idade in idades_geral)

2. Comparando valores consecutivos (Exercício das Bactérias)
No exercício de crescimento bacteriano, você usou muito bem os índices com range(1, len(numero_bacterias)) para acessar o dia atual e o anterior. Uma outra forma muito elegante e nativa do Python de parear itens consecutivos de uma lista é utilizando a função zip() juntamente com o fatiamento (slicing) da lista.

Exemplo:

# numero_bacterias[:-1] pega todos os itens menos o último (amostras passadas)
# numero_bacterias[1:] pega todos os itens menos o primeiro (amostras atuais)

for amostra_passada, amostra_atual in zip(numero_bacterias[:-1], numero_bacterias[1:]):
    crescimento = 100 * (amostra_atual - amostra_passada) / amostra_passada
    percentual_crescimento.append(crescimento)

O zip() é uma ferramenta poderosíssima que você certamente usará bastante ao manipular dados em bibliotecas maiores, como o Pandas.

Continue com esse excelente ritmo de estudos e organização!

Espero que possa ter lhe ajudado!