Aula_11.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Aula 11 - Coleções Parte 3: Dicionário**\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para quem já tem experiência com programação, principalmente com a linguagem JavaScript, vai sentir essa aula familiar.\n",
    "\n",
    "Um **dicionário** no Python é um tipo de coleção similar às listas, a diferença é que agora, para cada valor do dicionário, há uma **chave** associada àquele valor. Pense em um dicionário na vida real, você tem a palavra e tem o significado dela. Funciona de forma parecida. Assim, você encontra um valor pelo elemento correspondente — diferentemente de encontrar por um índice como em uma lista. O dicionário é uma forma de organização similar a um de banco de dados, mais completa e abrangente para diversas situações. Um dicionário grande e bem estruturado lembra muito um dataset, com os dados em um formato matricial, de tabela. Isso facilita o controle e o mapeamento desses dados. Uma forma fácil de visualizar um dicionário é uma lista telefônica. Nesse caso, as chaves são os nomes, elementos que demarcam a individualidade; ao passo que os números são os valores, elementos identificadores.\n",
    "\n",
    "Para os programadores Front-End vai ficar mais fácil de explicar, já que no JavaScript há uma estrutura quase idêntica: o ***JavaScript Object Notation*** **(Objeto de Notação JavaScript)**, também conhecido como **JSON**. A estrutura é praticamente idêntica, funcionando quase como que um \"JSON do Python\" mesmo. Enquanto nas listas são usados os colchetes (`[]`) e nas tuplas os parênteses (`()`), nos dicionários são usados as chaves (`{}`). Veja abaixo:\n",
    "\n",
    "- `lista = ['Fulano', 'Cicrano', 'Beltrano']` é uma lista.\n",
    "- `tupla = ('Fulano', 'Cicrano', 'Beltrano')` é uma tupla.\n",
    "- `dicionario = {'nome':'Fulano', 'idade':40, 'profissao':'Programador'}` é um dicionário.\n",
    "\n",
    "Segue abaixo um exemplo de código-fonte utilizando dicionário:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nome': 'Alex Machado', 'idade': 39, 'profissao': 'programador', 'empresa': 'SENAI'}\n"
     ]
    }
   ],
   "source": [
    "# dicionário\n",
    "pessoa = {\n",
    "    'nome':'Alex Machado',\n",
    "    'idade':39,\n",
    "    'profissao':'programador',\n",
    "    'empresa':'SENAI'\n",
    "}\n",
    "\n",
    "print(pessoa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diferenciando os tipos de coleções\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim como os tipos de variáveis, você pode exibir qual tipo de lista você está lidando através do comando `type()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'tuple'>\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "# coleções\n",
    "colecao1 = ['Fulano','Cicrano','Beltrano']\n",
    "colecao2 = ('Brasília','São Paulo','Rio de Janeiro')\n",
    "colecao3 = {'Nome':'Fulano de Tal', 'Profissao':'Programador', 'Genero':'Masculino'}\n",
    "\n",
    "# verificando os tipos de coleções\n",
    "print(type(colecao1))\n",
    "print(type(colecao2))\n",
    "print(type(colecao3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Acessando os dados do dicionário\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É claro que também posso acessar as chaves do dicionário de forma isolada, assim como nas listas, tuplas, e também no JSON (para quem veio do JS). No Python, há duas formas de se fazer isso:\n",
    "\n",
    "### Forma 1\n",
    "\n",
    "Chamando o dicionário como se fosse uma lista, mas colocando o nome da chave dentro dos colchetes ao invés do índice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alex Machado\n",
      "39\n",
      "programador\n",
      "SENAI\n"
     ]
    }
   ],
   "source": [
    "pessoa = {\n",
    "    'nome':'Alex Machado',\n",
    "    'idade':39,\n",
    "    'profissao':'programador',\n",
    "    'empresa':'SENAI'\n",
    "}\n",
    "\n",
    "# exibindo os dados do dicionário\n",
    "print(pessoa['nome'])\n",
    "print(pessoa['idade'])\n",
    "print(pessoa['profissao'])\n",
    "print(pessoa['empresa'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este método é bastante simples e fácil de ser implementado. Porém, ele tem uma desvantagem: se a chave informada não existir, então o código retornará um erro, e não irá executar o código. Para evitar o erro usando essa forma de acesso, será necessário usar o `try...except`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dados inexistentes\n"
     ]
    }
   ],
   "source": [
    "pessoa = {\n",
    "    'nome':'Alex Machado',\n",
    "    'idade':39,\n",
    "    'profissao':'programador',\n",
    "    'empresa':'SENAI'\n",
    "}\n",
    "\n",
    "try:\n",
    "    print(pessoa['cidade'])\n",
    "except:\n",
    "    print('Dados inexistentes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Forma 2\n",
    "\n",
    "Há, porém, uma forma de evitar isso. É possível usar a função `get()` em conjunto com o nome do dicionário para o mesmo fim. Este método tem a vantagem de que, caso a chave não exista, ele não irá retornar um erro, mas sim `none`. De qualquer forma, o código será executado normalmente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alex Machado\n",
      "39\n",
      "programador\n",
      "SENAI\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "pessoa = {\n",
    "    'nome':'Alex Machado',\n",
    "    'idade':39,\n",
    "    'profissao':'programador',\n",
    "    'empresa':'SENAI'\n",
    "}\n",
    "\n",
    "print(pessoa.get('nome'))\n",
    "print(pessoa.get('idade'))\n",
    "print(pessoa.get('profissao'))\n",
    "print(pessoa.get('empresa'))\n",
    "print(pessoa.get('cidade'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Forma 3\n",
    "\n",
    "É possível percorrer o dicionário como uma lista através de um laço de repetição, como o laço ***for***, por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nome: Alex Machado\n",
      "Idade: 39\n",
      "Profissão: Programador\n",
      "Empresa: SENAI\n"
     ]
    }
   ],
   "source": [
    "pessoa = {\n",
    "    'Nome':'Alex Machado',\n",
    "    'Idade':39,\n",
    "    'Profissão':'Programador',\n",
    "    'Empresa':'SENAI'\n",
    "}\n",
    "\n",
    "# laço\n",
    "for chave in pessoa:\n",
    "    print(f'{chave}: {pessoa.get(chave)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Forma 4\n",
    "\n",
    "Você pode também, caso deseje, criar uma **tupla** com o nome das chaves  desejadas. Assim, você protege o dicionário contra alterações das chaves, caso precise, além de poder exibir os dados do dicionário em um laço ***for***:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nome: Alex Machado\n",
      "Idade: 39\n",
      "Profissão: Programador\n",
      "Empresa: SENAI\n"
     ]
    }
   ],
   "source": [
    "# tupla das chaves\n",
    "chaves = ('Nome', 'Idade', 'Profissão', 'Empresa')\n",
    "\n",
    "# dicionário\n",
    "pessoa = {\n",
    "    chaves[0]:'Alex Machado',\n",
    "    chaves[1]:39,\n",
    "    chaves[2]:'Programador',\n",
    "    chaves[3]:'SENAI'\n",
    "}\n",
    "\n",
    "for chave in chaves:\n",
    "    print(f'{chave}: {pessoa.get(chave)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adicionando uma nova chave ao dicionário\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja que tentamos acessar uma chave que não existe no nosso dicionário. Pelo menos não ainda, porque podemos adicioná-la. O processo é bastante simples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alex Machado\n",
      "39\n",
      "programador\n",
      "SENAI\n",
      "Brasília\n"
     ]
    }
   ],
   "source": [
    "pessoa = {\n",
    "    'nome':'Alex Machado',\n",
    "    'idade':39,\n",
    "    'profissao':'programador',\n",
    "    'empresa':'SENAI'\n",
    "}\n",
    "\n",
    "# adicionando uma nova chave ao dicionário\n",
    "pessoa['cidade'] = 'Brasília'\n",
    "\n",
    "# exibindo os dados do dicionário\n",
    "print(pessoa.get('nome'))\n",
    "print(pessoa.get('idade'))\n",
    "print(pessoa.get('profissao'))\n",
    "print(pessoa.get('empresa'))\n",
    "print(pessoa.get('cidade'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos adicionar um novo valor através do `input()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alex Machado\n",
      "39\n",
      "programador\n",
      "SENAI\n",
      "Taguatinga\n"
     ]
    }
   ],
   "source": [
    "pessoa = {\n",
    "    'nome':'Alex Machado',\n",
    "    'idade':39,\n",
    "    'profissao':'programador',\n",
    "    'empresa':'SENAI'\n",
    "}\n",
    "\n",
    "# adicionando uma nova chave ao dicionário\n",
    "pessoa['cidade'] = input('Informe o nome da cidade: ')\n",
    "\n",
    "# exibindo os dados do dicionário\n",
    "print(pessoa.get('nome'))\n",
    "print(pessoa.get('idade'))\n",
    "print(pessoa.get('profissao'))\n",
    "print(pessoa.get('empresa'))\n",
    "print(pessoa.get('cidade'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Removendo uma chave do dicionário\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além de podermos adicionar nova chave, o contrário também acontece. Podemos remover uma chave, caso ela exista dentro do dicionário:\n",
    "\n",
    "### Forma 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nome': 'Alex Machado', 'idade': 39, 'profissao': 'programador'}\n"
     ]
    }
   ],
   "source": [
    "pessoa = {\n",
    "    'nome':'Alex Machado',\n",
    "    'idade':39,\n",
    "    'profissao':'programador',\n",
    "    'empresa':'SENAI'\n",
    "}\n",
    "\n",
    "pessoa.pop(input('Informe a chave que deseja excluir: '), None)\n",
    "\n",
    "# exibe os novos dados na tela\n",
    "print(pessoa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Obs:** o `None` serve para o programa não retornar um erro, caso o usuário informe uma chave inexistente, e para esse caso, é uma opção que substitui de forma mais satisfatória o `try...except`.\n",
    "\n",
    "### Forma 2\n",
    "\n",
    "Podemos usar também o comando `del`, que tem também a vantagem de não precisarmos fazer um tratamento de exceções caso a chave informada não exista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nome': 'Alex Machado', 'idade': 39, 'empresa': 'SENAI'}\n"
     ]
    }
   ],
   "source": [
    "pessoa = {\n",
    "    'nome':'Alex Machado',\n",
    "    'idade':39,\n",
    "    'profissao':'programador',\n",
    "    'empresa':'SENAI'\n",
    "}\n",
    "\n",
    "del pessoa[input('Informe a chave que deseja excluir: ')]\n",
    "\n",
    "# exibe os novos dados na tela\n",
    "print(pessoa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lista de dicionários\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É possível também montar uma lista de dicionários. Dessa forma, é possível montar um mini-banco de dados não-relacional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'nome': 'Fulano', 'idade': 20, 'profissao': 'programador'}, {'nome': 'Cicrano', 'idade': 25, 'profissao': 'cientista'}, {'nome': 'Beltrano', 'idade': 30, 'profissao': 'gerente de projetos'}]\n"
     ]
    }
   ],
   "source": [
    "# lista de dicionários\n",
    "pessoas = [\n",
    "    {\n",
    "        'nome':'Fulano',\n",
    "        'idade':20,\n",
    "        'profissao':'programador'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Cicrano',\n",
    "        'idade':25,\n",
    "        'profissao':'cientista'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Beltrano',\n",
    "        'idade':30,\n",
    "        'profissao':'gerente de projetos'\n",
    "    }\n",
    "]\n",
    "\n",
    "# imprimindo a lista\n",
    "print(pessoas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exibindo os dados de apenas uma das chaves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fulano\n",
      "Cicrano\n",
      "Beltrano\n"
     ]
    }
   ],
   "source": [
    "pessoas = [\n",
    "    {\n",
    "        'nome':'Fulano',\n",
    "        'idade':20,\n",
    "        'profissao':'programador'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Cicrano',\n",
    "        'idade':25,\n",
    "        'profissao':'cientista'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Beltrano',\n",
    "        'idade':30,\n",
    "        'profissao':'gerente de projetos'\n",
    "    }\n",
    "]\n",
    "\n",
    "# listando apenas os nomes\n",
    "for pessoa in pessoas:\n",
    "    print(pessoa['nome'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exibindo todos os dados de todos da lista de forma organizada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Índice: 1:\n",
      "Nome: Fulano\n",
      "Idade: 20\n",
      "Profissão: programador\n",
      "\n",
      "Índice: 2:\n",
      "Nome: Cicrano\n",
      "Idade: 25\n",
      "Profissão: cientista\n",
      "\n",
      "Índice: 3:\n",
      "Nome: Beltrano\n",
      "Idade: 30\n",
      "Profissão: gerente de projetos\n",
      "\n"
     ]
    }
   ],
   "source": [
    "pessoas = [\n",
    "    {\n",
    "        'nome':'Fulano',\n",
    "        'idade':20,\n",
    "        'profissao':'programador'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Cicrano',\n",
    "        'idade':25,\n",
    "        'profissao':'cientista'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Beltrano',\n",
    "        'idade':30,\n",
    "        'profissao':'gerente de projetos'\n",
    "    }\n",
    "]\n",
    "\n",
    "# listando como um banco de dados\n",
    "for i in range(len(pessoas)):\n",
    "    print(f'Índice: {i + 1}:')\n",
    "    print(f'Nome: {pessoas[i]['nome']}')\n",
    "    print(f'Idade: {pessoas[i]['idade']}')\n",
    "    print(f'Profissão: {pessoas[i]['profissao']}\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pesquisando por um dicionário dentro de uma lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Índice: 1\n",
      "Nome: Fulano\n",
      "Idade: 20\n",
      "Profissão: programador\n"
     ]
    }
   ],
   "source": [
    "pessoas = [\n",
    "    {\n",
    "        'nome':'Fulano',\n",
    "        'idade':20,\n",
    "        'profissao':'programador'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Cicrano',\n",
    "        'idade':25,\n",
    "        'profissao':'cientista'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Beltrano',\n",
    "        'idade':30,\n",
    "        'profissao':'gerente de projetos'\n",
    "    }\n",
    "]\n",
    "\n",
    "# usuário informa o nome que deseja procurar\n",
    "nome = input('Informe o nome que deseja procurar: ')\n",
    "\n",
    "# programa retorna o resultado\n",
    "for i in range(len(pessoas)):\n",
    "    if nome in pessoas[i]['nome']:\n",
    "        print(f'Índice: {i + 1}')\n",
    "        print(f'Nome: {pessoas[i]['nome']}')\n",
    "        print(f'Idade: {pessoas[i]['idade']}')\n",
    "        print(f'Profissão: {pessoas[i]['profissao']}')\n",
    "    else:\n",
    "        continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alterando dados de um dicionário dentro de uma lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Novos dados do índice 1:\n",
      "\n",
      "Nome: Fulano\n",
      "Idade: 20\n",
      "Profissão: atendente\n"
     ]
    }
   ],
   "source": [
    "pessoas = [\n",
    "    {\n",
    "        'nome':'Fulano',\n",
    "        'idade':20,\n",
    "        'profissao':'programador'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Cicrano',\n",
    "        'idade':25,\n",
    "        'profissao':'cientista'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Beltrano',\n",
    "        'idade':30,\n",
    "        'profissao':'gerente de projetos'\n",
    "    }\n",
    "]\n",
    "\n",
    "indice = int(input('Informe o índice a ser alterado: '))\n",
    "campo = input('Informe o nome do campo a ser alterado: ')\n",
    "\n",
    "indice -= 1\n",
    "\n",
    "# usuário altera o dado do campo desejado\n",
    "try:\n",
    "    pessoas[indice][campo] = input(f'Informe o novo valor do campo {campo}: ')\n",
    "except:\n",
    "    print('Não foi possível alterar.')\n",
    "\n",
    "# novos dados são exibidos na lista\n",
    "print(f'Novos dados do índice {indice + 1}:\\n')\n",
    "print(f'Nome: {pessoas[indice]['nome']}')\n",
    "print(f'Idade: {pessoas[indice]['idade']}')\n",
    "print(f'Profissão: {pessoas[indice]['profissao']}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inserindo um novo dicionário da lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Índice: 1:\n",
      "Nome: Fulano\n",
      "Idade: 20\n",
      "Profissão: programador\n",
      "\n",
      "Índice: 2:\n",
      "Nome: Cicrano\n",
      "Idade: 25\n",
      "Profissão: cientista\n",
      "\n",
      "Índice: 3:\n",
      "Nome: Beltrano\n",
      "Idade: 30\n",
      "Profissão: gerente de projetos\n",
      "\n",
      "Índice: 4:\n",
      "Nome: Alex\n",
      "Idade: 39\n",
      "Profissão: programador\n",
      "\n"
     ]
    }
   ],
   "source": [
    "pessoas = [\n",
    "    {\n",
    "        'nome':'Fulano',\n",
    "        'idade':20,\n",
    "        'profissao':'programador'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Cicrano',\n",
    "        'idade':25,\n",
    "        'profissao':'cientista'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Beltrano',\n",
    "        'idade':30,\n",
    "        'profissao':'gerente de projetos'\n",
    "    }\n",
    "]\n",
    "\n",
    "# usuário informa os dados a serem inseridos\n",
    "pessoa['nome'] = input('Informe o nome: ')\n",
    "pessoa['idade'] = int(input('Informe a idade: '))\n",
    "pessoa['profissao'] = input('Informe a profissão: ')\n",
    "\n",
    "# novos dados são inseridos\n",
    "pessoas.append(pessoa)\n",
    "\n",
    "# novos dados exibidos na lista\n",
    "for i in range(len(pessoas)):\n",
    "    print(f'Índice: {i + 1}:')\n",
    "    print(f'Nome: {pessoas[i]['nome']}')\n",
    "    print(f'Idade: {pessoas[i]['idade']}')\n",
    "    print(f'Profissão: {pessoas[i]['profissao']}\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deletando um dicionário da lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Índice: 1:\n",
      "Nome: Cicrano\n",
      "Idade: 25\n",
      "Profissão: cientista\n",
      "\n",
      "Índice: 2:\n",
      "Nome: Beltrano\n",
      "Idade: 30\n",
      "Profissão: gerente de projetos\n",
      "\n"
     ]
    }
   ],
   "source": [
    "pessoas = [\n",
    "    {\n",
    "        'nome':'Fulano',\n",
    "        'idade':20,\n",
    "        'profissao':'programador'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Cicrano',\n",
    "        'idade':25,\n",
    "        'profissao':'cientista'\n",
    "    },\n",
    "    {\n",
    "        'nome':'Beltrano',\n",
    "        'idade':30,\n",
    "        'profissao':'gerente de projetos'\n",
    "    }\n",
    "]\n",
    "\n",
    "# usuário informa o índice a ser excluído\n",
    "indice = int(input('Informe o índice que deseja deletar da lista de dicionários: '))\n",
    "\n",
    "indice -= 1\n",
    "\n",
    "# índice é deletado\n",
    "try:\n",
    "    del[pessoas[indice]]\n",
    "except:\n",
    "    print('Não foi possível deletar o índice.')\n",
    "\n",
    "# nova lista é exibida\n",
    "for i in range(len(pessoas)):\n",
    "    print(f'Índice: {i + 1}:')\n",
    "    print(f'Nome: {pessoas[i]['nome']}')\n",
    "    print(f'Idade: {pessoas[i]['idade']}')\n",
    "    print(f'Profissão: {pessoas[i]['profissao']}\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercícios\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Em programação, chamamos de sistema ***CRUD*** um sistema que faça 4 operações: ***C***_reate_, ***R***_ead_, ***U***_pdate_ e ***D***_elete_, que significam, respectivamente: cadastrar, pesquisar, atualizar e excluir. Crie um ***CRUD***, ou seja, um sistema que faça essas 4 operações em uma lista de dicionário."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}