Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d8ed6dc0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Dicionários em Python.\n",
    "\n",
    "    Introdução aos Dicionários\n",
    "        O que são dicionários?\n",
    "        Diferença entre listas, tuplas e dicionários.\n",
    "        Por que usar dicionários?\n",
    "\n",
    "    Criando Dicionários\n",
    "        Sintaxe básica\n",
    "        Dicionários vazios\n",
    "        Dicionários com múltiplos itens\n",
    "        Dicionários aninhados\n",
    "\n",
    "    Acessando Itens do Dicionário\n",
    "        Acessando valores usando chaves\n",
    "        Método get()\n",
    "        Verificando a existência de uma chave\n",
    "\n",
    "    Operações Básicas com Dicionários\n",
    "        Adicionando itens\n",
    "        Atualizando itens\n",
    "        Removendo itens (del, pop(), popitem())\n",
    "        Copiando dicionários (copy(), dict())\n",
    "\n",
    "    Métodos de Dicionários\n",
    "        keys(), values(), e items()\n",
    "        clear()\n",
    "        setdefault()\n",
    "        update()\n",
    "        fromkeys()\n",
    "\n",
    "    Iterando Sobre Dicionários\n",
    "        Usando loops for\n",
    "        Iterando sobre chaves, valores e itens\n",
    "\n",
    "    Dicionários Aninhados\n",
    "        Acessando e modificando valores em dicionários aninhados\n",
    "\n",
    "    Compreensão de Dicionários (Dictionary Comprehension)\n",
    "        Sintaxe básica\n",
    "        Exemplos práticos\n",
    "\n",
    "    Dicionários e Funções\n",
    "        Passando dicionários como argumentos para funções\n",
    "        Retornando dicionários de funções\n",
    "\n",
    "    Dicas e Boas Práticas\n",
    "\n",
    "        Quando e por que usar dicionários\n",
    "        Cuidados com tipos de chaves mutáveis\n",
    "        Dicionários vs. Listas: quando usar cada um\n",
    "\n",
    "    Projetos mais complexos envolvendo a manipulação de dados com dicionários\n",
    "\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a33b27b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "efdddc68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1984\n",
      "banana\n",
      "4.5\n",
      "555-1234\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Introdução aos Dicionários\n",
    "        O que são dicionários?\n",
    "        Diferença entre listas, tuplas e dicionários.\n",
    "        Por que usar dicionários?\n",
    "\"\"\"\n",
    "\n",
    "#1. O que são dicionários?\n",
    "\n",
    "\"\"\"\n",
    "Dicionários, em Python, são uma das estruturas de dados embutidas que \n",
    "permitem armazenar uma coleção de itens. Ao contrário de sequências, que \n",
    "são indexadas por números inteiros, os dicionários são indexados por chaves, que \n",
    "podem ser de qualquer tipo imutável, como strings ou números. Em sua essência, um \n",
    "dicionário é uma coleção de pares chave-valor.\n",
    "\n",
    "Exemplo prático:\n",
    "\n",
    "Suponha que você queira armazenar informações sobre um livro, como o \n",
    "título, o autor e o ano de publicação:\n",
    "\"\"\"\n",
    "\n",
    "# Criação de um dicionário chamado 'livro' com três pares chave-valor\n",
    "livro = {\n",
    "    \"titulo\": \"1984\",           # Chave 'titulo' com o valor \"1984\"\n",
    "    \"autor\": \"George Orwell\",   # Chave 'autor' com o valor \"George Orwell\"\n",
    "    \"ano\": 1949                 # Chave 'ano' com o valor 1949\n",
    "}\n",
    "\n",
    "# Imprime o valor associado à chave 'titulo' do dicionário 'livro'\n",
    "print(livro[\"titulo\"])  # Saída esperada: 1984\n",
    "\n",
    "\n",
    "#2. Diferença entre listas, tuplas e dicionários.\n",
    "\n",
    "    #Listas: São coleções ordenadas de itens, que podem ser de qualquer \n",
    "    #tipo. Os itens são acessados por sua posição na lista.\n",
    "\n",
    "    #Exemplo prático:\n",
    "    \n",
    "# Criação de uma lista chamada 'frutas' contendo três strings\n",
    "frutas = [\"maçã\", \"banana\", \"cereja\"]\n",
    "\n",
    "# Imprime o segundo item da lista 'frutas' (a indexação começa em 0)\n",
    "print(frutas[1])  # Saída esperada: banana\n",
    "\n",
    "\n",
    "#Tuplas: Semelhantes às listas, mas são imutáveis, o que significa que \n",
    "#você não pode alterar, adicionar ou remover itens depois que a tupla é definida.\n",
    "\n",
    "#Exemplo prático:\n",
    "coordenadas = (4.5, 6.7)\n",
    "print(coordenadas[0])  # Saída: 4.5\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "    Dicionários: Como mencionado anteriormente, são coleções de pares chave-valor e não são ordenados.\n",
    "\n",
    "3. Por que usar dicionários?\n",
    "\n",
    "Dicionários são extremamente úteis quando você precisa associar um conjunto de \n",
    "valores a chaves únicas, permitindo a organização e o acesso rápido a dados.\n",
    "\n",
    "Exemplos práticos:\n",
    "\n",
    "    Banco de Dados Simples: Se você estiver criando um programa para gerenciar um \n",
    "    banco de dados de contatos, um dicionário pode ser usado para associar nomes a \n",
    "    informações, como números de telefone ou endereços.\n",
    "\"\"\"\n",
    "\n",
    "# Criação de um dicionário chamado 'contatos' com dois pares chave-valor\n",
    "contatos = {\n",
    "    \"Alice\": \"555-1234\",  # Chave 'Alice' com o valor \"555-1234\"\n",
    "    \"Bob\": \"555-5678\"    # Chave 'Bob' com o valor \"555-5678\"\n",
    "}\n",
    "\n",
    "# Imprime o valor associado à chave 'Alice' no dicionário 'contatos'\n",
    "print(contatos[\"Alice\"])  # Saída esperada: 555-1234\n",
    "\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "    Contagem de Frequência: Para contar a frequência de palavras em um texto, um \n",
    "    dicionário pode ser usado para mapear palavras a suas contagens.\n",
    "\n",
    "    Cache: Em situações onde o cálculo ou a recuperação de informações é caro em \n",
    "    termos de tempo, um dicionário pode ser usado para armazenar resultados para \n",
    "    acesso rápido em consultas futuras.\n",
    "\n",
    "Resumindo, os dicionários são úteis quando você precisa armazenar e recuperar \n",
    "informações de maneira eficiente com base em chaves personalizadas.\n",
    "\"\"\"\n",
    "print()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecc741da",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e8183536",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'marca': 'Ford', 'modelo': 'Mustang', 'ano': 1964}\n",
      "{}\n",
      "{'nome': 'Maria', 'idade': 30, 'profissao': 'Engenheira', 'nacionalidade': 'Brasileira'}\n",
      "Roberto\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Criando Dicionários\n",
    "        Sintaxe básica\n",
    "        Dicionários vazios\n",
    "        Dicionários com múltiplos itens\n",
    "        Dicionários aninhados\n",
    "\"\"\"\n",
    "\n",
    "#1. Sintaxe básica\n",
    "\n",
    "#Os dicionários em Python são definidos usando chaves {} e contêm pares de \n",
    "#chave-valor. Cada chave é seguida por dois pontos : e então pelo valor \n",
    "#associado àquela chave.\n",
    "\n",
    "#Exemplo prático:\n",
    "\n",
    "# Criação de um dicionário chamado 'carro' com três pares chave-valor\n",
    "carro = {\n",
    "    \"marca\": \"Ford\",       # Chave 'marca' com o valor \"Ford\"\n",
    "    \"modelo\": \"Mustang\",   # Chave 'modelo' com o valor \"Mustang\"\n",
    "    \"ano\": 1964            # Chave 'ano' com o valor numérico 1964\n",
    "}\n",
    "\n",
    "# Imprime o dicionário completo 'carro'\n",
    "print(carro)\n",
    "\n",
    "#2. Dicionários vazios\n",
    "\n",
    "#Você pode criar um dicionário vazio simplesmente usando chaves sem \n",
    "#nenhum conteúdo.\n",
    "\n",
    "#Exemplo prático:\n",
    "\n",
    "pessoa = {}\n",
    "\n",
    "print(pessoa)\n",
    "\n",
    "\n",
    "#3. Dicionários com múltiplos itens\n",
    "\n",
    "#Dicionários podem conter vários pares chave-valor. Cada \n",
    "#par é separado por uma vírgula.\n",
    "\n",
    "#Exemplo prático:\n",
    "\n",
    "# Criação de um dicionário chamado 'pessoa' com quatro pares chave-valor\n",
    "pessoa = {\n",
    "    \"nome\": \"Maria\",                        # Chave 'nome' com o valor \"Maria\"\n",
    "    \"idade\": 30,                            # Chave 'idade' com o valor numérico 30\n",
    "    \"profissao\": \"Engenheira\",              # Chave 'profissao' com o valor \"Engenheira\"\n",
    "    \"nacionalidade\": \"Brasileira\"           # Chave 'nacionalidade' com o valor \"Brasileira\"\n",
    "}\n",
    "\n",
    "# Imprime o dicionário completo 'pessoa'\n",
    "print(pessoa)\n",
    "\n",
    "#4. Dicionários aninhados\n",
    "\n",
    "#Um dicionário pode conter outro dicionário (ou outros tipos de coleções, \n",
    "#como listas) como um valor. Isso é referido como um dicionário aninhado.\n",
    "\n",
    "#Exemplo prático:\n",
    "\n",
    "# Criação de um dicionário chamado 'familia' com subdicionários representando membros da família\n",
    "familia = {\n",
    "    \n",
    "    # Subdicionário para o \"pai\"\n",
    "    \"pai\": {\n",
    "        \"nome\": \"Roberto\",  # Chave 'nome' com o valor \"Roberto\"\n",
    "        \"idade\": 50         # Chave 'idade' com o valor numérico 50\n",
    "    },\n",
    "    \n",
    "    # Subdicionário para a \"mae\"\n",
    "    \"mae\": {\n",
    "        \"nome\": \"Clara\",    # Chave 'nome' com o valor \"Clara\"\n",
    "        \"idade\": 48         # Chave 'idade' com o valor numérico 48\n",
    "    },\n",
    "    \n",
    "    # Subdicionário para o \"filho\"\n",
    "    \"filho\": {\n",
    "        \"nome\": \"Pedro\",    # Chave 'nome' com o valor \"Pedro\"\n",
    "        \"idade\": 22         # Chave 'idade' com o valor numérico 22\n",
    "    }\n",
    "}\n",
    "\n",
    "\n",
    "print(familia[\"pai\"][\"nome\"])  # Saída: Roberto\n",
    "#No exemplo acima, cada membro da família tem seu próprio dicionário \n",
    "#contendo informações sobre ele. Para acessar informações específicas, \n",
    "#você segue a cadeia de chaves.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32619faa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9dc1b82c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Universidade Federal\n",
      "Rio de Janeiro\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício sobre Criando Dicionários\n",
    "\n",
    "Objetivo: Crie dicionários seguindo as instruções fornecidas e, depois, acesse \n",
    "alguns dos valores com base nas etapas do exercício.\n",
    "\n",
    "Parte 1: Sintaxe básica\n",
    "\n",
    "    Crie um dicionário chamado animal que tenha as seguintes chaves e valores:\n",
    "        Chave: \"tipo\" / Valor: \"gato\"\n",
    "        Chave: \"cor\" / Valor: \"branco\"\n",
    "        Chave: \"idade\" / Valor: 3\n",
    "\n",
    "Parte 2: Dicionários vazios\n",
    "\n",
    "    Crie um dicionário vazio chamado estudante.\n",
    "\n",
    "    Adicione as seguintes chaves e valores ao dicionário estudante usando a sintaxe de atribuição:\n",
    "        Chave: \"nome\" / Valor: \"Carlos\"\n",
    "        Chave: \"curso\" / Valor: \"Matemática\"\n",
    "        Chave: \"semestre\" / Valor: 2\n",
    "\n",
    "Parte 3: Dicionários com múltiplos itens\n",
    "\n",
    "    Crie um dicionário chamado livro que tenha as seguintes chaves e valores:\n",
    "        Chave: \"titulo\" / Valor: \"A Arte da Guerra\"\n",
    "        Chave: \"autor\" / Valor: \"Sun Tzu\"\n",
    "        Chave: \"publicado\" / Valor: -500\n",
    "\n",
    "Parte 4: Dicionários aninhados\n",
    "\n",
    "    Crie um dicionário chamado universidade que contenha as seguintes informações:\n",
    "        Chave: \"nome\" / Valor: \"Universidade Federal\"\n",
    "        Chave: \"localidade\" / Valor: {\"cidade\": \"Rio de Janeiro\", \"bairro\": \"Centro\"}\n",
    "\n",
    "    Ao acessar o dicionário universidade, imprima o nome da universidade e a cidade onde ela se localiza.\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "\"\"\"\n",
    "Parte 1: Sintaxe básica\n",
    "\n",
    "    Crie um dicionário chamado animal que tenha as seguintes chaves e valores:\n",
    "        Chave: \"tipo\" / Valor: \"gato\"\n",
    "        Chave: \"cor\" / Valor: \"branco\"\n",
    "        Chave: \"idade\" / Valor: 3\n",
    "\"\"\"\n",
    "\n",
    "# Criação de um dicionário chamado 'animal' com três pares chave-valor\n",
    "animal = {\n",
    "    \"tipo\": \"gato\",    # Chave 'tipo' com o valor \"gato\"\n",
    "    \"cor\": \"branco\",   # Chave 'cor' com o valor \"branco\"\n",
    "    \"idade\": 3         # Chave 'idade' com o valor numérico 3\n",
    "}\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Parte 2: Dicionários vazios\n",
    "\n",
    "    Crie um dicionário vazio chamado estudante.\n",
    "\n",
    "    Adicione as seguintes chaves e valores ao dicionário estudante usando a sintaxe de atribuição:\n",
    "        Chave: \"nome\" / Valor: \"Carlos\"\n",
    "        Chave: \"curso\" / Valor: \"Matemática\"\n",
    "        Chave: \"semestre\" / Valor: 2\n",
    "\"\"\"\n",
    "\n",
    "# Criação de um dicionário vazio chamado 'estudante'\n",
    "estudante = {}\n",
    "\n",
    "# Adicionando pares chave-valor ao dicionário 'estudante'\n",
    "estudante[\"nome\"] = \"Carlos\"             # Adiciona a chave 'nome' com o valor \"Carlos\"\n",
    "estudante[\"curso\"] = \"Matemática\"       # Adiciona a chave 'curso' com o valor \"Matemática\"\n",
    "estudante[\"semestre\"] = 2               # Adiciona a chave 'semestre' com o valor numérico 2\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Parte 3: Dicionários com múltiplos itens\n",
    "\n",
    "    Crie um dicionário chamado livro que tenha as seguintes chaves e valores:\n",
    "        Chave: \"titulo\" / Valor: \"A Arte da Guerra\"\n",
    "        Chave: \"autor\" / Valor: \"Sun Tzu\"\n",
    "        Chave: \"publicado\" / Valor: 1500\n",
    "\"\"\"\n",
    "\n",
    "# Criação de um dicionário chamado 'livro' com três pares chave-valor\n",
    "livro = {\n",
    "    \"titulo\": \"A Arte da Guerra\",  # Chave 'titulo' com o valor \"A Arte da Guerra\"\n",
    "    \"autor\": \"Sun Tzu\",            # Chave 'autor' com o valor \"Sun Tzu\"\n",
    "    \"publicado\": 1500              # Chave 'publicado' com o valor numérico 1500 (ano de publicação)\n",
    "}\n",
    "\n",
    "\"\"\"\n",
    "Parte 4: Dicionários aninhados\n",
    "\n",
    "    Crie um dicionário chamado universidade que contenha as seguintes informações:\n",
    "        Chave: \"nome\" / Valor: \"Universidade Federal\"\n",
    "        Chave: \"localidade\" / Valor: {\"cidade\": \"Rio de Janeiro\", \"bairro\": \"Centro\"}\n",
    "\n",
    "    Ao acessar o dicionário universidade, imprima o nome da universidade e a cidade onde ela se localiza.\n",
    "\"\"\"\n",
    "\n",
    "# Criação de um dicionário chamado 'universidade' com um subdicionário representando a localidade\n",
    "universidade = {\n",
    "    \"nome\": \"Universidade Federal\",      # Chave 'nome' com o valor \"Universidade Federal\"\n",
    "    \"localidade\": {\n",
    "        \"cidade\": \"Rio de Janeiro\",      # Chave 'cidade' dentro do subdicionário com o valor \"Rio de Janeiro\"\n",
    "        \"bairro\": \"Centro\"               # Chave 'bairro' dentro do subdicionário com o valor \"Centro\"\n",
    "    }\n",
    "}\n",
    "\n",
    "\n",
    "print(universidade[\"nome\"])  # Saída: Universidade Federal\n",
    "print(universidade[\"localidade\"][\"cidade\"])  # Saída: Rio de Janeiro\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0157edab",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "6d602576",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Método direto:\n",
      "Marca: Apple\n",
      "\n",
      "Usando o método get():\n",
      "Modelo: iPhone 12\n",
      "Câmera: None\n",
      "Câmera: Informação não disponível\n",
      "\n",
      "Verificando chaves:\n",
      "O smartphone roda no sistema: iOS\n",
      "Informações da câmera não disponíveis.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Acessando Itens do Dicionário\n",
    "        Acessando valores usando chaves\n",
    "        Método get()\n",
    "        Verificando a existência de uma chave\n",
    "\"\"\"\n",
    "\n",
    "#Acessando Itens do Dicionário\n",
    "\n",
    "#Exemplo Prático:\n",
    "\n",
    "#Vamos supor que você tem um dicionário representando informações \n",
    "#sobre um smartphone. Queremos acessar certas informações usando diferentes métodos.\n",
    "\n",
    "# Definindo o dicionário do smartphone\n",
    "# Criação de um dicionário chamado 'smartphone' com cinco pares chave-valor\n",
    "smartphone = {\n",
    "    \"marca\": \"Apple\",             # Chave 'marca' com o valor \"Apple\"\n",
    "    \"modelo\": \"iPhone 12\",        # Chave 'modelo' com o valor \"iPhone 12\"\n",
    "    \"cor\": \"Azul\",                # Chave 'cor' com o valor \"Azul\"\n",
    "    \"capacidade\": \"128GB\",        # Chave 'capacidade' com o valor \"128GB\"\n",
    "    \"sistema\": \"iOS\"              # Chave 'sistema' com o valor \"iOS\"\n",
    "}\n",
    "\n",
    "# 1. Acessando valores usando chaves\n",
    "# Imprimindo uma mensagem indicativa\n",
    "print(\"Método direto:\")\n",
    "\n",
    "# Acessando e imprimindo o valor associado à chave 'marca' do dicionário 'smartphone'\n",
    "print(\"Marca:\", smartphone[\"marca\"])  # Saída esperada: Apple\n",
    "#print(\"Marca:\", smartphone[\"camera\"])\n",
    "\n",
    "# Mas, se tentarmos acessar uma chave que não existe, receberemos um erro.\n",
    "# Por exemplo, tentar acessar smartphone[\"camera\"] lançaria um KeyError.\n",
    "\n",
    "# 2. Método get()\n",
    "print(\"\\nUsando o método get():\")\n",
    "print(\"Modelo:\", smartphone.get(\"modelo\"))  # Saída: iPhone 12\n",
    "\n",
    "# Se tentarmos acessar uma chave que não existe usando get(), ele retorna None por padrão.\n",
    "# Porém, podemos especificar um valor padrão para ser retornado.\n",
    "print(\"Câmera:\", smartphone.get(\"camera\")) \n",
    "print(\"Câmera:\", smartphone.get(\"camera\", \"Informação não disponível\"))  # Saída: Informação não disponível\n",
    "\n",
    "#3. Verificando a existência de uma chave\n",
    "\n",
    "# Imprimindo uma linha em branco e uma mensagem indicativa\n",
    "print(\"\\nVerificando chaves:\")\n",
    "\n",
    "#if - se\n",
    "# Verificando se a chave 'sistema' está presente no dicionário 'smartphone'\n",
    "if \"sistema\" in smartphone:\n",
    "    \n",
    "    # Se 'sistema' estiver presente, imprime o valor associado a essa chave\n",
    "    print(\"O smartphone roda no sistema:\", smartphone[\"sistema\"])  # Saída esperada: iOS\n",
    "    \n",
    "else:\n",
    "    \n",
    "    # Se 'sistema' não estiver presente, imprime uma mensagem indicando isso\n",
    "    print(\"Sistema operacional não especificado.\")\n",
    "\n",
    "# Verificando se a chave 'camera' está presente no dicionário 'smartphone'\n",
    "if \"camera\" in smartphone:\n",
    "    \n",
    "    # Se 'camera' estiver presente, imprime o valor associado a essa chave\n",
    "    print(\"Câmera:\", smartphone[\"camera\"])\n",
    "    \n",
    "else:\n",
    "    \n",
    "    # Se 'camera' não estiver presente, imprime uma mensagem indicando a ausência de informações sobre a câmera\n",
    "    print(\"Informações da câmera não disponíveis.\")  # Saída esperada: Informações da câmera não disponíveis.\n",
    "\n",
    "    \n",
    "\"\"\"\n",
    "Neste exemplo, mostramos diferentes formas de acessar e verificar itens \n",
    "em um dicionário. É essencial entender esses métodos porque eles previnem erros \n",
    "ao tentar acessar chaves que podem não existir no dicionário.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1bab4079",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "a77afae3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nome do artista: Ludwig van Beethoven\n",
      "\n",
      "Nacionalidade: Alemã\n",
      "Profissão: Informação não disponível\n",
      "\n",
      "Estilo musical: Clássico\n",
      "Instrumento principal não especificado\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício sobre Acessando Itens do Dicionário\n",
    "\n",
    "Objetivo: Dado um dicionário que representa informações sobre um artista \n",
    "musical, sua tarefa é acessar certas informações usando diferentes métodos.\n",
    "\n",
    "Dicionário fornecido:\n",
    "\n",
    "artista = {\n",
    "    \"nome\": \"Ludwig van Beethoven\",\n",
    "    \"nascimento\": 1770,\n",
    "    \"falecimento\": 1827,\n",
    "    \"nacionalidade\": \"Alemã\",\n",
    "    \"estilo\": \"Clássico\"\n",
    "}\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Acessando valores usando chaves:\n",
    "        - Imprima o nome do artista diretamente usando a chave apropriada.\n",
    "        - Tente acessar a \"profissão\" do artista diretamente usando a \n",
    "        chave (cuidado, essa chave não existe no dicionário!).\n",
    "\n",
    "    2. Método get():\n",
    "        - Use o método get() para obter a \"nacionalidade\" do artista.\n",
    "        - Use o método get() para tentar acessar a \"profissão\" do \n",
    "        artista. Se a chave não existir, deve retornar \"Informação não disponível\".\n",
    "\n",
    "    3. Verificando a existência de uma chave:\n",
    "        - Verifique se o \"estilo\" musical do artista está presente \n",
    "        no dicionário. Se estiver, imprima-o.\n",
    "        - Verifique se \"instrumento principal\" está presente no \n",
    "        dicionário. Se não estiver, imprima \"Instrumento principal não especificado\".\n",
    "        \n",
    "\"\"\"\n",
    "\n",
    "artista = {\n",
    "    \"nome\": \"Ludwig van Beethoven\",\n",
    "    \"nascimento\": 1770,\n",
    "    \"falecimento\": 1827,\n",
    "    \"nacionalidade\": \"Alemã\",\n",
    "    \"estilo\": \"Clássico\"\n",
    "}\n",
    "\n",
    "#Solução:\n",
    "\n",
    "# 1. Acessando valores usando chaves\n",
    "print(\"Nome do artista:\", artista[\"nome\"])  # Saída: Ludwig van Beethoven\n",
    "\n",
    "# Esta linha lançará um KeyError, pois \"profissão\" não é uma chave no dicionário.\n",
    "# print(artista[\"profissão\"])\n",
    "\n",
    "# 2. Método get()\n",
    "print(\"\\nNacionalidade:\", artista.get(\"nacionalidade\"))  # Saída: Alemã\n",
    "print(\"Profissão:\", artista.get(\"profissão\", \"Informação não disponível\"))  # Saída: Informação não disponível\n",
    "\n",
    "# 3. Verificando a existência de uma chave\n",
    "\n",
    "# Verificando se a chave 'estilo' está presente no dicionário 'artista'\n",
    "if \"estilo\" in artista:\n",
    "    \n",
    "    # Se 'estilo' estiver presente, imprime o valor associado a essa chave\n",
    "    print(\"\\nEstilo musical:\", artista[\"estilo\"])  # Se a chave existisse e seu valor fosse \"Clássico\", essa seria a saída.\n",
    "    \n",
    "else:\n",
    "    \n",
    "    # Se 'estilo' não estiver presente, imprime uma mensagem indicando isso\n",
    "    print(\"Estilo musical não especificado.\")\n",
    "\n",
    "# Verificando se a chave 'instrumento principal' está presente no dicionário 'artista'\n",
    "if \"instrumento principal\" in artista:\n",
    "    \n",
    "    # Se 'instrumento principal' estiver presente, imprime o valor associado a essa chave\n",
    "    print(\"Instrumento principal:\", artista[\"instrumento principal\"])\n",
    "    \n",
    "else:\n",
    "    \n",
    "    # Se 'instrumento principal' não estiver presente, imprime uma mensagem indicando a ausência de informações sobre o instrumento principal\n",
    "    print(\"Instrumento principal não especificado.\")  # Se a chave não existisse, essa seria a saída esperada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31d4d6ba",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "7e12951d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Após adicionar itens: {'id': 12345, 'nome': 'Camisa Polo', 'cor': 'Vermelho', 'preco': 49.9, 'estoque': 100, 'marca': 'FashionBrand', 'desconto': 10}\n",
      "\n",
      "Após atualizar itens: {'id': 12345, 'nome': 'Camisa Polo', 'cor': 'Vermelho', 'preco': 59.9, 'estoque': 100, 'marca': 'FashionBrand', 'desconto': 15}\n",
      "\n",
      "Cor removida: Vermelho\n",
      "Item removido: ('marca', 'FashionBrand')\n",
      "\n",
      "Após remover itens: {'id': 12345, 'nome': 'Camisa Polo', 'preco': 59.9, 'estoque': 100}\n",
      "\n",
      "Cópias do produto:\n",
      "Cópia 1: {'id': 12345, 'nome': 'Camisa Polo', 'preco': 59.9, 'estoque': 100}\n",
      "Cópia 2: {'id': 12345, 'nome': 'Camisa Polo', 'preco': 59.9, 'estoque': 100}\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Operações Básicas com Dicionários\n",
    "        Adicionando itens\n",
    "        Atualizando itens\n",
    "        Removendo itens (del, pop(), popitem())\n",
    "        Copiando dicionários (copy(), dict())\n",
    "\"\"\"\n",
    "\n",
    "#Operações Básicas com Dicionários\n",
    "\n",
    "#Exemplo Prático:\n",
    "\n",
    "#Suponhamos que temos um dicionário que representa um produto em \n",
    "#um e-commerce. Vamos realizar várias operações \n",
    "#para adicionar, atualizar, remover e copiar informações sobre o produto.\n",
    "\n",
    "# Dicionário inicial do produto\n",
    "# Inicialização de um dicionário chamado 'produto' com cinco pares chave-valor\n",
    "produto = {\n",
    "    \"id\": 12345,                  # Chave 'id' com o valor numérico 12345\n",
    "    \"nome\": \"Camisa Polo\",        # Chave 'nome' com o valor \"Camisa Polo\"\n",
    "    \"cor\": \"Vermelho\",            # Chave 'cor' com o valor \"Vermelho\"\n",
    "    \"preco\": 49.90,               # Chave 'preco' com o valor numérico 49.90\n",
    "    \"estoque\": 100                # Chave 'estoque' com o valor numérico 100\n",
    "}\n",
    "\n",
    "# 1. Adicionando itens ao dicionário 'produto'\n",
    "\n",
    "# Adicionando a chave 'marca' com o valor \"FashionBrand\"\n",
    "produto[\"marca\"] = \"FashionBrand\"\n",
    "\n",
    "# Adicionando a chave 'desconto' com o valor numérico 10 (representa uma porcentagem)\n",
    "produto[\"desconto\"] = 10\n",
    "\n",
    "# Imprimindo o dicionário 'produto' após a adição dos novos itens\n",
    "print(\"Após adicionar itens:\", produto)\n",
    "\n",
    "# 2. Atualizando itens\n",
    "\n",
    "produto[\"preco\"] = 59.90  # alterando o preço\n",
    "produto[\"desconto\"] = 15  # atualizando o valor do desconto\n",
    "\n",
    "print(\"\\nApós atualizar itens:\", produto)\n",
    "\n",
    "# 3. Removendo itens (del, pop(), popitem())\n",
    "\n",
    "del produto[\"desconto\"]  # remove o item \"desconto\" do dicionário\n",
    "\n",
    "# Usando pop() para remover item por chave\n",
    "cor_removida = produto.pop(\"cor\")\n",
    "print(f\"\\nCor removida: {cor_removida}\")\n",
    "\n",
    "# Usando popitem() para remover o último item inserido\n",
    "item_removido = produto.popitem()\n",
    "print(\"Item removido:\", item_removido)\n",
    "\n",
    "print(\"\\nApós remover itens:\", produto)\n",
    "\n",
    "#4. Copiando dicionários (copy(), dict())\n",
    "\n",
    "# Método copy()\n",
    "produto_copia_1 = produto.copy()\n",
    "\n",
    "# Método dict()\n",
    "produto_copia_2 = dict(produto)\n",
    "\n",
    "print(\"\\nCópias do produto:\")\n",
    "print(\"Cópia 1:\", produto_copia_1)\n",
    "print(\"Cópia 2:\", produto_copia_2)\n",
    "\n",
    "\"\"\"\n",
    "Neste exemplo, realizamos várias operações básicas em um dicionário. \n",
    "\n",
    "É importante entender como manipular dicionários efetivamente, pois são \n",
    "uma estrutura de dados fundamental em Python.\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Método copy():\n",
    "O método copy() é uma função integrada em objetos de dicionário em \n",
    "Python. Ele cria uma cópia superficial (shallow copy) do dicionário. \n",
    "Isso significa que os valores dos itens (pares chave-valor) são \n",
    "copiados, mas se esses valores forem objetos mutáveis (como listas \n",
    "ou outros dicionários), eles ainda serão compartilhados entre o \n",
    "dicionário original e a cópia.\n",
    "\n",
    "Função dict() (construtor de dicionário):\n",
    "A função dict() pode ser usada para criar uma cópia rasa \n",
    "(shallow copy) ou profunda (deep copy) do dicionário, dependendo \n",
    "de como ela é usada. Ao passar outro dicionário como argumento \n",
    "para dict(), você cria uma cópia rasa. No entanto, se você quiser \n",
    "criar uma cópia profunda, precisará usar a biblioteca copy e o \n",
    "método deepcopy().\n",
    "\n",
    "\"\"\"\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7d4545a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "c6a51d10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hobbies removidos: ['Leitura', 'Corrida', 'Xadrez']\n",
      "Item removido: ('cr', 8.7)\n",
      "\n",
      "Dicionário: {'matricula': 'A12345', 'nome': 'João Silva', 'curso': 'Engenharia de Computação', 'semestre': 6}\n",
      "\n",
      "Cópias do dicionário aluno:\n",
      "Cópia 1: {'matricula': 'A12345', 'nome': 'João Silva', 'curso': 'Engenharia de Computação', 'semestre': 6}\n",
      "Cópia 2: {'matricula': 'A12345', 'nome': 'João Silva', 'curso': 'Engenharia de Computação', 'semestre': 6}\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício sobre Operações Básicas com Dicionários\n",
    "\n",
    "Objetivo: Dado um dicionário que representa informações de \n",
    "um aluno, sua tarefa é realizar operações para \n",
    "adicionar, atualizar, remover e copiar informações.\n",
    "\n",
    "Dicionário fornecido:\n",
    "\n",
    "aluno = {\n",
    "    \"matricula\": \"A12345\",\n",
    "    \"nome\": \"João Silva\",\n",
    "    \"curso\": \"Engenharia de Computação\",\n",
    "    \"semestre\": 5,\n",
    "    \"cr\": 8.5\n",
    "}\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Adicionando itens:\n",
    "        - Adicione uma chave \"hobbies\" com o valor de uma \n",
    "        lista contendo: \"Leitura\", \"Corrida\", \"Xadrez\".\n",
    "        \n",
    "        - Adicione uma chave \"idade\" com valor 22.\n",
    "\n",
    "    2. Atualizando itens:\n",
    "        - Atualize o valor da chave \"semestre\" para 6.\n",
    "        - Atualize o valor da chave \"cr\" para 8.7.\n",
    "\n",
    "    3. Removendo itens:\n",
    "        - Use o método del para remover a chave \"idade\".\n",
    "        \n",
    "        - Use o método pop() para remover a chave \"hobbies\" \n",
    "        e imprima os hobbies removidos.\n",
    "        \n",
    "        - Use o método popitem() para remover o último item adicionado \n",
    "        ao dicionário e imprima a chave e o valor do item removido.\n",
    "\n",
    "    4. Copiando dicionários:\n",
    "        - Crie uma cópia do dicionário aluno chamada copia_1 usando o método copy().\n",
    "        - Crie outra cópia do dicionário aluno chamada copia_2 usando o método dict().\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "# Inicialização de um dicionário chamado 'aluno' com cinco pares chave-valor\n",
    "aluno = {\n",
    "    \"matricula\": \"A12345\",                         # Chave 'matricula' com o valor \"A12345\"\n",
    "    \"nome\": \"João Silva\",                          # Chave 'nome' com o valor \"João Silva\"\n",
    "    \"curso\": \"Engenharia de Computação\",           # Chave 'curso' com o valor \"Engenharia de Computação\"\n",
    "    \"semestre\": 5,                                 # Chave 'semestre' com o valor numérico 5\n",
    "    \"cr\": 8.5                                      # Chave 'cr' (Coeficiente de Rendimento) com o valor numérico 8.5\n",
    "}\n",
    "\n",
    "# 1. Adicionando itens ao dicionário 'aluno'\n",
    "\n",
    "# Adicionando a chave 'hobbies' com uma lista de hobbies\n",
    "aluno[\"hobbies\"] = [\"Leitura\", \"Corrida\", \"Xadrez\"]\n",
    "\n",
    "# Adicionando a chave 'idade' com o valor numérico 22\n",
    "aluno[\"idade\"] = 22\n",
    "\n",
    "# 2. Atualizando itens do dicionário 'aluno'\n",
    "\n",
    "# Atualizando o valor associado à chave 'semestre' para 6\n",
    "aluno[\"semestre\"] = 6\n",
    "\n",
    "# Atualizando o valor associado à chave 'cr' (Coeficiente de Rendimento) para 8.7\n",
    "aluno[\"cr\"] = 8.7\n",
    "\n",
    "# 3. Removendo itens do dicionário 'aluno'\n",
    "\n",
    "# Removendo o item com a chave 'idade' do dicionário\n",
    "del aluno[\"idade\"]\n",
    "\n",
    "# Removendo e retornando o valor associado à chave 'hobbies', e armazenando-o na variável 'hobbies_removidos'\n",
    "hobbies_removidos = aluno.pop(\"hobbies\")\n",
    "\n",
    "# Imprimindo a lista de hobbies que foi removida\n",
    "print(\"Hobbies removidos:\", hobbies_removidos)\n",
    "\n",
    "# Removendo e retornando o último par chave-valor inserido no dicionário, e armazenando-o na variável 'item_removido'\n",
    "item_removido = aluno.popitem()\n",
    "\n",
    "# Imprimindo o par chave-valor que foi removido\n",
    "print(\"Item removido:\", item_removido)\n",
    "\n",
    "print(\"\\nDicionário:\", aluno)\n",
    "\n",
    "# 4. Copiando o dicionário 'aluno'\n",
    "\n",
    "# Criando uma cópia superficial do dicionário 'aluno' usando o método .copy()\n",
    "copia_1 = aluno.copy()\n",
    "\n",
    "# Criando outra cópia superficial do dicionário 'aluno' usando a função dict()\n",
    "copia_2 = dict(aluno)\n",
    "\n",
    "# Imprimindo as cópias criadas\n",
    "print(\"\\nCópias do dicionário aluno:\")\n",
    "print(\"Cópia 1:\", copia_1)\n",
    "print(\"Cópia 2:\", copia_2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f43b58e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "fed75cb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "1. keys(), values(), e items()\n",
      "Chaves do dicionário: ['titulo', 'autor', 'ano', 'editora', 'preco']\n",
      "Valores do dicionário: ['O Pequeno Príncipe', 'Antoine de Saint-Exupéry', 1943, 'Reynal & Hitchcock', 20.5]\n",
      "Itens do dicionário: [('titulo', 'O Pequeno Príncipe'), ('autor', 'Antoine de Saint-Exupéry'), ('ano', 1943), ('editora', 'Reynal & Hitchcock'), ('preco', 20.5)]\n",
      "\n",
      "2. clear()\n",
      "\n",
      "Dicionário após clear(): {}\n",
      "\n",
      "3. setdefault()\n",
      "\n",
      "ISBN: 978-3-16-148410-0\n",
      "Dicionário após setdefault(): {'titulo': 'O Pequeno Príncipe', 'autor': 'Antoine de Saint-Exupéry', 'ano': 1943, 'editora': 'Reynal & Hitchcock', 'preco': 20.5, 'ISBN': '978-3-16-148410-0'}\n",
      "\n",
      "4. update()\n",
      "\n",
      "Dicionário após update(): {'titulo': 'O Pequeno Príncipe', 'autor': 'Antoine de Saint-Exupéry', 'ano': 1943, 'editora': 'Reynal & Hitchcock', 'preco': 18.5, 'ISBN': '978-3-16-148410-0', 'formato': 'Capa dura'}\n",
      "\n",
      "5. fromkeys()\n",
      "\n",
      "Dicionário criado com fromkeys() {'Titulo': 'Desconhecido', 'Autor': 'Desconhecido', 'sinopse': 'Desconhecido'}\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Métodos de Dicionários\n",
    "        keys(), values(), e items()\n",
    "        clear()\n",
    "        setdefault()\n",
    "        update()\n",
    "        fromkeys()\n",
    "\"\"\"\n",
    "\n",
    "#Exemplo Prático:\n",
    "\n",
    "#Vamos supor que estamos administrando uma livraria e \n",
    "#temos um dicionário que representa um livro específico. \n",
    "\n",
    "#Usaremos diferentes métodos de dicionário para manipular e \n",
    "#extrair informações sobre esse livro.\n",
    "\n",
    "# Dicionário representando um livro\n",
    "# Inicialização de um dicionário chamado 'livro' para \n",
    "# representar características de um livro específico\n",
    "livro = {\n",
    "    \"titulo\": \"O Pequeno Príncipe\",               # Chave 'titulo' com o valor \"O Pequeno Príncipe\"\n",
    "    \"autor\": \"Antoine de Saint-Exupéry\",          # Chave 'autor' com o valor \"Antoine de Saint-Exupéry\"\n",
    "    \"ano\": 1943,                                  # Chave 'ano' com o valor numérico 1943\n",
    "    \"editora\": \"Reynal & Hitchcock\",              # Chave 'editora' com o valor \"Reynal & Hitchcock\"\n",
    "    \"preco\": 20.5                                 # Chave 'preco' com o valor numérico 20.5\n",
    "}\n",
    "\n",
    "\n",
    "# 1. keys(), values(), e items()\n",
    "print(\"\\n1. keys(), values(), e items()\")\n",
    "print(\"Chaves do dicionário:\", list(livro.keys())) # Retorna todas as chaves\n",
    "print(\"Valores do dicionário:\", list(livro.values())) # Retorna todos os valores\n",
    "print(\"Itens do dicionário:\", list(livro.items())) # Retorna pares chave-valor\n",
    "\n",
    "# 2. clear()\n",
    "print(\"\\n2. clear()\")\n",
    "copia_livro = livro.copy()\n",
    "copia_livro.clear() # Remove todos os itens do dicionário\n",
    "print(\"\\nDicionário após clear():\", copia_livro)\n",
    "\n",
    "# 3. setdefault()\n",
    "# Retorna o valor da chave especificada. Se a chave não existir, insere a \n",
    "#chave com um valor especificado (ou padrão se nenhum valor for fornecido)\n",
    "print(\"\\n3. setdefault()\")\n",
    "isbn = livro.setdefault(\"ISBN\", \"978-3-16-148410-0\")\n",
    "print(\"\\nISBN:\", isbn)\n",
    "print(\"Dicionário após setdefault():\", livro)\n",
    "\n",
    "# 4. update()\n",
    "# Atualiza o dicionário com elementos de outro dicionário ou de um iterável com pares chave-valor\n",
    "print(\"\\n4. update()\")\n",
    "\n",
    "# Inicialização de um dicionário chamado 'atualizacoes' contendo os itens a serem \n",
    "#atualizados ou adicionados ao dicionário 'livro'\n",
    "atualizacoes = {\n",
    "    \"preco\": 18.5,              # Chave 'preco' com o novo valor numérico 18.5\n",
    "    \"formato\": \"Capa dura\"     # Chave 'formato' com o valor \"Capa dura\" (esse é um novo item que será adicionado ao dicionário 'livro')\n",
    "}\n",
    "\n",
    "# Utilização do método .update() do dicionário 'livro' para atualizar (ou adicionar) os itens a partir do dicionário 'atualizacoes'\n",
    "livro.update(atualizacoes)\n",
    "\n",
    "print(\"\\nDicionário após update():\", livro)\n",
    "\n",
    "# 5. fromkeys()\n",
    "# Retorna um novo dicionário com chaves de um iterável e valor definido\n",
    "print(\"\\n5. fromkeys()\")\n",
    "\n",
    "# Lista de chaves que queremos usar para criar um novo dicionário\n",
    "chaves = [\"titulo\", \"autor\", \"sinopse\"]\n",
    "\n",
    "# Utilização do método .fromkeys() da classe dict para criar um novo dicionário ('novo_livro').\n",
    "# Todas as chaves especificadas na lista 'chaves' terão o valor \"Desconhecido\".\n",
    "novo_livro = dict.fromkeys(chaves, \"Desconhecido\")\n",
    "\n",
    "# Impressão do dicionário recém-criado 'novo_livro'.\n",
    "print(\"\\nDicionário criado com fromkeys():\", novo_livro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30ed1d4e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "78a831da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "1. keys(), values(), e items()\n",
      "Chaves: ['titulo', 'diretor', 'ano', 'genero']\n",
      "Valores: ['Inception', 'Christopher Nolan', 2010, 'Ficção Científica']\n",
      "Itens: [('titulo', 'Inception'), ('diretor', 'Christopher Nolan'), ('ano', 2010), ('genero', 'Ficção Científica')]\n",
      "\n",
      "2. clear()\n",
      "\n",
      "Dicionário após clear(): {}\n",
      "\n",
      "3. setdefault()\n",
      "\n",
      "Elenco: ['Leonardo DiCaprio', 'Ellen Page']\n",
      "Dicionário após setdefault(): {'titulo': 'Inception', 'diretor': 'Christopher Nolan', 'ano': 2010, 'genero': 'Ficção Científica', 'elenco': ['Leonardo DiCaprio', 'Ellen Page']}\n",
      "\n",
      "4. update()\n",
      "\n",
      "Dicionário após update(): {'titulo': 'Inception', 'diretor': 'Christopher Nolan', 'ano': 2010, 'genero': 'Ficção Científica', 'elenco': ['Leonardo DiCaprio', 'Ellen Page'], 'duracao': 148, 'idioma': 'Inglês'}\n",
      "\n",
      "5. fromkeys()\n",
      "\n",
      "Dicionário criado com fromkeys(): {'nome': 'Desconhecido', 'idade': 'Desconhecido', 'ocupacao': 'Desconhecido'}\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício sobre Métodos de Dicionários\n",
    "\n",
    "Objetivo: Utilizando um dicionário que contém informações sobre \n",
    "um filme, pratique o uso dos métodos de dicionários.\n",
    "\n",
    "Dicionário fornecido:\n",
    "\n",
    "filme = {\n",
    "    \"titulo\": \"Inception\",\n",
    "    \"diretor\": \"Christopher Nolan\",\n",
    "    \"ano\": 2010,\n",
    "    \"genero\": \"Ficção Científica\"\n",
    "}\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. keys(), values(), e items()\n",
    "        - Imprima todas as chaves do dicionário filme.\n",
    "        - Imprima todos os valores do dicionário filme.\n",
    "        - Imprima todos os pares chave-valor do dicionário filme em formato de lista de tuplas.\n",
    "\n",
    "    2. clear()\n",
    "        - Faça uma cópia do dicionário filme e limpe todos os elementos \n",
    "        dessa cópia. Verifique se a cópia foi realmente esvaziada.\n",
    "\n",
    "    3. setdefault()\n",
    "        - Verifique se a chave \"elenco\" existe no dicionário filme. Se \n",
    "        não existir, adicione-a com o valor [\"Leonardo DiCaprio\", \"Ellen Page\"].\n",
    "\n",
    "    4. update()\n",
    "        - Atualize o dicionário filme com as seguintes \n",
    "        informações: duracao de 148 minutos e idioma como \"Inglês\".\n",
    "\n",
    "    5. fromkeys()\n",
    "        - Crie um novo dicionário a partir de uma lista de \n",
    "        chaves [\"nome\", \"idade\", \"ocupacao\"] e defina o valor \n",
    "        padrão para todas as chaves como \"Desconhecido\".\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "# Inicialização de um dicionário chamado 'filme' para representar características de um filme específico\n",
    "filme = {\n",
    "    \"titulo\": \"Inception\",                       # Chave 'titulo' com o valor \"Inception\"\n",
    "    \"diretor\": \"Christopher Nolan\",              # Chave 'diretor' com o valor \"Christopher Nolan\"\n",
    "    \"ano\": 2010,                                # Chave 'ano' com o valor numérico 2010\n",
    "    \"genero\": \"Ficção Científica\"                # Chave 'genero' com o valor \"Ficção Científica\"\n",
    "}\n",
    "\n",
    "# 1. Demonstração dos métodos keys(), values(), e items() em dicionários\n",
    "print(\"\\n1. keys(), values(), e items()\")\n",
    "\n",
    "# Extraindo e imprimindo as chaves do dicionário 'filme' usando o método keys()\n",
    "print(\"Chaves:\", list(filme.keys()))\n",
    "\n",
    "# Extraindo e imprimindo os valores do dicionário 'filme' usando o método values()\n",
    "print(\"Valores:\", list(filme.values()))\n",
    "\n",
    "# Extraindo e imprimindo os pares chave-valor do dicionário 'filme' usando o método items()\n",
    "print(\"Itens:\", list(filme.items()))\n",
    "\n",
    "\n",
    "# 2. Demonstração do método clear() para limpar o conteúdo de um dicionário\n",
    "print(\"\\n2. clear()\")\n",
    "\n",
    "# Fazendo uma cópia do dicionário 'filme' e armazenando em 'filme_copia'\n",
    "filme_copia = filme.copy()\n",
    "\n",
    "# Usando o método clear() para limpar todos os itens de 'filme_copia'\n",
    "filme_copia.clear()\n",
    "print(\"\\nDicionário após clear():\", filme_copia)\n",
    "\n",
    "\n",
    "# 3. Demonstração do método setdefault() para obter o valor de uma chave ou definir um padrão se ela não existir\n",
    "print(\"\\n3. setdefault()\")\n",
    "\n",
    "# Tentando obter a chave 'elenco' no dicionário 'filme'; se não existir, ela será criada com o valor fornecido\n",
    "elenco = filme.setdefault(\"elenco\", [\"Leonardo DiCaprio\", \"Ellen Page\"])\n",
    "print(\"\\nElenco:\", elenco)\n",
    "print(\"Dicionário após setdefault():\", filme)\n",
    "\n",
    "\n",
    "# 4. Demonstração do método update() para adicionar ou atualizar itens no dicionário\n",
    "print(\"\\n4. update()\")\n",
    "\n",
    "# Definindo um novo dicionário com informações adicionais\n",
    "informacoes_adicionais = {\n",
    "    \"duracao\": 148,\n",
    "    \"idioma\": \"Inglês\"\n",
    "}\n",
    "\n",
    "# Atualizando o dicionário 'filme' com as informações de \n",
    "#'informacoes_adicionais'\n",
    "filme.update(informacoes_adicionais)\n",
    "print(\"\\nDicionário após update():\", filme)\n",
    "\n",
    "# 5. Demonstração do método fromkeys() para criar um novo dicionário com chaves especificadas e um valor padrão\n",
    "print(\"\\n5. fromkeys()\")\n",
    "\n",
    "# Lista de chaves que queremos usar para criar um novo dicionário\n",
    "chaves = [\"nome\", \"idade\", \"ocupacao\"]\n",
    "\n",
    "# Criando um novo dicionário usando as chaves fornecidas com o valor \"Desconhecido\"\n",
    "perfil = dict.fromkeys(chaves, \"Desconhecido\")\n",
    "print(\"\\nDicionário criado com fromkeys():\", perfil)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6a3ff7f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d0362595",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matérias cursadas pelo aluno:\n",
      "Matemática\n",
      "Português\n",
      "História\n",
      "Geografia\n",
      "Química\n",
      "\n",
      "Matérias (usando .keys()):\n",
      "Matemática\n",
      "Português\n",
      "História\n",
      "Geografia\n",
      "Química\n",
      "\n",
      "Notas do aluno:\n",
      "8.5\n",
      "9.0\n",
      "7.5\n",
      "8.0\n",
      "9.5\n",
      "\n",
      "Média das notas: 8.5\n",
      "\n",
      "Relatório de notas:\n",
      "Matemática: 8.5\n",
      "Português: 9.0\n",
      "História: 7.5\n",
      "Geografia: 8.0\n",
      "Química: 9.5\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Iterando Sobre Dicionários\n",
    "        Usando loops for\n",
    "        Iterando sobre chaves, valores e itens\n",
    "\"\"\"\n",
    "\n",
    "#Iterando Sobre Dicionários\n",
    "\n",
    "#Exemplo Prático:\n",
    "\n",
    "#Imagine que temos um dicionário que representa as notas de um aluno\n",
    "#em diferentes matérias. Queremos iterar sobre esse dicionário para \n",
    "#exibir as matérias, as notas e também calcular a média das notas.\n",
    "\n",
    "# Definindo um dicionário chamado 'notas' que armazena \n",
    "# as notas do aluno em diferentes matérias\n",
    "notas = {\n",
    "    \"Matemática\": 8.5,  # Matemática: 8.5\n",
    "    \"Português\": 9.0,   # Português: 9.0\n",
    "    \"História\": 7.5,    # História: 7.5\n",
    "    \"Geografia\": 8.0,   # Geografia: 8.0\n",
    "    \"Química\": 9.5      # Química: 9.5\n",
    "}\n",
    "\n",
    "# 1. Iteração sobre as chaves do dicionário (neste caso, são as matérias)\n",
    "\n",
    "# Imprimindo um cabeçalho para identificar a seção de saída\n",
    "print(\"Matérias cursadas pelo aluno:\")\n",
    "\n",
    "# Usando um loop 'for' para iterar sobre as chaves do \n",
    "#dicionário 'notas' (por padrão, a iteração é feita sobre as chaves)\n",
    "for materia in notas:\n",
    "    print(materia)\n",
    "    \n",
    "# Outra forma de iterar sobre as chaves de um \n",
    "# dicionário é usar o método .keys()\n",
    "\n",
    "# Imprimindo um cabeçalho para identificar a nova seção de saída\n",
    "print(\"\\nMatérias (usando .keys()):\")\n",
    "\n",
    "# Iterando sobre as chaves do dicionário 'notas' usando o \n",
    "#método .keys() e imprimindo cada chave\n",
    "for materia in notas.keys():\n",
    "    print(materia)\n",
    "\n",
    "    \n",
    "# 2. Iterando apenas sobre os valores (notas)\n",
    "\n",
    "# Imprimindo um cabeçalho para identificar a seção de saída\n",
    "print(\"\\nNotas do aluno:\")\n",
    "\n",
    "# Inicializando uma variável 'total' para somar as notas do aluno\n",
    "total = 0\n",
    "\n",
    "# Usando um loop 'for' para iterar sobre os valores do \n",
    "# dicionário 'notas' usando o método .values()\n",
    "for nota in notas.values():\n",
    "    \n",
    "    # Imprimindo a nota atual\n",
    "    print(nota)\n",
    "    \n",
    "    # Somando a nota atual ao total\n",
    "    # total = total + nota\n",
    "    total += nota\n",
    "\n",
    "# Calculando a média das notas dividindo o total pelo \n",
    "# número de notas (len(notas))\n",
    "media = total / len(notas)\n",
    "\n",
    "# Imprimindo a média calculada\n",
    "print(\"\\nMédia das notas:\", media)\n",
    "\n",
    "\n",
    "# 3. Iterando sobre chaves e valores simultaneamente (itens)\n",
    "\n",
    "# Imprimindo um cabeçalho para identificar a seção de saída\n",
    "print(\"\\nRelatório de notas:\")\n",
    "\n",
    "# Utilizando um loop 'for' para iterar sobre as chaves (matérias) e \n",
    "#valores (notas) do dicionário 'notas' simultaneamente\n",
    "for materia, nota in notas.items():\n",
    "    \n",
    "    # Imprimindo a matéria e a nota correspondente em formato formatado\n",
    "    print(f\"{materia}: {nota}\")\n",
    "\n",
    "\n",
    "    \n",
    "\"\"\"\n",
    "Neste exemplo, mostramos três formas de iterar sobre dicionários: \n",
    "pelas chaves, pelos valores e pelos pares chave-valor (itens). \n",
    "\n",
    "As estruturas de repetição, como o loop for, tornam muito conveniente \n",
    "trabalhar com dicionários em Python.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07441fbc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "3bd4c421",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meses de vendas registradas:\n",
      "Janeiro\n",
      "Fevereiro\n",
      "Março\n",
      "Abril\n",
      "Maio\n",
      "\n",
      "2. Iterando sobre valores\n",
      "\n",
      "Total de livros vendidos: 750\n",
      "Mês com as vendas mais baixas: Março com 80 livros vendidos.\n",
      "\n",
      "3. Iterando sobre chaves e valores simultaneamente\n",
      "\n",
      "Resumo das vendas:\n",
      "Em Janeiro, 120 livros foram vendidos.\n",
      "Em Fevereiro, 150 livros foram vendidos.\n",
      "Em Março, 80 livros foram vendidos.\n",
      "Em Abril, 190 livros foram vendidos.\n",
      "Em Maio, 210 livros foram vendidos.\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício sobre Iterando Sobre Dicionários\n",
    "\n",
    "Objetivo: Você tem um dicionário que representa o número de livros vendidos \n",
    "em uma livraria em diferentes meses. Sua tarefa é iterar sobre esse dicionário \n",
    "para realizar diferentes análises.\n",
    "\n",
    "Dicionário fornecido:\n",
    "\n",
    "vendas = {\n",
    "    \"Janeiro\": 120,\n",
    "    \"Fevereiro\": 150,\n",
    "    \"Março\": 80,\n",
    "    \"Abril\": 190,\n",
    "    \"Maio\": 210\n",
    "}\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Iterando sobre as chaves (meses):\n",
    "        - Imprima todos os meses em que a livraria registrou vendas.\n",
    "\n",
    "    2. Iterando apenas sobre os valores (número de livros vendidos):\n",
    "        - Calcule e imprima a venda total nos 5 meses.\n",
    "        - Determine e imprima o mês com as vendas mais baixas.\n",
    "\n",
    "    3. Iterando sobre chaves e valores simultaneamente (itens):\n",
    "        - Para cada mês, imprima uma mensagem no seguinte \n",
    "        formato: \"Em [mês], [número] livros foram vendidos\".\n",
    "        \n",
    "\"\"\"\n",
    "\n",
    "#Solução\n",
    "\n",
    "# Definindo um dicionário 'vendas' para armazenar as vendas mensais\n",
    "vendas = {\n",
    "    \"Janeiro\": 120,    # Vendas de Janeiro\n",
    "    \"Fevereiro\": 150,  # Vendas de Fevereiro\n",
    "    \"Março\": 80,       # Vendas de Março\n",
    "    \"Abril\": 190,      # Vendas de Abril\n",
    "    \"Maio\": 210        # Vendas de Maio\n",
    "}\n",
    "\n",
    "\n",
    "# 1. Iterando sobre chaves\n",
    "\n",
    "# Imprime um cabeçalho informativo para a seção de saída\n",
    "print(\"Meses de vendas registradas:\")\n",
    "\n",
    "# Itera através das chaves do dicionário 'vendas' (que são os meses)\n",
    "for mes in vendas:\n",
    "    \n",
    "    # Imprime o nome do mês\n",
    "    print(mes)\n",
    "\n",
    "\n",
    "# 2. Iterando sobre valores\n",
    "\n",
    "#- Calcule e imprima a venda total nos 5 meses.\n",
    "#- Determine e imprima o mês com as vendas mais baixas.\n",
    "\n",
    "print(\"\\n2. Iterando sobre valores\")\n",
    "\n",
    "total_vendas = 0\n",
    "vendas_mais_baixas = float('inf')\n",
    "\n",
    "mes_vendas_mais_baixas = \"\"\n",
    "\n",
    "# Para cada 'venda' dentro dos valores do dicionário 'vendas'\n",
    "for venda in vendas.values():\n",
    "    \n",
    "    # Adiciona o valor da venda atual ao total de vendas\n",
    "    total_vendas += venda\n",
    "    \n",
    "    # Verifica se a venda atual é menor do que o valor armazenado em 'vendas_mais_baixas'\n",
    "    if venda < vendas_mais_baixas:\n",
    "        \n",
    "        # Se for, atualiza 'vendas_mais_baixas' com o valor da venda atual\n",
    "        vendas_mais_baixas = venda\n",
    "\n",
    "# Para cada par 'mes' e 'venda' no dicionário 'vendas'\n",
    "for mes, venda in vendas.items():\n",
    "    \n",
    "    # Verifica se a venda atual é igual ao valor mais baixo registrado\n",
    "    if venda == vendas_mais_baixas:\n",
    "        \n",
    "        # Se for, armazena o mês correspondente em 'mes_vendas_mais_baixas'\n",
    "        mes_vendas_mais_baixas = mes\n",
    "        \n",
    "        # Encerra o loop (não precisa continuar a busca)\n",
    "        break\n",
    "\n",
    "\n",
    "print(\"\\nTotal de livros vendidos:\", total_vendas)\n",
    "print(f\"Mês com as vendas mais baixas: {mes_vendas_mais_baixas} com {vendas_mais_baixas} livros vendidos.\") \n",
    "\n",
    "\n",
    "# 3. Iterando sobre chaves e valores simultaneamente\n",
    "print(\"\\n3. Iterando sobre chaves e valores simultaneamente\")\n",
    "print(\"\\nResumo das vendas:\")\n",
    "\n",
    "# Para cada par 'mes' e 'venda' no dicionário 'vendas'\n",
    "for mes, venda in vendas.items():\n",
    "    \n",
    "    # Imprime uma mensagem formatada com o mês e a quantidade de livros vendidos\n",
    "    print(f\"Em {mes}, {venda} livros foram vendidos.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e929efd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "17c132b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nota do João em Matemática: 8.5\n",
      "Nota atualizada de Maria em Geografia: 9.2\n",
      "Nota do Pedro em Química: 8.8\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\"\"\"\n",
    "Dicionários Aninhados\n",
    "        Acessando e modificando valores em dicionários aninhados\n",
    "\"\"\"\n",
    "\n",
    "#Dicionários Aninhados\n",
    "\n",
    "#Um dicionário aninhado é um dicionário dentro de outro dicionário. \n",
    "#É uma forma útil de representar, por exemplo, dados hierárquicos ou estruturados.\n",
    "\n",
    "#Exemplo Prático:\n",
    "\n",
    "#Imagine que você está administrando uma escola e quer armazenar informações \n",
    "#sobre seus alunos, incluindo suas notas em diferentes matérias. Um dicionário aninhado \n",
    "#seria útil nesse cenário.\n",
    "\n",
    "# Dicionário de alunos com notas em diferentes matérias\n",
    "\n",
    "# Definindo um dicionário chamado 'alunos'.\n",
    "# Cada chave do dicionário representa o nome de um aluno, e o valor \n",
    "# associado é outro dicionário que contém as notas do aluno nas diferentes matérias.\n",
    "\n",
    "# Inicializando um dicionário chamado 'alunos' para armazenar as notas \n",
    "#dos alunos em diferentes matérias.\n",
    "\n",
    "alunos = {\n",
    "    \"João\": {          # Informações sobre o aluno chamado \"João\".\n",
    "        \"Matemática\": 8.5,  # Nota de João em Matemática.\n",
    "        \"Português\": 9.0,   # Nota de João em Português.\n",
    "        \"História\": 7.5     # Nota de João em História.\n",
    "    },\n",
    "    \"Maria\": {         # Informações sobre a aluna chamada \"Maria\".\n",
    "        \"Matemática\": 9.5,  # Nota de Maria em Matemática.\n",
    "        \"Português\": 8.0,   # Nota de Maria em Português.\n",
    "        \"Geografia\": 8.7    # Nota de Maria em Geografia.\n",
    "    },\n",
    "    \"Pedro\": {         # Informações sobre o aluno chamado \"Pedro\".\n",
    "        \"Matemática\": 7.0,  # Nota de Pedro em Matemática.\n",
    "        \"Português\": 7.5,   # Nota de Pedro em Português.\n",
    "        \"História\": 8.0,    # Nota de Pedro em História.\n",
    "        \"Geografia\": 9.0    # Nota de Pedro em Geografia.\n",
    "    }\n",
    "}\n",
    "\n",
    "# Acessando notas do João em Matemática\n",
    "nota_joao_matematica = alunos[\"João\"][\"Matemática\"]\n",
    "print(f\"Nota do João em Matemática: {nota_joao_matematica}\")\n",
    "\n",
    "# Modificando a nota de Maria em Geografia\n",
    "alunos[\"Maria\"][\"Geografia\"] = 9.2\n",
    "print(f\"Nota atualizada de Maria em Geografia: {alunos['Maria']['Geografia']}\")\n",
    "\n",
    "# Adicionando um nota de Química para Pedro\n",
    "alunos[\"Pedro\"][\"Química\"] = 8.8\n",
    "print(f\"Nota do Pedro em Química: {alunos['Pedro']['Química']}\")\n",
    "\n",
    "\"\"\"\n",
    "Neste exemplo, temos um dicionário alunos, onde cada chave é o nome \n",
    "de um aluno e o valor associado é outro dicionário que contém as notas \n",
    "desse aluno em diferentes matérias. Ao usar chaves de maneira hierárquica, \n",
    "podemos acessar e modificar facilmente valores em dicionários aninhados.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea5814e3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "5f8be619",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. Modelo do carro na vaga B2: Civic\n",
      "2. Modificando dono do carro em A1: Sra. Lúcia\n",
      "\n",
      "3. Adicionando carro em D4 {'marca': 'Chevrolet', 'modelo': 'Onix', 'dono': 'Sr. Roberto'}\n",
      "\n",
      "4. Acessando marca do carro da Sra. Lúcia\n",
      "Marca do carro da Sra. Lúcia: Toyota\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício sobre Dicionários Aninhados\n",
    "\n",
    "Objetivo: Você possui um dicionário que contém informações \n",
    "sobre carros em um estacionamento, incluindo a marca, modelo e dono \n",
    "do carro. Seu objetivo é acessar e modificar algumas informações nesse dicionário.\n",
    "\n",
    "Dicionário fornecido:\n",
    "\n",
    "estacionamento = {\n",
    "    \"A1\": {\n",
    "        \"marca\": \"Toyota\",\n",
    "        \"modelo\": \"Corolla\",\n",
    "        \"dono\": \"Sr. Silva\"\n",
    "    },\n",
    "    \"B2\": {\n",
    "        \"marca\": \"Honda\",\n",
    "        \"modelo\": \"Civic\",\n",
    "        \"dono\": \"Dona Maria\"\n",
    "    },\n",
    "    \"C3\": {\n",
    "        \"marca\": \"Ford\",\n",
    "        \"modelo\": \"Mustang\",\n",
    "        \"dono\": \"Sr. Jorge\"\n",
    "    }\n",
    "}\n",
    "\n",
    "\n",
    "Onde as chaves (A1, B2, C3) representam as vagas no estacionamento.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Acesse e imprima o modelo do carro estacionado na vaga \"B2\".\n",
    "    \n",
    "    2. Altere o dono do carro na vaga \"A1\" para \"Sra. Lúcia\".\n",
    "    \n",
    "    3. Adicione um novo carro na vaga \"D4\" com as seguintes \n",
    "        informações: marca \"Chevrolet\", modelo \"Onix\", dono \"Sr. Roberto\".\n",
    "        \n",
    "    4. Acesse e imprima a marca do carro que agora pertence à \"Sra. Lúcia\".\n",
    "\"\"\"\n",
    "\n",
    "#Solução \n",
    "\n",
    "# Definindo um dicionário chamado 'estacionamento'.\n",
    "# Cada chave do dicionário representa um espaço no estacionamento, \n",
    "#e o valor associado é outro dicionário que contém detalhes do carro \n",
    "#estacionado naquela vaga.\n",
    "\n",
    "# Inicializando um dicionário chamado 'estacionamento' com informações de veículos.\n",
    "estacionamento = {\n",
    "    \"A1\": {               # Vaga \"A1\" do estacionamento.\n",
    "        \"marca\": \"Toyota\",  # Marca do carro estacionado na vaga \"A1\".\n",
    "        \"modelo\": \"Corolla\", # Modelo do carro estacionado na vaga \"A1\".\n",
    "        \"dono\": \"Sr. Silva\"  # Dono do carro estacionado na vaga \"A1\".\n",
    "    },\n",
    "    \"B2\": {               # Vaga \"B2\" do estacionamento.\n",
    "        \"marca\": \"Honda\",   # Marca do carro estacionado na vaga \"B2\".\n",
    "        \"modelo\": \"Civic\",  # Modelo do carro estacionado na vaga \"B2\".\n",
    "        \"dono\": \"Dona Maria\" # Dono do carro estacionado na vaga \"B2\".\n",
    "    },\n",
    "    \"C3\": {               # Vaga \"C3\" do estacionamento.\n",
    "        \"marca\": \"Ford\",    # Marca do carro estacionado na vaga \"C3\".\n",
    "        \"modelo\": \"Mustang\", # Modelo do carro estacionado na vaga \"C3\".\n",
    "        \"dono\": \"Sr. Jorge\"  # Dono do carro estacionado na vaga \"C3\".\n",
    "    }\n",
    "}\n",
    "\n",
    "# 1. Acesse e imprima o modelo do carro estacionado na vaga \"B2\".\n",
    "print(\"1. Modelo do carro na vaga B2:\", estacionamento[\"B2\"][\"modelo\"])\n",
    "\n",
    "# 2. Altere o dono do carro na vaga \"A1\" para \"Sra. Lúcia\".\n",
    "estacionamento[\"A1\"][\"dono\"] = \"Sra. Lúcia\"\n",
    "print(f\"2. Modificando dono do carro em A1: {estacionamento['A1']['dono']}\")\n",
    "\n",
    "# 3. Adicione um novo carro na vaga \"D4\" com as seguintes \n",
    "# informações: marca \"Chevrolet\", modelo \"Onix\", dono \"Sr. Roberto\".\n",
    "\n",
    "# Atualizando ou adicionando um novo carro ao dicionário \n",
    "#'estacionamento' na posição \"D4\".\n",
    "estacionamento[\"D4\"] = {\n",
    "    \"marca\": \"Chevrolet\",  # Define a marca do carro como \"Chevrolet\".\n",
    "    \"modelo\": \"Onix\",      # Define o modelo do carro como \"Onix\".\n",
    "    \"dono\": \"Sr. Roberto\"  # Define o dono do carro como \"Sr. Roberto\".\n",
    "}\n",
    "\n",
    "\n",
    "# Exibindo as informações do carro que foi estacionado na vaga D4.\n",
    "print(\"\\n3. Adicionando carro em D4\", estacionamento[\"D4\"])\n",
    "\n",
    "\n",
    "# 4. Acesse e imprima a marca do carro que agora pertence à \"Sra. Lúcia\".\n",
    "\n",
    "print(\"\\n4. Acessando marca do carro da Sra. Lúcia\")\n",
    "\n",
    "# Para cada par 'vaga' e 'carro' no dicionário 'estacionamento'\n",
    "for vaga, carro in estacionamento.items():\n",
    "    \n",
    "    # Verifica se o campo \"dono\" do dicionário 'carro' é igual a \"Sra. Lúcia\"\n",
    "    if carro[\"dono\"] == \"Sra. Lúcia\":\n",
    "        \n",
    "        # Imprime a marca do carro que pertence à Sra. Lúcia\n",
    "        print(f\"Marca do carro da Sra. Lúcia: {carro['marca']}\")\n",
    "        \n",
    "        # Encerra o loop após encontrar o carro da Sra. Lúcia\n",
    "        break\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c63082c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "fb387e14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n",
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n",
      "{1: 'a', 2: 'b', 3: 'c'}\n",
      "{1: 'a', 2: 'b', 3: 'c'}\n",
      "{'laptop': 1000, 'monitor': 200}\n",
      "{'laptop': 1000, 'monitor': 200}\n",
      "{'Python': 6, 'compreensão': 11, 'dicionário': 10}\n",
      "{'Python': 6, 'compreensão': 11, 'dicionário': 10}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Compreensão de Dicionários (Dictionary Comprehension)\n",
    "        Sintaxe básica\n",
    "        Exemplos práticos\n",
    "\"\"\"\n",
    "\n",
    "#Compreensão de Dicionários (Dictionary Comprehension)\n",
    "\n",
    "#A compreensão de dicionários é uma maneira concisa de criar dicionários. \n",
    "#Assim como a compreensão de listas em Python, ela oferece uma forma mais legível \n",
    "#e muitas vezes mais rápida de criar dicionários do que usar loops for tradicionais.\n",
    "\n",
    "#Sintaxe Básica:\n",
    "\n",
    "#{chave: valor for item in iterável}\n",
    "\n",
    "#Exemplos Práticos:\n",
    "\n",
    "#1. Criar um dicionário com quadrados de números:\n",
    "\n",
    "#Suponha que queremos criar um dicionário onde as chaves \n",
    "#são números de 1 a 5 e os valores são seus quadrados.\n",
    "\n",
    "quadrados = {x: x**2 for x in range(1, 6)}\n",
    "print(quadrados)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n",
    "\n",
    "#Usando um loop for tradicional, ficaria assim:\n",
    "\n",
    "# Inicializa um dicionário vazio chamado \"quadrados\"\n",
    "quadrados = {}\n",
    "\n",
    "# Itera sobre os números de 1 a 5 (o intervalo vai até 6, mas o 6 não está incluído)\n",
    "for x in range(1, 6):\n",
    "    \n",
    "    # Para cada número \"x\", cria uma entrada no dicionário com \"x\" como chave \n",
    "    # e o quadrado de \"x\" como valor\n",
    "    quadrados[x] = x**2\n",
    "\n",
    "    \n",
    "print(quadrados)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n",
    "\n",
    "#2. Converter chaves em valores e valores em chaves:\n",
    "\n",
    "#Dado um dicionário, podemos querer inverter suas chaves e valores.\n",
    "\n",
    "original = {\"a\": 1, \"b\": 2, \"c\": 3}\n",
    "invertido = {valor: chave for chave, valor in original.items()}\n",
    "print(invertido)  # Output: {1: 'a', 2: 'b', 3: 'c'}\n",
    "\n",
    "#Usando um loop for tradicional, ficaria assim:\n",
    "\n",
    "# Inicializa um dicionário chamado \"original\" com pares chave-valor\n",
    "original = {\"a\": 1, \"b\": 2, \"c\": 3}\n",
    "\n",
    "# Inicializa um dicionário vazio chamado \"invertido\"\n",
    "invertido = {}\n",
    "\n",
    "# Itera sobre cada par chave-valor do dicionário \"original\"\n",
    "for chave, valor in original.items():\n",
    "    \n",
    "    # Para cada par, adiciona uma entrada ao dicionário \"invertido\" \n",
    "    # com o \"valor\" como chave e a \"chave\" original como valor\n",
    "    invertido[valor] = chave\n",
    "\n",
    "\n",
    "print(invertido)  # Output: {1: 'a', 2: 'b', 3: 'c'}\n",
    "\n",
    "#3. Filtrando itens de um dicionário:\n",
    "\n",
    "#Imagine que temos um dicionário com preços de produtos \n",
    "#e queremos filtrar apenas os produtos que custam mais de 50.\n",
    "\n",
    "# Iniciando um dicionário chamado 'precos'\n",
    "precos = {\n",
    "    \"laptop\": 1000,       # Chave: \"laptop\", Valor: 1000\n",
    "    \"mouse\": 25,          # Chave: \"mouse\", Valor: 25\n",
    "    \"monitor\": 200,       # Chave: \"monitor\", Valor: 200\n",
    "    \"teclado\": 30,        # Chave: \"teclado\", Valor: 30\n",
    "    \"cabo hdmi\": 10       # Chave: \"cabo hdmi\", Valor: 10\n",
    "}\n",
    "\n",
    "caros = {produto: preco for produto, preco in precos.items() if preco > 50}\n",
    "print(caros)  # Output: {'laptop': 1000, 'monitor': 200}\n",
    "\n",
    "\n",
    "#Usando um loop for tradicional, ficaria assim:\n",
    "\n",
    "# Inicializa um dicionário vazio chamado \"caros\"\n",
    "caros = {}\n",
    "\n",
    "# Itera sobre cada par chave-valor do dicionário \"precos\"\n",
    "for produto, preco in precos.items():\n",
    "    \n",
    "    # Verifica se o \"preco\" é maior que 50\n",
    "    if preco > 50:\n",
    "        \n",
    "        # Se o \"preco\" for maior que 50, adiciona a entrada correspondente ao dicionário \"caros\"\n",
    "        caros[produto] = preco\n",
    "\n",
    "\n",
    "print(caros)  # Output: {'laptop': 1000, 'monitor': 200}\n",
    "\n",
    "#4. Dicionário com palavras e seus comprimentos:\n",
    "\n",
    "#Dado uma lista de palavras, criar um dicionário com as \n",
    "#palavras como chaves e seus comprimentos como valores.\n",
    "\n",
    "palavras = [\"Python\", \"compreensão\", \"dicionário\"]\n",
    "comprimentos = {palavra: len(palavra) for palavra in palavras}\n",
    "print(comprimentos)  # Output: {'Python': 6, 'compreensão': 11, 'dicionário': 10}\n",
    "\n",
    "#Usando um loop for tradicional, você faria o seguinte:\n",
    "\n",
    "palavras = [\"Python\", \"compreensão\", \"dicionário\"]\n",
    "\n",
    "# Inicializa um dicionário vazio chamado \"comprimentos\"\n",
    "comprimentos = {}\n",
    "\n",
    "# Itera sobre cada \"palavra\" na lista \"palavras\"\n",
    "for palavra in palavras:\n",
    "    \n",
    "    # Para cada \"palavra\", calcula o seu comprimento usando a função \"len()\"\n",
    "    # e adiciona uma entrada ao dicionário \"comprimentos\" com a \"palavra\" como chave \n",
    "    # e seu comprimento como valor\n",
    "    comprimentos[palavra] = len(palavra)\n",
    "\n",
    "\n",
    "print(comprimentos)  # Output: {'Python': 6, 'compreensão': 11, 'dicionário': 10}\n",
    "\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Estes exemplos demonstram a versatilidade e a concisão das compreensões de \n",
    "dicionário em Python. Elas são especialmente úteis quando se quer transformar \n",
    "ou filtrar dados de maneira eficiente.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78342267",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a4e8f207",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n",
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Compreensão de Dicionários (Dictionary Comprehension)\n",
    "\n",
    "Objetivo: Familiarizar-se com a sintaxe básica da compreensão de dicionários em Python.\n",
    "\n",
    "\n",
    "Instruções:\n",
    "\n",
    "Dada a seguinte lista de números:\n",
    "\n",
    "numeros = [1, 2, 3, 4, 5]\n",
    "\n",
    "a) Use a compreensão de dicionário para criar um novo dicionário onde as \n",
    "chaves são os números da lista e os valores são os quadrados desses números.\n",
    "\n",
    "Resultado esperado:\n",
    "\n",
    "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n",
    "\n",
    "\n",
    "Dica:\n",
    "\n",
    "Para elevar um número ao quadrado, use o operador **. Por exemplo, 3**2 resulta em 9.\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#Solução:\n",
    "\n",
    "#Dada a lista de números:\n",
    "numeros = [1, 2, 3, 4, 5]\n",
    "\n",
    "#Você pode criar um dicionário onde as chaves são os números da lista e \n",
    "#os valores são os quadrados desses números, usando a seguinte compreensão de dicionário:\n",
    "\n",
    "quadrados = {n: n**2 for n in numeros}\n",
    "\n",
    "#Ao imprimir o dicionário quadrados:\n",
    "print(quadrados)\n",
    "\n",
    "\n",
    "#Usando um loop for tradicional da seguinte maneira:\n",
    "\n",
    "numeros = [1, 2, 3, 4, 5]\n",
    "\n",
    "quadrados = {}  # Inicializa um dicionário vazio\n",
    "\n",
    "for n in numeros:\n",
    "    quadrados[n] = n**2  # Adiciona o número e seu quadrado ao dicionário\n",
    "\n",
    "print(quadrados)  # Isso imprimirá {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "155955f8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "d184fff1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nome: João\n",
      "Idade: 25\n",
      "Email: joao@email.com\n",
      "\n",
      "Novo Perfil Criado:\n",
      "Nome: Ana\n",
      "Idade: 30\n",
      "Email: ana@email.com\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Dicionários e Funções\n",
    "        Passando dicionários como argumentos para funções\n",
    "        Retornando dicionários de funções\n",
    "\"\"\"\n",
    "\n",
    "#Exemplo Prático: Dicionários e Funções\n",
    "\n",
    "#Vamos criar um sistema simples de gestão de perfis de usuários:\n",
    "\n",
    "#1. Passando dicionários como argumentos para funções:\n",
    "#Suponha que temos um dicionário representando um perfil de usuário e \n",
    "#queremos exibir este perfil.\n",
    "\n",
    "#2. Retornando dicionários de funções:\n",
    "#Vamos criar uma função que pode criar um novo perfil de usuário \n",
    "#com base em informações fornecidas.\n",
    "\n",
    "# Definição do dicionário do perfil do usuário\n",
    "\n",
    "# Iniciando um dicionário chamado 'usuario'\n",
    "usuario = {\n",
    "    \"nome\": \"João\",\n",
    "    \"idade\": 25,\n",
    "    \"email\": \"joao@email.com\"\n",
    "}\n",
    "\n",
    "# 1. Passando dicionários como argumentos para funções\n",
    "\n",
    "# Define uma função chamada 'exibir_perfil' que aceita um dicionário 'perfil' como parâmetro\n",
    "def exibir_perfil(perfil):\n",
    "    \n",
    "    # Para cada par de chave-valor no dicionário 'perfil'\n",
    "    for chave, valor in perfil.items():\n",
    "        \n",
    "        # Imprime a chave (formatada com a primeira letra maiúscula) e seu respectivo valor\n",
    "        print(f\"{chave.title()}: {valor}\")\n",
    "\n",
    "# Chama a função 'exibir_perfil' passando o dicionário 'usuario' como argumento\n",
    "exibir_perfil(usuario)\n",
    "\n",
    "# 2. Retornando dicionários de funções\n",
    "\n",
    "# Definindo uma função chamada 'criar_perfil'\n",
    "def criar_perfil(nome, idade, email):\n",
    "    \n",
    "    \"\"\"Retorna um dicionário representando um perfil de usuário\"\"\"\n",
    "    \n",
    "    # Criando e retornando um dicionário com as informações do perfil do usuário\n",
    "    return {\n",
    "        \"nome\": nome,   # Chave: \"nome\", Valor: valor da variável 'nome'\n",
    "        \"idade\": idade, # Chave: \"idade\", Valor: valor da variável 'idade'\n",
    "        \"email\": email  # Chave: \"email\", Valor: valor da variável 'email'\n",
    "    }\n",
    "\n",
    "# Criando um novo perfil de usuário usando a função 'criar_perfil'\n",
    "novo_usuario = criar_perfil(\"Ana\", 30, \"ana@email.com\")\n",
    "\n",
    "print(\"\\nNovo Perfil Criado:\")\n",
    "\n",
    "# Exibindo o perfil do novo usuário\n",
    "exibir_perfil(novo_usuario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c785f64",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "bab68827",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'titulo': '1984', 'autor': 'George Orwell', 'ano': 1949}\n",
      "\n",
      "Título: 1984\n",
      "Autor: George Orwell\n",
      "Ano: 1949\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Dicionários e Funções\n",
    "\n",
    "Objetivo: Praticar a interação entre dicionários e funções, aprendendo \n",
    "a passar dicionários como argumentos e a retornar dicionários a partir de funções.\n",
    "\n",
    "Contexto:\n",
    "\n",
    "Imagine que você está construindo um sistema para uma biblioteca. Este sistema deve ser capaz de:\n",
    "\n",
    "    Registrar um novo livro, fornecendo título, autor e ano de publicação.\n",
    "    Exibir detalhes de um livro registrado.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Registro de Livro:\n",
    "\n",
    "        a) Crie uma função chamada registrar_livro que aceite \n",
    "        três parâmetros: titulo, autor e ano.\n",
    "\n",
    "        b) Esta função deve retornar um dicionário representando o livro. O dicionário deve \n",
    "        ter três chaves: 'titulo', 'autor' e 'ano', e os valores correspondentes devem ser \n",
    "        os fornecidos à função.\n",
    "\n",
    "        Por exemplo:\n",
    "\n",
    "        livro = registrar_livro(\"1984\", \"George Orwell\", 1949)\n",
    "        print(livro)\n",
    "        # Output esperado: {'titulo': '1984', 'autor': 'George Orwell', 'ano': 1949}\n",
    "        \n",
    "    2. Exibição de Livro:\n",
    "\n",
    "        a) Crie uma função chamada exibir_livro que aceite um \n",
    "        dicionário (representando um livro) como seu único argumento.\n",
    "\n",
    "        b) A função deve imprimir os detalhes do livro em um formato \n",
    "        legível. Por exemplo:\n",
    "        \n",
    "        Título: 1984\n",
    "        Autor: George Orwell\n",
    "        Ano: 1949\n",
    "        \n",
    "        c) Teste sua função exibir_livro usando o dicionário que você criou \n",
    "        na etapa anterior (usando a função registrar_livro).\n",
    "\n",
    "    Dicas:\n",
    "\n",
    "        Lembre-se de usar o operador de atribuição = para criar pares \n",
    "        chave-valor no dicionário.\n",
    "        \n",
    "        Ao exibir os detalhes do livro, você pode usar um loop para iterar sobre \n",
    "        os pares chave-valor do dicionário ou acessar cada chave individualmente.\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#Solução\n",
    "\n",
    "\"\"\"\n",
    "1. Registro de Livro:\n",
    "\n",
    "        a) Crie uma função chamada registrar_livro que aceite \n",
    "        três parâmetros: titulo, autor e ano.\n",
    "\n",
    "        b) Esta função deve retornar um dicionário representando o livro. O dicionário deve \n",
    "        ter três chaves: 'titulo', 'autor' e 'ano', e os valores correspondentes devem ser \n",
    "        os fornecidos à função.\n",
    "\n",
    "        Por exemplo:\n",
    "\n",
    "        livro = registrar_livro(\"1984\", \"George Orwell\", 1949)\n",
    "        print(livro)\n",
    "        # Output esperado: {'titulo': '1984', 'autor': 'George Orwell', 'ano': 1949}\n",
    "\"\"\"\n",
    "\n",
    "# Define uma função chamada 'registrar_livro' que aceita três parâmetros: titulo, autor e ano\n",
    "def registrar_livro(titulo, autor, ano):\n",
    "    \n",
    "    # Documentação da função que descreve sua finalidade\n",
    "    \"\"\"Cria e retorna um dicionário representando um livro.\"\"\"\n",
    "    \n",
    "    # Retorna um dicionário com as informações do livro\n",
    "    return {\n",
    "        'titulo': titulo,  # Chave 'titulo' com o valor do parâmetro 'titulo'\n",
    "        'autor': autor,   # Chave 'autor' com o valor do parâmetro 'autor'\n",
    "        'ano': ano        # Chave 'ano' com o valor do parâmetro 'ano'\n",
    "    }\n",
    "\n",
    "# Chama a função 'registrar_livro' com informações específicas e armazena o dicionário resultante na variável 'livro'\n",
    "livro = registrar_livro(\"1984\", \"George Orwell\", 1949)\n",
    "\n",
    "# Imprime o conteúdo do dicionário 'livro'\n",
    "print(livro)\n",
    "\n",
    "print()\n",
    "\n",
    "\"\"\"\n",
    "2. Exibição de Livro:\n",
    "\n",
    "        a) Crie uma função chamada exibir_livro que aceite um \n",
    "        dicionário (representando um livro) como seu único argumento.\n",
    "\n",
    "        b) A função deve imprimir os detalhes do livro em um formato \n",
    "        legível. Por exemplo:\n",
    "        \n",
    "        Título: 1984\n",
    "        Autor: George Orwell\n",
    "        Ano: 1949\n",
    "        \n",
    "        c) Teste sua função exibir_livro usando o dicionário que você criou \n",
    "        na etapa anterior (usando a função registrar_livro).\n",
    "\"\"\"\n",
    "\n",
    "# Define uma função chamada 'exibir_livro' que aceita um parâmetro: livro_dicionario\n",
    "def exibir_livro(livro_dicionario):\n",
    "    \n",
    "    # Documentação da função explicando sua finalidade\n",
    "    \"\"\"Recebe um dicionário de livro e exibe seus detalhes.\"\"\"\n",
    "    \n",
    "    # Imprime o valor associado à chave 'titulo' do dicionário do livro\n",
    "    print(f\"Título: {livro_dicionario['titulo']}\")\n",
    "    \n",
    "    # Imprime o valor associado à chave 'autor' do dicionário do livro\n",
    "    print(f\"Autor: {livro_dicionario['autor']}\")\n",
    "    \n",
    "    # Imprime o valor associado à chave 'ano' do dicionário do livro\n",
    "    print(f\"Ano: {livro_dicionario['ano']}\")\n",
    "\n",
    "# Chama a função 'exibir_livro', passando o dicionário 'livro' como argumento\n",
    "exibir_livro(livro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c39f20e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "520c5c74",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'978-1234567890': {'titulo': 'A Arte da Guerra', 'autor': 'Sun Tzu', 'ano_publicacao': 500}, '978-0987654321': {'titulo': '1984', 'autor': 'George Orwell', 'ano_publicacao': 1949}}\n",
      "{(1, 2, 3): 'valor'}\n",
      "Pulp Fiction\n",
      "555-1234\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Dicas e Boas Práticas\n",
    "\n",
    "        Quando e por que usar dicionários\n",
    "        Cuidados com tipos de chaves mutáveis\n",
    "        Dicionários vs. Listas: quando usar cada um\n",
    "\"\"\"\n",
    "\n",
    "#Exemplo Prático: Dicas e Boas Práticas com Dicionários\n",
    "\n",
    "#1. Quando e por que usar dicionários\n",
    "\n",
    "#Dicionários são ideais quando você tem um conjunto de chaves únicas \n",
    "#e quer associar valores a elas. Por exemplo, suponha que você esteja \n",
    "#criando um sistema para uma biblioteca e queira armazenar informações sobre \n",
    "#os livros com base no seu ISBN (uma chave única para cada livro).\n",
    "\n",
    "# Criando um dicionário chamado 'livros'. \n",
    "# As chaves são os ISBNs e os valores são outros dicionários que representam informações sobre cada livro.\n",
    "\n",
    "livros = {\n",
    "    \"978-1234567890\": {               # Chave: ISBN do livro \"A Arte da Guerra\"\n",
    "        \"titulo\": \"A Arte da Guerra\", # Chave: \"titulo\", Valor: \"A Arte da Guerra\"\n",
    "        \"autor\": \"Sun Tzu\",           # Chave: \"autor\", Valor: \"Sun Tzu\"\n",
    "        \"ano_publicacao\": 500         # Chave: \"ano_publicacao\", Valor: 500 (ano aproximado de publicação)\n",
    "    },\n",
    "    \"978-0987654321\": {               # Chave: ISBN do livro \"1984\"\n",
    "        \"titulo\": \"1984\",             # Chave: \"titulo\", Valor: \"1984\"\n",
    "        \"autor\": \"George Orwell\",     # Chave: \"autor\", Valor: \"George Orwell\"\n",
    "        \"ano_publicacao\": 1949        # Chave: \"ano_publicacao\", Valor: 1949\n",
    "    }\n",
    "}\n",
    "\n",
    "# Imprimindo o dicionário 'livros' no console\n",
    "print(livros)\n",
    "\n",
    "#2. Cuidados com tipos de chaves mutáveis\n",
    "\n",
    "#Evite usar tipos mutáveis, como listas, como chaves de dicionário. \n",
    "#Eles podem causar comportamento inesperado e erros, pois, se a lista \n",
    "#for alterada depois de ser usada como chave, ela poderá interferir no \n",
    "#mapeamento do dicionário.\n",
    "\n",
    "# Ruim\n",
    "ruim = {}\n",
    "lista_chave = [1, 2, 3]\n",
    "#ruim[lista_chave] = \"valor\"  # Isso vai lançar um TypeError\n",
    "\n",
    "\"\"\"\n",
    "Aqui, tentamos usar uma lista como chave para o dicionário ruim. Se \n",
    "você descomentar a linha #ruim[lista_chave] = \"valor\", obterá um TypeError, \n",
    "pois listas são mutáveis e não podem ser usadas como chaves de dicionário.\n",
    "\"\"\"\n",
    "\n",
    "# Bom\n",
    "bom = {}\n",
    "tupla_chave = (1, 2, 3)\n",
    "bom[tupla_chave] = \"valor\"  # Isso é perfeitamente válido\n",
    "\n",
    "print(bom)\n",
    "\n",
    "\"\"\"\n",
    "Neste exemplo, usamos uma tupla (que é um tipo imutável) como \n",
    "chave para o dicionário bom. As tuplas são \"hashable\" e podem ser \n",
    "usadas como chaves de dicionário sem problemas.\n",
    "\"\"\"\n",
    "\n",
    "#3. Dicionários vs. Listas: quando usar cada um\n",
    "\n",
    "#Use listas quando a ordem dos itens for importante e quando \n",
    "#você precisar de uma coleção ordenada de itens. Listas são ótimas \n",
    "#para sequências onde os itens são frequentemente recuperados por \n",
    "#sua posição na coleção.\n",
    "\n",
    "filmes_favoritos = [\"Pulp Fiction\", \"Cidade de Deus\", \"O Poderoso Chefão\"]\n",
    "\n",
    "# Recuperando o primeiro filme favorito\n",
    "primeiro_filme = filmes_favoritos[0]\n",
    "\n",
    "print(primeiro_filme)\n",
    "\n",
    "\n",
    "#Use dicionários quando você precisar associar valores a chaves \n",
    "#únicas e desejar uma recuperação eficiente por chave. Dicionários \n",
    "#são ideais para armazenar e recuperar dados de forma não sequencial.\n",
    "\n",
    "# Inicializando um dicionário chamado 'contatos'.\n",
    "contatos = {\n",
    "    \"Alice\": \"555-1234\",  # Adicionando uma chave \"Alice\" com valor \"555-1234\" ao dicionário.\n",
    "    \"Bob\": \"555-5678\"     # Adicionando uma chave \"Bob\" com valor \"555-5678\" ao dicionário.\n",
    "}\n",
    "\n",
    "# Recuperando o número de telefone de Alice\n",
    "telefone_alice = contatos[\"Alice\"]\n",
    "\n",
    "print(telefone_alice)\n",
    "\n",
    "\"\"\"\n",
    "Lembre-se de que a escolha entre dicionários e listas deve ser baseada na \n",
    "natureza dos dados e nas operações que você deseja realizar com eles. Se a ordem for \n",
    "importante ou se você estiver trabalhando com uma sequência, use uma lista. Se você \n",
    "precisar de mapeamentos de chave-valor rápidos, use um dicionário.\n",
    "\"\"\"\n",
    "print()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a1615ae",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "97c8c4e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "MENU:\n",
      "1. Adicionar contato\n",
      "2. Alterar contato\n",
      "3. Remover contato\n",
      "4. Listar contatos\n",
      "5. Sair\n",
      "Escolha uma opção: 1\n",
      "\n",
      "Digite o nome do contato: A\n",
      "Digite o número de telefone: 778787\n",
      "{'A': '778787'}\n",
      "\n",
      "Contato adicionado com sucesso!\n",
      "\n",
      "MENU:\n",
      "1. Adicionar contato\n",
      "2. Alterar contato\n",
      "3. Remover contato\n",
      "4. Listar contatos\n",
      "5. Sair\n",
      "Escolha uma opção: 1\n",
      "\n",
      "Digite o nome do contato: Bia\n",
      "Digite o número de telefone: 78787\n",
      "{'A': '778787', 'Bia': '78787'}\n",
      "\n",
      "Contato adicionado com sucesso!\n",
      "\n",
      "MENU:\n",
      "1. Adicionar contato\n",
      "2. Alterar contato\n",
      "3. Remover contato\n",
      "4. Listar contatos\n",
      "5. Sair\n",
      "Escolha uma opção: 4\n",
      "\n",
      "Nome: A\n",
      "Telefone: 778787\n",
      "\n",
      "Nome: Bia\n",
      "Telefone: 78787\n",
      "\n",
      "MENU:\n",
      "1. Adicionar contato\n",
      "2. Alterar contato\n",
      "3. Remover contato\n",
      "4. Listar contatos\n",
      "5. Sair\n",
      "Escolha uma opção: 2\n",
      "\n",
      "Digite o nome do contato que deseja alterar: A\n",
      "Digite o novo nome para o contato (deixe em branco para manter o nome atual): Amanda\n",
      "Digite o novo número de telefone (deixe em branco para manter o atual): 5659\n",
      "\n",
      "Contato atualizado com sucesso!\n",
      "\n",
      "MENU:\n",
      "1. Adicionar contato\n",
      "2. Alterar contato\n",
      "3. Remover contato\n",
      "4. Listar contatos\n",
      "5. Sair\n",
      "Escolha uma opção: 4\n",
      "\n",
      "Nome: Bia\n",
      "Telefone: 78787\n",
      "\n",
      "Nome: Amanda\n",
      "Telefone: 5659\n",
      "\n",
      "MENU:\n",
      "1. Adicionar contato\n",
      "2. Alterar contato\n",
      "3. Remover contato\n",
      "4. Listar contatos\n",
      "5. Sair\n",
      "Escolha uma opção: 3\n",
      "\n",
      "Digite o nome do contato que deseja remover: Bia\n",
      "\n",
      "Contato removido com sucesso!\n",
      "\n",
      "MENU:\n",
      "1. Adicionar contato\n",
      "2. Alterar contato\n",
      "3. Remover contato\n",
      "4. Listar contatos\n",
      "5. Sair\n",
      "Escolha uma opção: 9\n",
      "\n",
      "Opção inválida!\n",
      "\n",
      "MENU:\n",
      "1. Adicionar contato\n",
      "2. Alterar contato\n",
      "3. Remover contato\n",
      "4. Listar contatos\n",
      "5. Sair\n",
      "Escolha uma opção: 5\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Agenda Telefônica Simplificada\n",
    "\n",
    "Objetivo: Criar um programa para gerenciar uma lista de contatos \n",
    "utilizando dicionários em Python.\n",
    "\n",
    "Descrição:\n",
    "\n",
    "Desenvolva uma aplicação de agenda telefônica que permita ao usuário:\n",
    "\n",
    "    1. Adicionar contato\n",
    "    2. Alterar contato\n",
    "    3. Remover contato\n",
    "    4. Listar contatos\n",
    "    5. Sair\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "def mostrar_menu():\n",
    "    \n",
    "    print(\"\\nMENU:\")\n",
    "    print(\"1. Adicionar contato\")\n",
    "    print(\"2. Alterar contato\")\n",
    "    print(\"3. Remover contato\")\n",
    "    print(\"4. Listar contatos\")\n",
    "    print(\"5. Sair\")\n",
    "\n",
    "# Função para adicionar um novo contato ao dicionário de contatos.\n",
    "def adicionar_contato(contatos):\n",
    "    \n",
    "    # Obtém o nome do contato.\n",
    "    nome = input(\"\\nDigite o nome do contato: \")\n",
    "    \n",
    "    # Obtém o número de telefone.\n",
    "    telefone = input(\"Digite o número de telefone: \")\n",
    "    \n",
    "    # Adiciona/Atualiza o contato no dicionário.\n",
    "    contatos[nome] = telefone\n",
    "    print(contatos)\n",
    "    print(\"\\nContato adicionado com sucesso!\")\n",
    "    \n",
    "# Função para alterar um contato existente.\n",
    "def alterar_contato(contatos):\n",
    "    \n",
    "    # Obtém o nome do contato a ser alterado.\n",
    "    nome_atual = input(\"\\nDigite o nome do contato que deseja alterar: \")\n",
    "\n",
    "    # Verifica se o contato existe.\n",
    "    if nome_atual in contatos:\n",
    "        \n",
    "        # Solicita as novas informações ao usuário.\n",
    "        novo_nome = input(\"Digite o novo nome para o contato (deixe em branco para manter o nome atual): \")\n",
    "        novo_telefone = input(\"Digite o novo número de telefone (deixe em branco para manter o atual): \")\n",
    "        \n",
    "        # Altera o nome, se fornecido.\n",
    "        if novo_nome:\n",
    "            \n",
    "            # Verifica se o novo nome já está em uso.\n",
    "            if novo_nome in contatos:\n",
    "                \n",
    "                print(\"\\nO nome informado já está em uso. Por favor, tente um nome diferente.\")\n",
    "                \n",
    "                return\n",
    "            \n",
    "            # Adiciona o novo nome com os dados antigos.\n",
    "            contatos[novo_nome] = contatos[nome_atual]\n",
    "            \n",
    "            # Remove o nome antigo.\n",
    "            del contatos[nome_atual]\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            # Mantém o nome original, se nenhum novo nome for fornecido.\n",
    "            novo_nome = nome_atual\n",
    "        \n",
    "        # Altera o telefone, se fornecido pelo usuário.\n",
    "        if novo_telefone:\n",
    "            \n",
    "            # Atualiza o telefone do contato no dicionário.\n",
    "            contatos[novo_nome] = novo_telefone\n",
    "\n",
    "        \n",
    "        print(\"\\nContato atualizado com sucesso!\")\n",
    "        \n",
    "    else:\n",
    "        \n",
    "        print(\"\\nContato não encontrado!\")\n",
    "        \n",
    "# Função para remover um contato do dicionário.\n",
    "def remover_contato(contatos):\n",
    "    \n",
    "    # Obtém o nome do contato a ser removido.\n",
    "    nome = input(\"\\nDigite o nome do contato que deseja remover: \")\n",
    "\n",
    "    # Verifica se o contato existe e o remove.\n",
    "    if nome in contatos:\n",
    "        \n",
    "        del contatos[nome]\n",
    "        \n",
    "        print(\"\\nContato removido com sucesso!\")\n",
    "        \n",
    "    else:\n",
    "        \n",
    "        print(\"\\nContato não encontrado!\")\n",
    "\n",
    "    \n",
    "# Função para listar todos os contatos no dicionário.\n",
    "def listar_contatos(contatos):\n",
    "    \n",
    "    # Verifica se há contatos no dicionário.\n",
    "    if not contatos:\n",
    "        \n",
    "        print(\"\\nNenhum contato registrado!\")\n",
    "        \n",
    "    # Itera e exibe todos os contatos.\n",
    "    for nome, telefone in contatos.items():\n",
    "        \n",
    "        print(f\"\\nNome: {nome}\")\n",
    "        print(f\"Telefone: {telefone}\")\n",
    "\n",
    "    \n",
    "# Função principal para executar o programa.\n",
    "def main():\n",
    "    \n",
    "    # Inicializa um dicionário vazio para contatos.\n",
    "    contatos = {}\n",
    "    \n",
    "    # Loop infinito para a interação do usuário.\n",
    "    while True:\n",
    "        \n",
    "        # Exibe o menu.\n",
    "        mostrar_menu()\n",
    "        \n",
    "        # Obtém a escolha do usuário.\n",
    "        escolha = input(\"Escolha uma opção: \")\n",
    "\n",
    "        # Condicional para direcionar a ação com base na opção escolhida pelo usuário.\n",
    "        \n",
    "        # Se o usuário escolher a opção 1:\n",
    "        if escolha == \"1\":\n",
    "            \n",
    "            # Chama a função para adicionar um novo contato.\n",
    "            adicionar_contato(contatos)\n",
    "        \n",
    "        # Se o usuário escolher a opção 2:\n",
    "        elif escolha == \"2\":\n",
    "            \n",
    "            # Chama a função para alterar um contato existente.\n",
    "            alterar_contato(contatos)\n",
    "        \n",
    "        # Se o usuário escolher a opção 3:\n",
    "        elif escolha == \"3\":\n",
    "            \n",
    "            # Chama a função para remover um contato.\n",
    "            remover_contato(contatos)\n",
    "        \n",
    "        # Se o usuário escolher a opção 4:\n",
    "        elif escolha == \"4\":\n",
    "            \n",
    "            # Chama a função para listar todos os contatos.\n",
    "            listar_contatos(contatos)\n",
    "        \n",
    "        # Se o usuário escolher a opção 5:\n",
    "        elif escolha == \"5\":\n",
    "            \n",
    "            # Encerra o loop e, consequentemente, o programa.\n",
    "            break  \n",
    "        \n",
    "        # Se o usuário escolher uma opção que não está no menu:\n",
    "        else:\n",
    "            \n",
    "            # Exibe uma mensagem de erro.\n",
    "            print(\"\\nOpção inválida!\")\n",
    "\n",
    "\n",
    "# Chama a função principal para executar o programa.\n",
    "main()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc663179",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd277a42",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac6ca026",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a013294b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9885de29",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5048aa0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f184b8d9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6719df07",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef85a3e6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84a1a51a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22683b68",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}