exercicios revisão.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercícios Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sua empresa resolveu pagar uma bonificação de R$1.000 para todos os funcionários com mais de 20 anos de casa. Quanto vai custar a ação de bonificação para a sua empresa?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lista contendo os anos de casa dos funcionários\n",
    "anos_casa_funcionarios = [10, 15, 20, 25, 30, 47, 2, 5, 5, 6, 18, 32, 10, 1, 1, 2, 3, 3, 2, 1, 10, 40, 21, 10, 1, 2, 5, 7, 7, 6, 9, 19]\n",
    "\n",
    "# Loop para iterar sobre a lista de anos de casa dos funcionários\n",
    "for i, anos in enumerate(anos_casa_funcionarios):\n",
    "    # Verifica se o funcionário tem mais de 20 anos de casa\n",
    "    if anos > 20:\n",
    "        # Exibe uma mensagem indicando o funcionário e o valor da bonificação\n",
    "        print(f\"Funcionario {i} tem {anos} anos de casa, e vai receber uma bonificação de R$ 1000\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desenvolva um programa que armazene quatro notas em uma lista e que apresente: a média final, a maior nota e a menor nota\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inicializa uma lista vazia para armazenar as notas\n",
    "lista_de_notas = []\n",
    "\n",
    "# Loop para solicitar 4 notas ao usuário\n",
    "for i in range(4):\n",
    "    # Solicita a nota ao usuário e converte para float\n",
    "    nota = float(input(f'Digite a {i+1}° nota: '))\n",
    "    # Adiciona a nota à lista de notas\n",
    "    lista_de_notas.append(nota)\n",
    "\n",
    "# Calcula a média das notas e arredonda para uma casa decimal\n",
    "media = round(sum(lista_de_notas) / len(lista_de_notas), 1)\n",
    "\n",
    "# Exibe a média, a maior nota e a menor nota\n",
    "print('A média foi {}, a maior nota foi {} e a menor nota {}'.format(media, max(lista_de_notas), min(lista_de_notas)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desenvolva um programa que armazene quatro notas em uma lista e que apresente a média final. Caso a média seja igual ou superior a 7, apresentar a mensagem \"APROVADO\", caso contrário, armazenar a nota da prova final e recalcular a média (nova média = (antiga média + prova final) / 2). Caso a nova média seja igual superior a 5, apresentar a mensagem \"APROVADO\", caso contrário, apresentar a mensagem \"REPROVADO\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inicializa uma lista vazia para armazenar as notas\n",
    "lista_de_notas = []\n",
    "\n",
    "# Loop para solicitar 4 notas ao usuário\n",
    "for i in range(4):\n",
    "    # Solicita a nota ao usuário e converte para float\n",
    "    nota = float(input(f'Digite a {i+1}° nota: '))\n",
    "    # Adiciona a nota à lista de notas\n",
    "    lista_de_notas.append(nota)\n",
    "\n",
    "# Calcula a média das notas e arredonda para uma casa decimal\n",
    "media = round(sum(lista_de_notas) / len(lista_de_notas), 1)\n",
    "\n",
    "# Verifica se a média é maior ou igual a 7\n",
    "if media >= 7:\n",
    "    print('Aprovado')\n",
    "# Caso a média seja menor que 7\n",
    "elif media < 7:\n",
    "    # Solicita a nota da prova final ao usuário e converte para float\n",
    "    prova_final = float(input('Digite a nota da prova final: '))\n",
    "    # Calcula a nova média considerando a prova final\n",
    "    nova_media = (media + prova_final) / 2\n",
    "    # Verifica se a nova média é maior ou igual a 5\n",
    "    if nova_media >= 5:\n",
    "        print('Aprovado')\n",
    "    # Caso a nova média seja menor que 5\n",
    "    else:\n",
    "        print('Reprovado')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desenvolva um programa que pergunte para o usuário o nome completo, cpf, endereço e duração do contrato e personalize todo o texto do contrato de acordo com as informações dadas.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto_contrato = \"\"\"\n",
    "CONTRATO DE PRESTAÇÃO DE SERVIÇOS PROFISSIONAIS\n",
    "\n",
    "\t\tPelo presente instrumento particular de Contrato de Prestação de Serviços Contábeis, de um lado NOME_CONTRATANTE inscrita no CPF, sob nº CPF_CONTRATANTE,doravante denominada CONTRATANTE, residente e domiciliado(a)  à RUA_CONTRATANTE, Cidade CIDADE_CONTRATANTE, Estado ESTADO_CONTRATANTE, e o Contabilista Fulano, com escritório à Qualquer Lugar, Cidade Rio de Janeiro Estado RJ , inscrito no CNPJ Nº 22222222000100, doravante CONTRATADO(A), mediante as cláusulas e condições seguintes, tem justo e “Contratado” o que se segue:\n",
    "\n",
    "CLAUSULA PRIMEIRA - A contratante neste ato, contrata os serviços profissionais do contratado(a) nas seguintes àreas:\n",
    "\t\t\n",
    "1. Escrituração Contábil.\n",
    "1.1 - Classificação da contabilidade de acordo com  normas e princípios contábeis vigentes;\n",
    "1.2 - Emissão de Balancetes:\n",
    "1.3 - Elaboração de Balanço anual e Demonstrativo de Resultado.\n",
    "\t\t\n",
    "E por estarem de comum acordo, assinam o presente instrumento em duas vias, de igual teor e forma, na presença das testemunhas abaixo.\n",
    "\n",
    "\n",
    "DIA_DATA/MES_DATA/ANO_DATA.\n",
    "\n",
    "\n",
    "_________________________________                      __________________________\n",
    "    Contratante - NOME_CONTRATANTE                                     Contratado(a)\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "import time\n",
    "\n",
    "# Obtém a data atual\n",
    "data_atual = time.localtime()\n",
    "dia_atual = data_atual.tm_mday\n",
    "mes_atual = data_atual.tm_mon\n",
    "ano_atual = data_atual.tm_year\n",
    "\n",
    "# Solicita informações do usuário (contratante)\n",
    "nome_completo = input('Digite o nome completo do(a) CONTRATANTE: ')\n",
    "cpf = input('Digite o número do CPF do(a) CONTRATANTE: ')\n",
    "endereco = input('Digite o endereço do(a) CONTRATANTE: ')\n",
    "cidade = input('Digite a cidade do(a) CONTRATANTE: ')\n",
    "estado = input('Digite o estado do(a) CONTRATANTE: ')\n",
    "\n",
    "# Substitui os placeholders no texto do contrato com as informações fornecidas pelo usuário\n",
    "texto_contrato = texto_contrato.replace('NOME_CONTRATANTE', nome_completo)\n",
    "texto_contrato = texto_contrato.replace('CPF_CONTRATANTE', cpf)\n",
    "texto_contrato = texto_contrato.replace('RUA_CONTRATANTE', endereco)\n",
    "texto_contrato = texto_contrato.replace('CIDADE_CONTRATANTE', cidade)\n",
    "texto_contrato = texto_contrato.replace('ESTADO_CONTRATANTE', estado)\n",
    "texto_contrato = texto_contrato.replace('DIA_DATA', str(dia_atual))\n",
    "texto_contrato = texto_contrato.replace('MES_DATA', str(mes_atual))\n",
    "texto_contrato = texto_contrato.replace('ANO_DATA', str(ano_atual))\n",
    "\n",
    "# Remove quebras de linha no início e no fim da string\n",
    "texto_contrato = texto_contrato.strip('\\n')\n",
    "\n",
    "# Exibe o texto do contrato com as informações preenchidas\n",
    "print(texto_contrato)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Crie um programa que converta a temperatura de celsius para Faremheit\n",
    "    - Agora adapte o programa para ele funcionar para uma lista de temperaturas\n",
    "    - Agora adapte o programa para ele conseguir fazer a conversão tanto de C para F quanto de F para C de acordo com a escolha do usuário."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exibe o título do programa\n",
    "print('Conversor de temperatura Celsius para Fahrenheit')\n",
    "\n",
    "# Solicita ao usuário a temperatura em graus Celsius e converte para float\n",
    "temperatura_celsius = float(input('Digite a temperatura em graus Celsius: '))\n",
    "\n",
    "# Converte a temperatura de Celsius para Fahrenheit\n",
    "temperatura_fahrenheit = (temperatura_celsius * 1.8) + 32\n",
    "\n",
    "# Exibe a temperatura convertida em Fahrenheit\n",
    "print('A temperatura em Fahrenheit é {:.2f}F'.format(temperatura_fahrenheit))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exibe o título do programa\n",
    "print('Conversor de temperatura Celsius para Fahrenheit')\n",
    "\n",
    "# Cria uma lista vazia para armazenar as temperaturas em Celsius\n",
    "lista_de_temperaturas = []\n",
    "\n",
    "# Loop infinito para solicitar temperaturas ao usuário\n",
    "while True:\n",
    "    # Solicita ao usuário uma temperatura em graus Celsius ou a opção de sair (s)\n",
    "    temperatura_celsius = input('Digite a temperatura em graus Celsius ou (s) para sair: ').casefold()\n",
    "    \n",
    "    # Verifica se o usuário digitou 's' para sair\n",
    "    if temperatura_celsius == 's':\n",
    "        # Itera sobre a lista de temperaturas e as converte para Fahrenheit\n",
    "        for i, temperatura in enumerate(lista_de_temperaturas):\n",
    "            temperatura_fahrenheit = (temperatura * 1.8) + 32\n",
    "            # Exibe a temperatura convertida em Fahrenheit\n",
    "            print('A temperatura em Fahrenheit da {}ª temperatura é {:.2f}F'.format(i + 1, temperatura_fahrenheit))\n",
    "        break  # Sai do loop infinito\n",
    "    else:\n",
    "        # Converte a temperatura fornecida para float\n",
    "        temperatura_celsius = float(temperatura_celsius)\n",
    "        # Adiciona a temperatura à lista de temperaturas\n",
    "        lista_de_temperaturas.append(temperatura_celsius)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exibe o título do programa\n",
    "print('Conversor de temperatura Celsius para Fahrenheit')\n",
    "\n",
    "# Solicita ao usuário que escolha a conversão desejada e converte a entrada para minúsculas\n",
    "escolher_temperatura = input('Celsius para Fahrenheit digite F ou Fahrenheit para Celsius digite C: ').casefold()\n",
    "\n",
    "# Verifica se o usuário escolheu converter de Celsius para Fahrenheit\n",
    "if escolher_temperatura == 'c':\n",
    "    # Solicita ao usuário a temperatura em graus Celsius e converte para float\n",
    "    temperatura_celsius = float(input('Digite a temperatura em graus Celsius: '))\n",
    "    # Converte a temperatura de Celsius para Fahrenheit\n",
    "    temperatura_fahrenheit = (temperatura_celsius * 1.8) + 32\n",
    "    # Exibe a temperatura convertida em Fahrenheit\n",
    "    print('A temperatura em Fahrenheit é {:.2f}F'.format(temperatura_fahrenheit))\n",
    "else:\n",
    "    # Solicita ao usuário a temperatura em graus Fahrenheit e converte para float\n",
    "    temperatura_fahrenheit = float(input('Digite a temperatura em graus Fahrenheit: '))\n",
    "    # Converte a temperatura de Fahrenheit para Celsius\n",
    "    temperatura_celsius = (5/9) * (temperatura_fahrenheit - 32)\n",
    "    # Exibe a temperatura convertida em Celsius\n",
    "    print('A temperatura em Celsius é {:.2f}C'.format(temperatura_celsius))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analisador de Telefone\n",
    "\n",
    "- Crie um programa que receba um telefone e verifique se ele é um telefone real brasileiro. Seu programa deve conseguir tratar espaços em branco, parênteses, existência de um 9º dígito no número ou não, existência de DDD ou não e deve obrigar o usuário a inserir o código do País (+55)\n",
    "\n",
    "Válidos:<br>\n",
    "\"+55 21 9799999999\"<br>\n",
    "\"+55 21 799999999 \"<br>\n",
    "\"+55 (21)79999-9999\"<br>\n",
    "\"+5521799999999\"<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verifica_telefone(telefone):\n",
    "    # Remover espaços em branco e parênteses\n",
    "    telefone = telefone.replace(\" \", \"\").replace(\"(\", \"\").replace(\")\", \"\").replace('-','')\n",
    "\n",
    "    # Verificar se o telefone começa com +55\n",
    "    if not telefone.startswith(\"+55\"):\n",
    "        return False\n",
    "\n",
    "    # Remover o +55 do início do telefone\n",
    "    telefone = telefone[3:]\n",
    "\n",
    "    # Verificar se o telefone tem 10 ou 11 dígitos\n",
    "    if len(telefone) != 10 and len(telefone) != 11:\n",
    "        return False\n",
    "\n",
    "    # Verificar se o telefone tem um 9º dígito\n",
    "    if len(telefone) == 11 and telefone[2] != \"9\":\n",
    "        return False\n",
    "\n",
    "    # Verificar se o telefone tem um DDD\n",
    "    if len(telefone) == 10 and telefone[0] != \"0\":\n",
    "        return False\n",
    "\n",
    "    # Verificar se o telefone é composto apenas por dígitos\n",
    "    if not telefone.isdigit():\n",
    "        return False\n",
    "\n",
    "    return True\n",
    "\n",
    "telefone = input(\"Digite o telefone: \")\n",
    "\n",
    "if verifica_telefone(telefone):\n",
    "    print(\"Telefone válido\")\n",
    "else:\n",
    "    print(\"Telefone inválido\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analisador de URL\n",
    "    - Seu programa deve pedir um link/URL para o usuário, como por exemplo: https://www.hashtagtreinamentos.com/blog\n",
    "    - Ele deve analisar essa URL dizendo:\n",
    "        - Domínio: hashtagtreinamentos.com\n",
    "        - Protocolo: HTTPS (tudo que vem antes de começar o endereço da URL, no caso antes do :)\n",
    "        - Caminho: /blog (tudo que vem depois do domínio, a partir da primeira / até antes dos parâmetros de busca)\n",
    "        - Parâmetros de busca: (Tudo que vem depois do ? e são separados entre si por um &. Os links podem ter isso ou não)\n",
    "\n",
    "Exemplos de URL:\n",
    "\n",
    "https://www.hashtagtreinamentos.com/blog<br>\n",
    "https://lp.hashtagtreinamentos.com/inscricao-intensivao-de-python-igfb?origemurl=curso&fonte=portal<br>\n",
    "https://lp.hashtagtreinamentos.com/inscricao-intensivao-de-python-igfb?origemurl=exercicios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solicita ao usuário que digite a URL a ser analisada\n",
    "analisar_url = input('Digite a url a ser analisada: ')\n",
    "\n",
    "# Divide a URL na primeira ocorrência de ':' e converte para maiúsculas\n",
    "protocolo = analisar_url.split(':')[0].upper()\n",
    "\n",
    "# Divide a URL na ocorrência de '//' e pega a parte restante\n",
    "sem_protoco = analisar_url.split('//')[1]\n",
    "\n",
    "# Divide a parte restante da URL na primeira ocorrência de '/' para obter o domínio\n",
    "dominio_completo = sem_protoco.split('/')[0]\n",
    "# Remove o 'www.' do domínio, se estiver presente\n",
    "if dominio_completo.startswith('www.'):\n",
    "    dominio = dominio_completo[4:]\n",
    "\n",
    "# Junta todas as partes da URL que vêm após o domínio principal\n",
    "resto_url = '/'.join(sem_protoco.split('/')[1:])\n",
    "caminho = ''\n",
    "parametros = ''\n",
    "\n",
    "# Verifica se há parâmetros de busca na URL\n",
    "if '?' in resto_url:\n",
    "    # Separa o caminho (parte antes do '?') e os parâmetros de busca (parte após o '?')\n",
    "    caminho = '/' + resto_url.split('?')[0]\n",
    "    parametros = resto_url.split('?')[1]\n",
    "else:\n",
    "    # Se não houver parâmetros de busca, considera o restante da URL como o caminho\n",
    "    caminho = '/' + resto_url\n",
    "\n",
    "# Exibe os resultados: protocolo, domínio, caminho e parâmetros de busca\n",
    "print(f'Protocolo: {protocolo}\\nDomínio: {dominio}\\nCaminho: {caminho}\\nParâmetros: {parametros}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Crie um programa que dado o e-mail de um usuário, valide se aquele e-mail é válido com as seguintes regras:\n",
    "    - Tem que ter .com ou .gov\n",
    "    - Tem que ter @\n",
    "    - Tem que ter mais de 5 caracteres\n",
    "    - Não pode ter espaço"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solicita ao usuário que digite o e-mail\n",
    "email_usuario = input('Digite o email: ')\n",
    "\n",
    "# Função para verificar a validade do e-mail\n",
    "def verificar_email(email_usuario):\n",
    "    # Extrai o domínio do e-mail (parte após o '@' e após o '.')\n",
    "    dominio_email = email_usuario.split('@')[-1].split('.')[-1]\n",
    "    # Lista de domínios válidos\n",
    "    dominios_validos = ['com', 'gov']\n",
    "\n",
    "    # Verifica se o domínio do e-mail está na lista de domínios válidos\n",
    "    if dominio_email not in dominios_validos:\n",
    "        return False\n",
    "\n",
    "    # Verifica se o e-mail contém o caractere '@'\n",
    "    if '@' not in email_usuario:\n",
    "        return False\n",
    "\n",
    "    # Verifica se o e-mail tem pelo menos 6 caracteres\n",
    "    if len(email_usuario) <= 5:\n",
    "        return False\n",
    "\n",
    "    # Verifica se o e-mail contém espaços\n",
    "    if ' ' in email_usuario:\n",
    "        return False\n",
    "\n",
    "    # Se todas as verificações passarem, retorna True (e-mail válido)\n",
    "    return True\n",
    "\n",
    "# Verifica se o e-mail é válido usando a função verificar_email\n",
    "if verificar_email(email_usuario):\n",
    "    print('E-mail válido')\n",
    "else:\n",
    "    print('E-mail inválido')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ToDo List no Terminal\n",
    "\n",
    "Crie um programa para criar uma lista de tarefas para o usuário (mais futuramente no curso, aprenderemos a armazenar essas informações em um banco de dados para essa lista poder ser editada e armazenada)\n",
    "\n",
    "Seu programa deve pedir as tarefas que o usuário tem que fazer em um dia e, a cada inserção de uma nova tarefa, dizer que a tarefa foi adicionada a lista de tarefas. Quando o usuário digitar apenas enter no seu input (sem inserir nenhuma tarefa, seu programa deve printar a quantidade de tarefas para o dia e a lista de tarefas completa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "# Lista para armazenar as tarefas do dia\n",
    "lista_de_tarefas = []\n",
    "\n",
    "# Loop infinito para solicitar tarefas ao usuário\n",
    "while True:\n",
    "    # Solicita ao usuário a tarefa a ser realizada hoje, mostrando a data atual\n",
    "    tarefas_do_dia = input('Digite a tarefa a ser realizada hoje {}: '.format(time.strftime('%d/%m/%Y')))\n",
    "    \n",
    "    # Se o usuário não digitar nada e apenas pressionar Enter\n",
    "    if tarefas_do_dia == '':\n",
    "        # Exibe a quantidade de tarefas e lista todas as tarefas do dia\n",
    "        print('\\nQuantidade de tarefas a ser realizada: {}\\nTarefas do dia:\\n{}\\n'.format(len(lista_de_tarefas), '\\n'.join(lista_de_tarefas)))\n",
    "        break  # Sai do loop infinito\n",
    "    else:\n",
    "        # Verifica se a tarefa já está na lista\n",
    "        if tarefas_do_dia in lista_de_tarefas:\n",
    "            print(f'{tarefas_do_dia} Tarefa já cadastrada')\n",
    "        else:\n",
    "            # Adiciona a nova tarefa à lista de tarefas\n",
    "            lista_de_tarefas.append(tarefas_do_dia)\n",
    "            print(f'{lista_de_tarefas[-1]} foi cadastrada.')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversor de Moedas\n",
    "\n",
    "- Parte 1: Crie um conversor de moedas que pergunte para o usuário qual moeda ele quer converter e para qual moeda destino ele quer converter. Caso alguma das moedas não estejam na lista de conversão, o usuário deve ser informado que essa conversão não é possível. Sendo possível a conversão, o seu conversor de moedas deve em seguida pedir o valor da moeda de origem que ele quer converter para a moeda de destino, fazer a conversão e exibir para o usuário o valor convertido.\n",
    "- Parte 2: Adapte o seu código (crie uma cópia para manter os 2 códigos prontos) para o usuário não precisar dizer qual a moeda original, mas que permita inserir um valor para fazer a conversão com o indicativo da moeda, ex: R$50, US$20 e o sistema fazer a conversão automaticamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dic_conversoes = {\n",
    "    \"R$-US$\": 0.194,\n",
    "    \"US$-R$\": 5.15,\n",
    "    \"R$-BTC\":  0.000002857,\n",
    "    \"BTC-R$\": 350000,\n",
    "    \"BTC-US$\": 67961.16,\n",
    "    \"US$-BTC\": 0.000014714\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exibe as moedas disponíveis para conversão\n",
    "print('Moedas disponíveis para conversão.')\n",
    "valores_impressos = set()\n",
    "for chave in dic_conversoes:\n",
    "    # Extrai a primeira parte da chave antes do '-' para identificar a moeda\n",
    "    valor = chave.split('-')[0]\n",
    "    # Verifica se a moeda já foi impressa para evitar duplicatas\n",
    "    if valor not in valores_impressos:\n",
    "        print(valor)\n",
    "        valores_impressos.add(valor)\n",
    "\n",
    "# Solicita ao usuário a moeda de origem para conversão\n",
    "moeda_converter = input('Digite para qual moeda deseja converter: ')\n",
    "# Verifica se a moeda de origem está disponível para conversão\n",
    "if moeda_converter not in valores_impressos:\n",
    "    print('A moeda informada não possui valor de conversão cadastrado.')\n",
    "else:\n",
    "    # Solicita ao usuário a moeda de destino para conversão\n",
    "    moeda_destino = input('Digite para qual moeda deseja a conversão: ')\n",
    "    # Verifica se a moeda de destino está disponível para conversão\n",
    "    if moeda_destino not in valores_impressos:\n",
    "        print('A moeda informada não possui valor de conversão cadastrado.')\n",
    "    else:\n",
    "        try:\n",
    "            # Solicita ao usuário o valor a ser convertido\n",
    "            valor_da_conversao = float(input('Digite o valor a ser convertido: '))\n",
    "            # Itera sobre as chaves no dicionário de conversões\n",
    "            for chave in dic_conversoes:\n",
    "                chave1, chave2 = chave.split('-')\n",
    "                # Verifica se as moedas de origem e destino correspondem às chaves\n",
    "                if moeda_converter == chave1 and moeda_destino == chave2:\n",
    "                    # Calcula o valor convertido usando o fator de conversão\n",
    "                    valor_convertido = valor_da_conversao * dic_conversoes[chave]\n",
    "                    # Exibe o valor convertido\n",
    "                    print('O valor da conversão de {} para {} é: {}{:.2f}'.format(chave1, chave2, chave2, valor_convertido))\n",
    "        except:\n",
    "            # Trata o caso em que nenhum valor é informado\n",
    "            print('Sem valor informado.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import locale\n",
    "\n",
    "# Configura o local para formatação numérica (português do Brasil)\n",
    "locale.setlocale(locale.LC_ALL, 'PT-br.UTF-8')\n",
    "\n",
    "# Exibe as moedas disponíveis para conversão\n",
    "print('Moedas disponíveis para conversão.')\n",
    "valores_impressos = set()\n",
    "for chave in dic_conversoes:\n",
    "    # Extrai a primeira parte da chave antes do '-' para identificar a moeda\n",
    "    valor = chave.split('-')[0]\n",
    "    # Verifica se a moeda já foi impressa para evitar duplicatas\n",
    "    if valor not in valores_impressos:\n",
    "        print(valor)\n",
    "        valores_impressos.add(valor)\n",
    "\n",
    "# Solicita ao usuário o valor a ser convertido com a cifra\n",
    "moeda_converter = input('Digite o valor a ser convertido com a cifra: ')\n",
    "moeda_converter = moeda_converter.strip()\n",
    "# Define o padrão de expressão regular para separar a cifra e o valor numérico\n",
    "padrao = re.compile(r'([^\\d]+)(\\d+)')\n",
    "resultado = padrao.match(moeda_converter)\n",
    "\n",
    "# Verifica se a entrada do usuário corresponde ao padrão\n",
    "if resultado:\n",
    "    # Extrai a cifra e o valor numérico da entrada\n",
    "    cifra = resultado.group(1)\n",
    "    valor = resultado.group(2)\n",
    "    # Itera sobre as conversões disponíveis\n",
    "    for chave in dic_conversoes:\n",
    "        chave1, chave2 = chave.split('-')\n",
    "        # Verifica se a cifra corresponde a uma das moedas na chave de conversão\n",
    "        if chave1 == cifra or chave2 == cifra:\n",
    "            valor_da_conversão = int(valor) * dic_conversoes[chave]\n",
    "            valor_formatado = locale.format_string('%.4f',valor_da_conversão, grouping=True)\n",
    "            valor_inteiro, valor_decimal = valor_formatado.split(',')\n",
    "        # Exibe a cotação da moeda convertida se a cifra corresponde a uma das chaves\n",
    "        if chave1 == cifra:\n",
    "            print('A cotação da moeda {} e valor {} informado, para a moeda {} é: {}.{}\\t'.format(cifra,valor,chave2,valor_inteiro,valor_decimal))\n",
    "        elif chave2 == cifra:\n",
    "            print('A cotação da moeda {} e valor {} informado, para a moeda {} é: {}.{}\\t'.format(chave1,valor,cifra,valor_inteiro,valor_decimal))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Você está analisando a conta de energia de um pequeno escritório e precisa saber:\n",
    "1. Qual o valor total da conta de energia em cada mês do ano\n",
    "2. Qual o valor total da conta de energia no ano\n",
    "\n",
    "Considere as listas dadas como os 12 meses do ano, tanto para bandeiras quanto para consumo. O valor da conta é dado por: consumo * multiplicador_bandeira * preco_kwh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "bandeiras_tarifarias = [\"vermelha\", \"vermelha\", \"amarela\", \"amarela\", \"verde\", \"verde\", \"verde\", \"verde\", \"verde\", \"amarela\", \"amarela\", \"amarela\"]\n",
    "consumo_kwh = [400, 350, 325, 350, 200, 220, 250, 290, 360, 290, 300, 300]\n",
    "preco_kwh = 1.3\n",
    "multiplicador = {\"vermelha\": 2, \"amarela\": 1.3, \"verde\": 1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bandeiras_e_consumo_mes= {}\n",
    "\n",
    "# Iterar sobre as listas de bandeiras e consumos\n",
    "for bandeira, consumo in zip(bandeiras_tarifarias, consumo_kwh):\n",
    "    # Calcular o valor gasto para cada ocorrência de bandeira\n",
    "    valor_gasto_mes= consumo * preco_kwh * multiplicador[bandeira]\n",
    "    print(f'Para a bandeira {bandeira} com consumo de {consumo} kWh, o valor gasto é: R${valor_gasto_mes:.2f}')\n",
    "    # Preencher o dicionário com os consumos de energia para cada bandeira\n",
    "    if bandeira not in bandeiras_e_consumo_mes: \n",
    "        bandeiras_e_consumo_mes[bandeira] = [] \n",
    "    bandeiras_e_consumo_mes[bandeira].append(consumo)\n",
    "\n",
    "# Calcular e imprimir o valor gasto total para cada bandeira tarifária\n",
    "for bandeira, consumos in bandeiras_e_consumo_mes.items():\n",
    "    valor_total_bandeira = sum(consumo * preco_kwh * multiplicador[bandeira] for consumo in consumos)\n",
    "    print(f'O valor total gasto na bandeira {bandeira} é: R${valor_total_bandeira:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Você recebeu uma lista de alunos da Arroba Treinamentos e precisa descobrir quantos alunos e quais aluno estão devendo ainda algum pagamento do curso. O curso custa 2.000 reais e os pagamentos dos alunos são representados por uma lista de valores já pagos no dicionário de alunos\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "pagamentos_alunos = {\n",
    "    \"André\": [2000],\n",
    "    \"Fulano\": [1000, 1000],\n",
    "    \"Ciclano\": [500, 500],\n",
    "    \"Beltrano\": [100], \n",
    "    \"João\": [100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],\n",
    "    \"Amanda\": [200, 300, 250, 250, 500, 400, 100],\n",
    "    \"Lira\": [1000],\n",
    "    \"Alon\": [10]\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Itera sobre os itens do dicionário pagamentos_alunos\n",
    "for aluno, valores in pagamentos_alunos.items():\n",
    "    # Calcula a soma dos valores pagos pelo aluno\n",
    "    valor_pago = sum(valores)\n",
    "    # Verifica se o valor pago pelo aluno é menor que 2000\n",
    "    if valor_pago < 2000:\n",
    "        # Exibe uma mensagem indicando que o aluno está com pagamento atrasado\n",
    "        print(f'O aluno {aluno} está com o pagamento atrasado!!, valor pago até o momento: R$ {valor_pago}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Password Checker\n",
    "- Pessa para o usuário um input com a senha e um input com a confirmação de senha (aprenderemos no módulo de criação de telas com Python a fazer isso em um sistema bonito, mas para esse exercício faremos com inputs isso)\n",
    "- Para validar a senha, verifique que:\n",
    "    - A senha e confirmação são iguais\n",
    "    - A senha possua mais de 8 caracteres\n",
    "    - A senha tenha letras e números"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def validar_senha(senha):\n",
    "    # Verifica se a senha tem pelo menos 8 caracteres\n",
    "    if len(senha) < 8:\n",
    "        return False\n",
    "    \n",
    "    # Verifica se a senha contém pelo menos uma letra e um número usando regex\n",
    "    if not re.search(r'[A-Za-z]', senha) or not re.search(r'[0-9]', senha):\n",
    "        return False\n",
    "    \n",
    "    return True\n",
    "\n",
    "senha = input('Digite a senha: ')\n",
    "confirmacao_de_senha = input('Digite a senha novamente: ')\n",
    "\n",
    "# Verifica se as senhas coincidem\n",
    "if senha != confirmacao_de_senha:\n",
    "    print(\"As senhas não coincidem.\")\n",
    "elif not validar_senha(senha):\n",
    "    print(\"A senha deve ter pelo menos 8 caracteres, conter letras e números.\")\n",
    "else:\n",
    "    print(\"Senha válida.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Você precisa criar a lógica de um sistema de load balance/redirecionamento automático. Seu programa deve receber um input que representa quantas requisições um sistema vai receber. Para cada requisição, seu sistema deve decidir em qual destino atribuir a requisição, destino A, B ou C. A regra de distribuição é: a primeira requisição é atribuída ao destino A, a segunda ao B, a terceira ao C, a quarta ao A, a quinta ao B, a sexta ao C, a sétima ao A, a oitava ao B, a nona ao C… e assim vai até o total de requisições. Ao final do programa, você deve calcular quais requisições foram para cada destino e quantas são. Ex: se o sistema deveria receber 80 requisições, no final seu código tem q dizer: destino A recebeu 27 requisições, destino B recebeu 27 requisições e destino C recebeu 26 requisicoes e a lista de requisições de cada destino: listaA = [1, 4, 7, 10, 13...], listaB = [2, 5, 8, 11, 14, ...], listaC = [3, 6, 9, 12, 15, 18, 21, ...].\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solicita o número de requisições que o sistema vai receber\n",
    "num_requisicoes = int(input(\"Digite o número de requisições: \"))\n",
    "\n",
    "# Inicializa listas para armazenar as requisições de cada destino\n",
    "listaA = []\n",
    "listaB = []\n",
    "listaC = []\n",
    "\n",
    "# Distribui as requisições conforme a regra especificada\n",
    "for i in range(1, num_requisicoes + 1):\n",
    "    if i % 3 == 1:\n",
    "        listaA.append(i)\n",
    "    elif i % 3 == 2:\n",
    "        listaB.append(i)\n",
    "    elif i % 3 == 0:\n",
    "        listaC.append(i)\n",
    "\n",
    "# Calcula o número de requisições para cada destino\n",
    "num_requisicoes_A = len(listaA)\n",
    "num_requisicoes_B = len(listaB)\n",
    "num_requisicoes_C = len(listaC)\n",
    "\n",
    "# Exibe os resultados\n",
    "print(f\"Destino A recebeu {num_requisicoes_A} requisições: {listaA}\")\n",
    "print(f\"Destino B recebeu {num_requisicoes_B} requisições: {listaB}\")\n",
    "print(f\"Destino C recebeu {num_requisicoes_C} requisições: {listaC}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ChatBot de Recomendações de Viagens\n",
    "- Você trabalha em uma agência de viagens e precisa criar um chatbot para os seus clientes. Esse chatbot deve pedir para o usuario escolher um mês de viagem. Em seguida, seu chatbot deve perguntar para qual lugar o usuário deseja viajar. Caso o local escolhido pelo usuário esteja na lista de bons lugares para viajar naquele mês, o seu chatbot deve dizer que é um ótimo lugar para viajar nesse mês. Caso o local não esteja na lista de bons locais daquele mês, seu chatbot deve:\n",
    "    1. Dizer para ele quais lugares são bons para viajar nesse mês\n",
    "    2. Verificar no resto dos meses se o local que o usuário quer viajar está em algum outro mês. Se tiver, seu programa deve dizer para ele qual o melhor mês para viajar para o local desejado pelo cliente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dicionário que armazena os destinos de viagem para cada mês\n",
    "viagens_mensais = {\n",
    "    \"jan\": [\"Tailândia\", \"Brasil\", \"Antártica\", \"África do Sul\", \"Argentina\"],\n",
    "    \"fev\": [\"Tailândia\", \"Brasil\", \"Argentina\", \"Uruguai\", \"África do Sul\"],\n",
    "    \"mar\": [\"Brasil\", \"Marrocos\", \"EUA\", \"Egito\", \"Dubai\"],\n",
    "    \"abr\": [\"Brasil\", \"Marrocos\", \"Egito\", \"Dubai\", \"Equador\"],\n",
    "    \"mai\": [\"Brasil\", \"EUA\", \"Itália\", \"França\", \"Inglaterra\"],\n",
    "    \"jun\": [\"Brasil\", \"Itália\", \"França\", \"Grécia\", \"Turquia\"],\n",
    "    \"jul\": [\"Brasil\", \"Itália\", \"França\", \"Grécia\", \"Turquia\"],\n",
    "    \"ago\": [\"Brasil\", \"Itália\", \"França\", \"Grécia\", \"Turquia\"],\n",
    "    \"set\": [\"Brasil\", \"Croácia\", \"Grécia\", \"México\", \"Alemanha\"],\n",
    "    \"out\": [\"Brasil\", \"Alemanha\", \"Japão\", \"Chile\", \"Indonésia\"],\n",
    "    \"nov\": [\"Brasil\", \"México\", \"Costa Rica\", \"Barbados\", \"Colômbia\"],\n",
    "    \"dez\": [\"Tailândia\", \"México\", \"Costa Rica\", \"Barbados\", \"Colômbia\"]\n",
    "}\n",
    "\n",
    "# Solicita ao usuário que digite o mês em que pretende viajar\n",
    "mes_viagem = input('Digite o mês que pretende viajar: ')\n",
    "# Extrai os três primeiros caracteres do mês digitado pelo usuário\n",
    "mes_viagem= mes_viagem[:3]\n",
    "# Solicita ao usuário que digite o destino da viagem\n",
    "destino_viagem = input('Digite o destino da viagem: ').capitalize()\n",
    "\n",
    "# Inicializa variáveis para armazenar o mês encontrado e os meses disponíveis\n",
    "meses_disponiveis = []\n",
    "\n",
    "# Verifica se o destino desejado está disponível no mês especificado\n",
    "if destino_viagem in viagens_mensais.get(mes_viagem, []):\n",
    "    print(f'O {destino_viagem} é um ótimo lugar para viajar no mês de {mes_viagem}')\n",
    "else:\n",
    "    # Se o destino não estiver disponível no mês especificado, verifica em todos os meses\n",
    "    for mes, paises in viagens_mensais.items():\n",
    "        if destino_viagem in paises:\n",
    "            meses_disponiveis.append(mes)\n",
    "    \n",
    "    # Se o destino estiver disponível em outros meses, exibe os meses disponíveis\n",
    "    if meses_disponiveis:\n",
    "        print(f'O {destino_viagem} não está disponível no mês de {mes_viagem}, mas está disponível nos meses de: {\", \".join(meses_disponiveis)} como um dos melhores locais para viajar.')\n",
    "    # Se o destino não estiver disponível em nenhum mês, informa o usuário\n",
    "    else:\n",
    "        print(f'O destino {destino_viagem} não foi encontrado em nenhum mês disponível.')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Password Manager com dicionário sendo o Banco de Dados\n",
    "\n",
    "- Seu desafio é criar um gerenciador de senhas (usando um dicionário python como banco de dados, mais para frente no curso no modulo de banco de dados você será capaz de armazenar essas senhas em um banco de dados de forma definitiva e mais protegida)\n",
    "    - Seu programa deve perguntar para o usuário se ele quer cadastrar uma senha nova ou pegar uma senha existente. Independente da operação ele deve usar uma senha mestre: \"uh&g7fnsd8\" para aprovar qualquer consulta/edição no sistema. Se o usuário quiser adicionar uma senha, deve pedir qual o nome do sistema de onde essa senha faz parte, qual o login e qual a senha a ser cadastrada. Se for para consultar, seu programa deve exibir os nomes dos sistemas disponíveis e o usuário pode escolher qual senha quer pedir e seu programa deve dar para ela a resposta de login e senha. Se quiser que as suas senhas cadastradas possam ser usadas para consulta, coloque tudo em um loop infinito e dê algum comando para o usuário conseguir finalizar o processo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dicionário que armazena logins e senhas\n",
    "gerenciador_senhas = {\n",
    "    \"Gmail\": (\"lira@emailfalso.com\", \"minhasenha123\"),\n",
    "    \"Github\": (\"pythonimpressionador\", \"senhadoida\"),\n",
    "    \"Cartão de Crédito\": (\"NumeroFalsodoCartao\", \"123456\"),\n",
    "    \"Portal Hashtag\": (\"usuario@gmail.com\", \"123456\")\n",
    "}\n",
    "\n",
    "# Define a senha mestra para acessar o gerenciador de senhas\n",
    "senha_mestra = 'uh&g7fnsd8'\n",
    "\n",
    "# Função para cadastrar uma nova senha\n",
    "def cadastrar_senha():\n",
    "    nome_do_sistema = input('Digite qual o nome do sistema que deseja acessar: ').capitalize()\n",
    "    login = input('Digite o login a ser cadastrado: ')\n",
    "    senha = input('Digite a senha a ser cadastrada: ')\n",
    "    gerenciador_senhas[nome_do_sistema] = (login, senha)\n",
    "    print(f'Login e senha para {nome_do_sistema} foram cadastrados com sucesso.')\n",
    "\n",
    "# Função para consultar uma senha existente\n",
    "def consultar_senha():\n",
    "    for sistema in gerenciador_senhas.keys():\n",
    "        print(sistema)\n",
    "    nome_do_sistema = input('Digite qual o nome do sistema que deseja consultar: ').capitalize()\n",
    "    if nome_do_sistema in gerenciador_senhas:\n",
    "        login, senha = gerenciador_senhas[nome_do_sistema]\n",
    "        print(f'Login: {login}\\nSenha: {senha}')\n",
    "    else:\n",
    "        print(f'{nome_do_sistema} não está cadastrado no gerenciador de senhas.')\n",
    "\n",
    "# Loop infinito para gerenciar o sistema\n",
    "while True:\n",
    "    senha_para_acesso = input('Digite a senha mestra: ')\n",
    "    if senha_para_acesso == senha_mestra:\n",
    "        opcao_usuario = input('Para cadastrar novo login e senha digite 1, para consultar informações cadastradas digite 2, para sair digite 3: ')\n",
    "        if opcao_usuario == '1':\n",
    "            cadastrar_senha()\n",
    "        elif opcao_usuario == '2':\n",
    "            consultar_senha()\n",
    "        elif opcao_usuario == '3':\n",
    "            print('Saindo do gerenciador de senhas...')\n",
    "            break\n",
    "        else:\n",
    "            print('Opção inválida, tente novamente.')\n",
    "    else:\n",
    "        print('Senha mestra incorreta.')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    ### Extrator de data em email\n",
    "\n",
    "    - Crie um código que consiga extrair a data escrita em um email no formato DIA/MES/ANO. Essa data pode estar com diferentes quantidades de dígitos para cada informação de DIA/MES/ANO. Ex: 01/05/2024 = 1/5/24\n",
    "    - Mais para frente no curso vamos aprender regex que facilita esse tipo de extração, por enquanto, para esse exercício pode considerar que apenas 1 data será incluída no email e que não será usado mais a / em outros locais do email"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto_email = \"\"\"Prezados,\n",
    "Segue em anexo contrato para aprovação e assinatura até o dia 10/12/2025\n",
    "Favor se atentar ao prazo de conclusão para evitar o cancelamento do serviço.\n",
    "Att.,\n",
    "Fulano Beltrano\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extrair_data(texto):\n",
    "    # Divide o texto em palavras usando espaços e quebras de linha como delimitadores\n",
    "    palavras = texto.split()\n",
    "    \n",
    "    # Itera sobre cada palavra para encontrar a data\n",
    "    for palavra in palavras:\n",
    "        # Verifica se a palavra contém '/' e se as partes são todas dígitos\n",
    "        if '/' in palavra:\n",
    "            partes = palavra.split('/')\n",
    "            if len(partes) == 3 and all(parte.isdigit() for parte in partes):\n",
    "                # Se encontrar a data, retorna a palavra\n",
    "                return palavra\n",
    "                \n",
    "    # Se nenhuma data for encontrada, retorna uma mensagem\n",
    "    return 'Nenhuma data encontrada'\n",
    "\n",
    "# Chama a função para extrair a data do texto do e-mail\n",
    "data_encontrada = extrair_data(texto_email)\n",
    "print(f'Data encontrada: {data_encontrada}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extrator de contato em email\n",
    "\n",
    "- Crie um código que consiga extrair um endereço de e-mail de um texto.\n",
    "- Mais para frente no curso vamos aprender regex que facilita esse tipo de extração, por enquanto, para esse exercício pode considerar que apenas 1 email será incluída no texto e o @ não será usado em outros locais."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto_email = \"\"\"Prezados,\n",
    "Favor encaminhar documentação para o email qualquercoisa@gmail.com\n",
    "Obrigado\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Função para extrair email\n",
    "def extrair_email(texto):\n",
    "    # Divide o texto em palavras\n",
    "    palavras = texto.split()\n",
    "    \n",
    "    # Itera sobre cada palavra para encontrar o email\n",
    "    for palavra in palavras:\n",
    "        if '@' in palavra:\n",
    "            partes = palavra.split('@')\n",
    "            if len(partes) == 2 and all(partes):\n",
    "                return palavra\n",
    "\n",
    "# Chama a função para extrair o email do texto\n",
    "email_encontrado = extrair_email(texto_email)    \n",
    "print(f'Email encontrado: {email_encontrado}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dado um dicionário com a temperatura em várias cidades, máximas e mínimas estimadas e máximas e mínimas reais, veja em quantas cidades a previsão do tempo acertou e em quantas errou.\n",
    "\n",
    "Considere que a previsão erra se a mínima real for menor do que a mínima estimada OU se a máxima real for maior do que a máxima estimada. Se os valores reais estiverem dentro da faixa estimada, mesmo que os valores não sejam iguais, é considerado que a previsão acertou.\n",
    "\n",
    "Ex: <br>\n",
    "Mínima Estimada: 20, Máxima Estimada: 25, Mínima Real: 21, Máxima Real: 25 -> acertou<br>\n",
    "Mínima Estimada: 20, Máxima Estimada: 25, Mínima Real: 19, Máxima Real: 25 -> errou<br>\n",
    "Mínima Estimada: 20, Máxima Estimada: 25, Mínima Real: 23, Máxima Real: 24 -> acertou<br>\n",
    "Mínima Estimada: 20, Máxima Estimada: 25, Mínima Real: 19, Máxima Real: 28 -> errou<br>\n",
    "\n",
    "formato:\n",
    "(minima_estimada, maxima_estimada, minima_real, maxima_real)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dic_temperaturas = {\n",
    "    \"São Paulo\": (15, 23, 16, 22),\n",
    "    \"Rio de Janeiro\": (21, 25, 20, 25),\n",
    "    \"Belo Horizonte\": (19, 22, 19, 22),\n",
    "    \"Brasília\": (23, 25, 19, 21),\n",
    "    \"Porto Alegre\": (13, 19, 14, 18),\n",
    "    \"Natal\": (25, 28, 24, 28),\n",
    "    \"Salvador\": (22, 29, 23, 30),\n",
    "    \"Manaus\": (23, 27, 23, 26),\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Itera sobre cada item no dicionário dic_temperaturas\n",
    "for cidade, temperaturas in dic_temperaturas.items():\n",
    "    # Desempacota as temperaturas estimadas e reais\n",
    "    minima_estimada, maxima_estimada, minima_real, maxima_real = temperaturas\n",
    "    \n",
    "    # Verifica se a mínima real é maior que a mínima estimada e a máxima real é menor que a máxima estimada\n",
    "    if minima_real > minima_estimada and maxima_real < maxima_estimada:\n",
    "        # Imprime que a previsão estimada está correta para a cidade\n",
    "        print('A previsão estimada para a cidade de {} está correta. Sendo a minima real de {} e a máxima real de {}'.format(cidade, minima_real, maxima_real))\n",
    "    else:\n",
    "        # Imprime que a previsão estimada está errada para a cidade\n",
    "        print('A previsão estimada informada para a cidade de {} está errada. Sendo a minima de {} e máxima de {}'.format(cidade, minima_estimada, maxima_estimada))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Você trabalha em uma montadora de veículos com 32 distribuidores e a meta da sua empresa era produzir e entregar 50.000 veículos no ano. Essa meta foi batida, com folga. Seu chefe então se questionou: se a gente tivesse 31 distribuidoras, ainda assim a gente teria batido a meta? E se a gente tivesse 30? E 29?\n",
    "\n",
    "Seu objetivo então é descobrir qual o menor número de distribuidores que teria permitido a sua empresa a ter batido essa meta de 50.000 veiculos produzidos e entregues no ano."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "entregas_distribuidores = [5000, 4000, 3900, 3900, 3800, 3200, 3000, 3000, 3000, 3000, 2950, 2950, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900, 2900]\n",
    "\n",
    "# Inicia um loop infinito\n",
    "while True:\n",
    "    # Itera sobre cada valor na lista entregas_distribuidores\n",
    "    for veiculos in entregas_distribuidores:\n",
    "        # Verifica se a soma das entregas é maior que 50000\n",
    "        if sum(entregas_distribuidores) > 50000:\n",
    "            # Remove o último item da lista se a condição for verdadeira\n",
    "            entregas_distribuidores.pop(-1)\n",
    "        else:\n",
    "            # Calcula a quantidade de distribuidoras necessárias\n",
    "            quantidade_distribuidoras = len(entregas_distribuidores)\n",
    "            # Exibe a quantidade de distribuidoras necessárias para bater a meta de 50000 veículos\n",
    "            print('Para bater a meta de 50000 mil veículos produzidos no ano, seriam necessários no mínimo {} distribuidoras.'.format(quantidade_distribuidoras))\n",
    "            # Interrompe o loop for\n",
    "            break\n",
    "    # Verifica novamente se a soma das entregas é menor ou igual a 50000\n",
    "    if sum(entregas_distribuidores) <= 50000:\n",
    "        # Interrompe o loop while se a condição for verdadeira\n",
    "        break\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Um dos princípios mais importantes nas empresas é o princípio 80/20. No geral, 20% das ações que uma empresa faz geram 80% dos resultados. Isso tanto para receita, quanto para custos, etc. Você está analisando uma empresa de bebidas. Tendo isso em mente, queremos descobrir quais as linhas de custos que representam 80% do total gasto da empresa. Para isso, calcule quanto percentualmente cada custo representa do custo total da empresa e crie um ranking decrescente baseado nesse percentual "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "custos = [\n",
    "    (10131.7, \"Custo Mercadorias Vendidas\"),\n",
    "    (2916, \"Logística\"),\n",
    "    (1741, \"Despesas Comerciais\"),\n",
    "    (1305, \"Despesas administrativas\"),\n",
    "    (28, \"Outros Itens\"),\n",
    "    (997, \"Juros e Resultado Financeiro\"),\n",
    "    (14, \"Participações em outros Empreendimentos\"),\n",
    "    (58, \"Impostos\")\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcular o total dos custos\n",
    "total_custos = sum(custo for custo, descricao in custos)\n",
    "\n",
    "# Calcular o percentual de cada despesa e armazenar em uma lista de tuplas (percentual, descricao)\n",
    "percentuais = [(custo / total_custos * 100, descricao) for custo, descricao in custos]\n",
    "\n",
    "# Ordenar a lista de percentuais do maior para o menor\n",
    "percentuais.sort(reverse=True, key=lambda x: x[0])\n",
    "\n",
    "# Exibir os percentuais em ordem decrescente\n",
    "print(\"Percentual de cada despesa em relação ao total, em ordem do maior para o menor:\")\n",
    "for percentual, descricao in percentuais:\n",
    "    print(f\"{descricao}: {percentual:.2f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Você trabalha em uma empresa que possui várias franquias. Queremos saber quais as franquias que têm maior número de funcionários e quais dessas, juntas, representam 80% dos funcionários da rede toda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "franquias = [\n",
    "    (25000, \"Loja A\"),\n",
    "    (10000, \"Loja B\"),\n",
    "    (500, \"Loja C\"),\n",
    "    (25000, \"Loja D\"),\n",
    "    (1200, \"Loja E\"),\n",
    "    (400, \"Loja F\"),\n",
    "    (200, \"Loja G\"),\n",
    "    (15, \"Loja H\"),\n",
    "    (200, \"Loja I\"),\n",
    "    (15, \"Loja J\"),\n",
    "    (200, \"Loja K\"),\n",
    "    (15, \"Loja L\"),\n",
    "    (200, \"Loja M\"),\n",
    "    (15, \"Loja N\"),\n",
    "]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcula o total de funcionários da rede\n",
    "total_funcionarios = sum(funcionarios for funcionarios, loja in franquias)\n",
    "\n",
    "# Calcula 80% do total de funcionários\n",
    "meta_80 = total_funcionarios * 0.8\n",
    "\n",
    "# Ordena as franquias pelo número de funcionários em ordem decrescente\n",
    "franquias_ordenadas = sorted(franquias, reverse=True, key=lambda x: x[0])\n",
    "\n",
    "# Inicializa variáveis para somar os funcionários e armazenar as franquias\n",
    "soma_funcionarios = 0\n",
    "franquias_meta_80 = []\n",
    "\n",
    "# Soma os funcionários das maiores franquias até atingir 80% do total\n",
    "for funcionarios, loja in franquias_ordenadas:\n",
    "    if soma_funcionarios >= meta_80:\n",
    "        break\n",
    "    soma_funcionarios += funcionarios\n",
    "    franquias_meta_80.append((funcionarios, loja))\n",
    "\n",
    "# Exibe os resultados\n",
    "print(f\"Total de funcionários na rede: {total_funcionarios}\")\n",
    "print(f\"Meta de 80% dos funcionários: {meta_80}\")\n",
    "print(\"Franquias que juntas representam 80% dos funcionários:\")\n",
    "for funcionarios, loja in franquias_meta_80:\n",
    "    print(f\"{loja}: {funcionarios} funcionários\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desafio (esse exercício é mais difícil mesmo)\n",
    "### Com o PIB de 2022 e de 2021 de cada estado brasileiro, descubra: qual o maior PIB, menor PIB, média do PIB, PIB total em cada ano e qual estado mais cresceu o PIB percentualmente e em valores absolutos de um ano pro outro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "pib_2022 = {\n",
    "    \"Acre\": 21374,\n",
    "    \"Alagoas\": 76266,\n",
    "    \"Amapá\": 20100,\n",
    "    \"Amazonas\": 131531,\n",
    "    \"Bahia\": 352618,\n",
    "    \"Ceará\": 194885,\n",
    "    \"Distrito Federal\": 286944,\n",
    "    \"Espírito Santo\": 186337,\n",
    "    \"Goiás\": 269628,\n",
    "    \"Maranhão\": 124981,\n",
    "    \"Mato Grosso\": 233390,\n",
    "    \"Mato Grosso do Sul\": 142204,\n",
    "    \"Minas Gerais\": 857593,\n",
    "    \"Paraná\": 549973,\n",
    "    \"Paraíba\": 77470,\n",
    "    \"Pará\": 262905,\n",
    "    \"Pernambuco\": 220814,\n",
    "    \"Piauí\": 64028,\n",
    "    \"Rio de Janeiro\": 949301,\n",
    "    \"Rio Grande do Norte\": 80181,\n",
    "    \"Rio Grande do Sul\": 581284,\n",
    "    \"Rondônia\": 58170,\n",
    "    \"Roraima\": 18203,\n",
    "    \"Santa Catarina\": 428571,\n",
    "    \"Sergipe\": 51861,\n",
    "    \"São Paulo\": 2719751,\n",
    "    \"Tocantins\": 51781\n",
    "}\n",
    "\n",
    "pib_2021 = {\n",
    "    \"Acre\": 16476,\n",
    "    \"Alagoas\": 63202,\n",
    "    \"Amapá\": 18469,\n",
    "    \"Amazonas\": 116019,\n",
    "    \"Bahia\": 305321,\n",
    "    \"Ceará\": 166915,\n",
    "    \"Distrito Federal\": 265847,\n",
    "    \"Espírito Santo\": 138446,\n",
    "    \"Goiás\": 224126,\n",
    "    \"Maranhão\": 106916,\n",
    "    \"Mato Grosso\": 178650,\n",
    "    \"Mato Grosso do Sul\": 122628,\n",
    "    \"Minas Gerais\": 682786, \n",
    "    \"Paraná\": 487931,\n",
    "    \"Paraíba\": 70292,\n",
    "    \"Pará\": 215936,\n",
    "    \"Pernambuco\": 193307,\n",
    "    \"Piauí\": 56391,\n",
    "    \"Rio de Janeiro\": 753824,\n",
    "    \"Rio Grande do Norte\": 71577,\n",
    "    \"Rio Grande do Sul\": 470942, \n",
    "    \"Rondônia\": 51599,\n",
    "    \"Roraima\": 16024,\n",
    "    \"Santa Catarina\": 349275,\n",
    "    \"Sergipe\": 45410,\n",
    "    \"São Paulo\": 2377639,\n",
    "    \"Tocantins\": 43650\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Função para formatar os valores em reais\n",
    "def formatar_real(valor):\n",
    "    return f\"R$ {valor:,.2f}\".replace(',', 'X').replace('.', ',').replace('X', '.')\n",
    "\n",
    "# Função para calcular as métricas desejadas\n",
    "def calcular_metricas(pib_2021, pib_2022):\n",
    "    # Calcular o maior e menor PIB em cada ano\n",
    "    maior_pib21 = max(pib_2021.values())\n",
    "    maior_pib22 = max(pib_2022.values())\n",
    "    menor_pib21 = min(pib_2021.values())\n",
    "    menor_pib22 = min(pib_2022.values())\n",
    "\n",
    "    # Encontrar os estados correspondentes\n",
    "    estado_maior_pib21 = max(pib_2021, key=pib_2021.get)\n",
    "    estado_maior_pib22 = max(pib_2022, key=pib_2022.get)\n",
    "    estado_menor_pib21 = min(pib_2021, key=pib_2021.get)\n",
    "    estado_menor_pib22 = min(pib_2022, key=pib_2022.get)\n",
    "\n",
    "    # Calcular o PIB total em cada ano\n",
    "    total_pib21 = sum(pib_2021.values())\n",
    "    total_pib22 = sum(pib_2022.values())\n",
    "\n",
    "    # Calcular a média do PIB em cada ano\n",
    "    media_pib21 = total_pib21 / len(pib_2021)\n",
    "    media_pib22 = total_pib22 / len(pib_2022)\n",
    "\n",
    "    # Calcular a variação percentual e absoluta do PIB de cada estado\n",
    "    variacao_percentual = {}\n",
    "    variacao_absoluta = {}\n",
    "    for estado in pib_2021:\n",
    "        if estado in pib_2022:\n",
    "            variacao_absoluta[estado] = pib_2022[estado] - pib_2021[estado]\n",
    "            variacao_percentual[estado] = ((pib_2022[estado] - pib_2021[estado]) / pib_2021[estado]) * 100\n",
    "\n",
    "    # Encontrar o estado que mais cresceu em termos percentuais e absolutos\n",
    "    estado_maior_crescimento_percentual = max(variacao_percentual, key=variacao_percentual.get)\n",
    "    estado_maior_crescimento_absoluto = max(variacao_absoluta, key=variacao_absoluta.get)\n",
    "\n",
    "    # Exibir os resultados\n",
    "    print(f\"Maior PIB em 2021: {estado_maior_pib21} com {formatar_real(maior_pib21)}\")\n",
    "    print(f\"Maior PIB em 2022: {estado_maior_pib22} com {formatar_real(maior_pib22)}\")\n",
    "    print(f\"Menor PIB em 2021: {estado_menor_pib21} com {formatar_real(menor_pib21)}\")\n",
    "    print(f\"Menor PIB em 2022: {estado_menor_pib22} com {formatar_real(menor_pib22)}\")\n",
    "    print(f\"PIB total em 2021: {formatar_real(total_pib21)}\")\n",
    "    print(f\"PIB total em 2022: {formatar_real(total_pib22)}\")\n",
    "    print(f\"Média do PIB em 2021: {formatar_real(media_pib21)}\")\n",
    "    print(f\"Média do PIB em 2022: {formatar_real(media_pib22)}\")\n",
    "    print(f\"Maior crescimento percentual do PIB: {estado_maior_crescimento_percentual} com {variacao_percentual[estado_maior_crescimento_percentual]:.2f}%\")\n",
    "    print(f\"Maior crescimento absoluto do PIB: {estado_maior_crescimento_absoluto} com {formatar_real(variacao_absoluta[estado_maior_crescimento_absoluto])}\")\n",
    "\n",
    "# Chamar a função para calcular e exibir as métricas\n",
    "calcular_metricas(pib_2021, pib_2022)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desafio (esse exercício é mais difícil mesmo)\n",
    "### Temos o preço de diferentes ações no início de 2024 e em maio de 2024, queremos:\n",
    "    - Ação que mais subiu, ação que mais caiu no período (percentualmente)\n",
    "    - Se tivessemos 1.000 reais investido em um portfólio com as ações da carteira A vs um portfólio com as ações B, qual teria rendido mais? - considere que os 1.000 reais são investidos de forma proporcional entre cada ativo da carteira"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "acoes = {\n",
    "    \"PETR4\": [37.78, 37.01],\n",
    "    \"VALE3\": [77.05, 65.30],\n",
    "    \"ITUB4\": [33.52, 33.74],\n",
    "    \"ABEV3\": [13.71, 11.81],\n",
    "    \"WEGE3\": [36.57, 38.35],\n",
    "    \"BBAS3\": [27.38, 29.41],\n",
    "    \"JBSS3\": [25.17, 29.96],\n",
    "    \"SBSP3\": [73.63, 75.07]\n",
    "}\n",
    "\n",
    "carteiraA = [\"PETR4\", \"VALE3\", \"JBSS3\", \"SBSP3\"]\n",
    "carteiraB = [\"WEGE3\", \"BBAS3\", \"ITUB4\", \"ABEV3\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Função para calcular métricas das ações\n",
    "def calcular_acoes(acoes):\n",
    "    # Dicionário para armazenar a diferença de valores das ações\n",
    "    diferenca_acoes = {}\n",
    "    \n",
    "    # Itera sobre cada ação no dicionário\n",
    "    for acao in acoes:\n",
    "        # Obtém os valores da ação (valor1 e valor2)\n",
    "        valores = acoes[acao]\n",
    "        valor1, valor2 = valores\n",
    "        \n",
    "        # Calcula a diferença de valores no período (valor2 - valor1)\n",
    "        diferenca_acoes_periodo = valor2 - valor1\n",
    "        \n",
    "        # Armazena a diferença calculada no dicionário diferenca_acoes\n",
    "        diferenca_acoes[acao] = diferenca_acoes_periodo\n",
    "    \n",
    "    # Calcular o menor valor de diferença de ações\n",
    "    menor_valor_acao = min(diferenca_acoes.values())\n",
    "    \n",
    "    # Calcular o maior valor de diferença de ações\n",
    "    maior_valor_acao = max(diferenca_acoes.values())\n",
    "    \n",
    "    # Encontrar a ação com a menor variação de valor\n",
    "    acao_menor_valor = min(diferenca_acoes, key=diferenca_acoes.get)\n",
    "    \n",
    "    # Encontrar a ação com a maior variação de valor\n",
    "    acao_maior_valor = max(diferenca_acoes, key=diferenca_acoes.get)\n",
    "    \n",
    "    # Calcular a variação percentual da ação com a maior variação de valor\n",
    "    variacao_percentual_maior_acao = (maior_valor_acao / acoes[acao_maior_valor][0]) * 100\n",
    "    \n",
    "    # Calcular a variação percentual da ação com a menor variação de valor\n",
    "    variacao_percentual_menor_acao = (menor_valor_acao / acoes[acao_menor_valor][0]) * 100\n",
    "    \n",
    "    # Exibir os resultados formatados\n",
    "    print(f'Ação com menor variação de valor: {acao_menor_valor} com variação de R$ {menor_valor_acao:.2f}')\n",
    "    print(f'Ação com maior variação de valor: {acao_maior_valor} com variação de R$ {maior_valor_acao:.2f}')\n",
    "    print(f'Maior variação percentual de valor: {acao_maior_valor} com variação de {variacao_percentual_maior_acao:.2f}%')\n",
    "    print(f'Menor variação percentual de valor: {acao_menor_valor} com variação de {variacao_percentual_menor_acao:.2f}%')\n",
    "\n",
    "# Chamar a função para calcular e exibir as métricas\n",
    "calcular_acoes(acoes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Função para calcular métricas das ações\n",
    "def calcular_acoes(acoes):\n",
    "    # Dicionário para armazenar a diferença de valores das ações\n",
    "    diferenca_acoes = {}\n",
    "    variacoes_percentuais = {}\n",
    "\n",
    "    # Itera sobre cada ação no dicionário\n",
    "    for acao in acoes:\n",
    "        # Obtém os valores da ação (valor1 e valor2)\n",
    "        valores = acoes[acao]\n",
    "        valor1, valor2 = valores\n",
    "        \n",
    "        # Calcula a diferença de valores no período (valor2 - valor1)\n",
    "        diferenca_acoes_periodo = valor2 - valor1\n",
    "        \n",
    "        # Armazena a diferença calculada no dicionário diferenca_acoes\n",
    "        diferenca_acoes[acao] = diferenca_acoes_periodo\n",
    "        \n",
    "        # Calcula e armazena a variação percentual da ação\n",
    "        variacoes_percentuais[acao] = (diferenca_acoes_periodo / valor1) * 100\n",
    "\n",
    "    # Calcular o menor valor de diferença de ações\n",
    "    menor_valor_acao = min(diferenca_acoes.values())\n",
    "    \n",
    "    # Calcular o maior valor de diferença de ações\n",
    "    maior_valor_acao = max(diferenca_acoes.values())\n",
    "    \n",
    "    # Encontrar a ação com a menor variação de valor\n",
    "    acao_menor_valor = min(diferenca_acoes, key=diferenca_acoes.get)\n",
    "    \n",
    "    # Encontrar a ação com a maior variação de valor\n",
    "    acao_maior_valor = max(diferenca_acoes, key=diferenca_acoes.get)\n",
    "    \n",
    "    # Calcular a variação percentual da ação com a maior variação de valor\n",
    "    variacao_percentual_maior_acao = variacoes_percentuais[acao_maior_valor]\n",
    "    \n",
    "    # Calcular a variação percentual da ação com a menor variação de valor\n",
    "    variacao_percentual_menor_acao = variacoes_percentuais[acao_menor_valor]\n",
    "\n",
    "    # Exibir os resultados formatados\n",
    "    print(f'Ação com menor variação de valor: {acao_menor_valor} com variação de R$ {menor_valor_acao:.2f}')\n",
    "    print(f'Ação com maior variação de valor: {acao_maior_valor} com variação de R$ {maior_valor_acao:.2f}')\n",
    "    print(f'Maior variação percentual de valor: {acao_maior_valor} com variação de {variacao_percentual_maior_acao:.2f}%')\n",
    "    print(f'Menor variação percentual de valor: {acao_menor_valor} com variação de {variacao_percentual_menor_acao:.2f}%')\n",
    "\n",
    "# Função para calcular o retorno da carteira de investimentos\n",
    "def carteira_investimentos(carteira, acoes):\n",
    "    # Define o valor do investimento inicial\n",
    "    investimento_inicial = 1000\n",
    "    # Inicializa o valor final da carteira\n",
    "    valor_final = 0\n",
    "\n",
    "    # Divide o investimento inicial igualmente entre as ações na carteira\n",
    "    investimento_por_acao = investimento_inicial / len(carteira)\n",
    "    \n",
    "    # Calcula o valor final da carteira após o período\n",
    "    for acao in carteira:\n",
    "        # Obtém o valor inicial e final da ação\n",
    "        valor_inicial = acoes[acao][0]\n",
    "        valor_final_acao = acoes[acao][1]\n",
    "        \n",
    "        # Calcula a quantidade de ações compradas com o valor inicial\n",
    "        quantidade_acoes = investimento_por_acao / valor_inicial\n",
    "        \n",
    "        # Atualiza o valor final da carteira\n",
    "        valor_final += quantidade_acoes * valor_final_acao\n",
    "    \n",
    "    # Retorna o valor final da carteira\n",
    "    return valor_final\n",
    "\n",
    "# Chamar a função para calcular e exibir as métricas das ações\n",
    "calcular_acoes(acoes)\n",
    "\n",
    "# Calcular e comparar o retorno das carteiras A e B\n",
    "valor_final_carteiraA = carteira_investimentos(carteiraA, acoes)\n",
    "valor_final_carteiraB = carteira_investimentos(carteiraB, acoes)\n",
    "\n",
    "# Exibir o valor final de cada carteira\n",
    "print(f'Valor final da Carteira A: R$ {valor_final_carteiraA:.2f}')\n",
    "print(f'Valor final da Carteira B: R$ {valor_final_carteiraB:.2f}')\n",
    "\n",
    "# Comparar os rendimentos das carteiras A e B\n",
    "if valor_final_carteiraA > valor_final_carteiraB:\n",
    "    print('A Carteira A teve um melhor rendimento.')\n",
    "else:\n",
    "    print('A Carteira B teve um melhor rendimento.')\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}