8- App_Phonebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesse seção vamos programar um phonebook. Um aplicativo simples para gravar e buscar os contatos telefonicos. Para fazer isso, o Python fornece uma estrutura de armazenar dados que se chama `Dictionary` (dicionario). Alem disso para salvar o phonebook na memoria do computador a gente precisa sobre a forma que vamos salvar esse banco de dados. Eu sugiro o formato `json` que recentemente está ficando muito popular. Vamos começar com um modelo bem simples e aos poucos melhoramos o nosso App.<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `Dictionary`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um dicionario é um formato mais completo em relação a lista (`List`). Cada elemento de um dicionario tem duas parte, uma chave (`key`) e um valor (`value`), ou seja\n",
    "\n",
    "```pythn\n",
    "d= {'sophia' : 5}\n",
    "```\n",
    "Neste exemplo, o termo `sophia` é a chave e `5` é o valor. Então cada elemento de um dicionario não tem indice como a lista, tem uma chave. Agora, para acessar um valor usamos a seguinte syntax:\n",
    "\n",
    "```python\n",
    "\n",
    "d['sophia']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'sophia':5 , 'yasmin':0}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora como podemos adiocionar um elemento novo nesse decionario? Tem duas formas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['heitor'] = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'sophia': 5, 'yasmin': 0, 'heitor': 5}"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.update({'yuri':7})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'sophia': 5, 'yasmin': 0, 'heitor': 5, 'yuri': 7}"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acessar o valor de uma chave temos duas opções"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.get('yuri')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['yuri']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ver as chaves do dicionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['sophia', 'yasmin', 'heitor', 'yuri'])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O rsultado acima não é uma lista e por isso não conseguimos accesar as chaves um por um"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'dict_keys' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-8ea809e8b798>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0md\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'dict_keys' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "d.keys()[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas podemos transormar o resultado em uma lista facilmente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['sophia', 'yasmin', 'heitor', 'yuri']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(d.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ver os valores do dictionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([5, 0, 5, 7])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ver os itens dentro de um dicionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('sophia', 5), ('yasmin', 0), ('heitor', 5), ('yuri', 7)])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos fazer iteração em um dictionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sophia 5\n",
      "yasmin 0\n",
      "heitor 5\n",
      "yuri 7\n"
     ]
    }
   ],
   "source": [
    "for key,value in d.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para eliminar um elemento desse dicionario faremos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "del d['yuri']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'sophia': 5, 'yasmin': 0, 'heitor': 5}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `JSON`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Não é de surpreender que a **J**ava**S**cript **O**bject **N**otation tenha sido inspirada em um subconjunto da linguagem de programação JavaScript que lida com a sintaxe literal do objeto. Eles têm um site bacana que explica tudo. No entanto, não se preocupe: o JSON há muito se tornou independente da linguagem e existe como seu próprio padrão, para podermos evitar o JavaScript com prazer nesta discussão.\n",
    "\n",
    "Por fim, a comunidade em geral adotou o JSON porque é fácil para humanos e máquinas criar e entender. O formato de `json` é muito parecido com dicionario. Para mexer com esse formato dentro de Python tem um pacote no mesmo nome, `json`.\n",
    "\n",
    "```json\n",
    "{\n",
    "    \"firstName\": \"Jane\",\n",
    "    \"lastName\": \"Doe\",\n",
    "    \"hobbies\": [\"running\", \"sky diving\", \"singing\"],\n",
    "    \"age\": 35,\n",
    "    \"children\": [\n",
    "        {\n",
    "            \"firstName\": \"Alice\",\n",
    "            \"age\": 6\n",
    "        },\n",
    "        {\n",
    "            \"firstName\": \"Bob\",\n",
    "            \"age\": 8\n",
    "        }\n",
    "    ]\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos criar um arquivo de `json`, é facil. Na verdade a gente tenta para abrir um arquivo de `json` para modificar e se esse arquivo não existir o Python vai criar um vazio. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "d = {'sophia':5 , 'yasmin':0, 'heitor': 5}\n",
    "\n",
    "file = open('./data/test.json', 'w+')\n",
    "json.dump(d, file)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ver o que aconteceu com calma:\n",
    "- `import json`: chama o pacote `json` para a gente puder mexer nos arquivos no formato de `json`\n",
    "- `file = open('test.json', 'w+')`: abre o arquivo \"test.json\", o arqumento `w+` significa que o Python vai abrir para modificar (write) e se não existir um arquivo com esse nome vai criar um. Outras possibilidades são `w` (so para abrir sem criação) e `r` só para ler (read) sem puder modificar. \n",
    "- `json.dump(d, file)`: aqui a gente insere o dicionario `d` dentro do arquivo de `json` já aberto. \n",
    "- `file.close()`: fechamos o arquivo e desocupamos a memoria. <br>\n",
    "\n",
    "\n",
    "agora como podemos ler o conteudo deste arquivo?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'sophia': 5, 'yasmin': 0, 'heitor': 5}\n"
     ]
    }
   ],
   "source": [
    "file = open('./data/test.json', 'r')\n",
    "d_new = json.load(file)\n",
    "print(d_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para facilitar a vida e não se preocupar com a memoria podemos reescrever o codigo acima na seguinte forma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'sophia': 5, 'yasmin': 0, 'heitor': 5}\n"
     ]
    }
   ],
   "source": [
    "with open('./data/test.json', 'r') as file:\n",
    "    d_new = json.load(file)\n",
    "    \n",
    "\n",
    "print(d_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O phonebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O nosso phonebook tem umas funções, uma par buscar no banco de dados (`buscar`) e outra para inserir um contato no banco de dados (`inserir`). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "para inserir digita \"i\", para buscar \"b\", para sair \"s\" s\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "import pathlib\n",
    "\n",
    "\n",
    "def inserir():\n",
    "    name = input('insere o nome: ')\n",
    "    numero = input('insere o numero: ')\n",
    "    #abrimos o arquivo .json para ler e criamos o dicionario \"dic\"\n",
    "    file = pathlib.Path('phonebook.json')\n",
    "    if file.exists():\n",
    "        with open('phonebook.json', 'r') as file:\n",
    "            dic = json.load(file)\n",
    "    else:\n",
    "        dic = {}\n",
    "                \n",
    "    #adicionamos o contato novo\n",
    "    #dic[name.lower()] = numero\n",
    "    new_contact = {name.lower(): numero}\n",
    "    dic.update(new_contact)\n",
    "    \n",
    "    #inserimos o dicionario atualizado no arquivo \"phonebook.json\" \n",
    "    with open('phonebook.json', 'w') as file:\n",
    "        json.dump(dic,file)\n",
    "    \n",
    "\n",
    "    \n",
    "def buscar():\n",
    "    name = input('insere o nome da pessoa: ')\n",
    "        #abrimos o arquivo .json para ler e criamos o dicionario \"dic\"\n",
    "    with open('phonebook.json', 'r') as file:\n",
    "        dic = json.load(file)\n",
    "        #checamos se o nome inserido existe no 'dic', se sim, vamos imprimir o seu numero\n",
    "        if name.lower() in dic:\n",
    "            print(dic[name.lower()])\n",
    "        else:\n",
    "            print('não entendi!')\n",
    "    \n",
    "\n",
    "\n",
    "while True:\n",
    "    \n",
    "    action = input('para inserir digita \"i\", para buscar \"b\", para sair \"s\" ')\n",
    "    \n",
    "    if action == \"i\":\n",
    "        inserir()\n",
    "    elif action == 'b':\n",
    "        buscar()\n",
    "    elif action == 's':\n",
    "        break\n",
    "    else:\n",
    "        print(\"Não entendi!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O codigo acima funciona mas tem dois problemas grandes, entre outros! Primeiro, se um nome já existisse no phonebook e o usuario adiciona o mesmo nome, o programa não o alerta sobre esse perigo! Assim ele vai perder o numero anterior. Segundo, seria interessante na hora de buscar um nome, se o nome não existir no phonebook, o programa pergunta para o usuario se ele deseja adicionar o nome no phonebook. Atualizamos o codigo acima para resolver esses problemas "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "\n",
    "def inserir(name = False):\n",
    "    \n",
    "    if name == False:\n",
    "        name = input('insere o nome: ')\n",
    "        \n",
    "    #antes de inserir o nome vamos checar se ele já existe no phonebook\n",
    "    while check(name):\n",
    "        \n",
    "        resposta = input('Esse contato já existe, deseja repor? \"s\" ou \"n\" ')\n",
    "        # com a resposta 'sim' vamos atualizar o numero no contato\n",
    "        if resposta == 's':\n",
    "            numero = input('insere o numero: ')\n",
    "            \n",
    "            with open('phonebook.json', 'r') as file:\n",
    "                dic = json.load(file)\n",
    "                \n",
    "            dic[name.lower()] = numero\n",
    "            \n",
    "            with open('phonebook.json', 'w') as file:\n",
    "                json.dump(dic,file)\n",
    "        # com a resposta \"não\" não fazemos nada e voltamos para o 'while' externo\n",
    "        elif resposta == 'n':\n",
    "            break\n",
    "        else:\n",
    "            print('não entendi')\n",
    "     \n",
    "    # se o nome não existir no phonebook o adicionamos.\n",
    "    if not check(name):\n",
    "        numero = input('insere o numero: ')\n",
    "        with open('phonebook.json', 'r+') as file:\n",
    "            dic = json.load(file)\n",
    "                \n",
    "        dic[name.lower()] = numero\n",
    "            \n",
    "        with open('phonebook.json', 'w+') as file:\n",
    "            json.dump(dic,file)\n",
    "        \n",
    "        \n",
    "        \n",
    "def check(nome):      \n",
    "    #essa função checa se o nome inserido já existe no phonebook\n",
    "    with open('phonebook.json', 'r') as file:\n",
    "        d = json.load(file)\n",
    "    if nome in d:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "  \n",
    "    \n",
    "def buscar():\n",
    "    name = input('insere o nome da pessoa: ')\n",
    "    with open('phonebook.json') as file:\n",
    "        dic = json.load(file)\n",
    "        if name.lower() in dic:\n",
    "            print(dic[name.lower()])\n",
    "        else:\n",
    "            oque = input('Esse contato não existe, deseja inserir? \"s\" ou \"n\"')\n",
    "            if oque == 's':\n",
    "                inserir(name)\n",
    "            elif oque == 'n':\n",
    "                pass\n",
    "            else:\n",
    "                print('não entendi!')\n",
    "    \n",
    "\n",
    "\n",
    "while True:\n",
    "    \n",
    "    action = input('para inserir digita \"i\", para buscar \"b\", para sair \"s\" ')\n",
    "    \n",
    "    if action == \"i\":\n",
    "        inserir()\n",
    "    elif action == 'b':\n",
    "        buscar()\n",
    "    elif action == 's':\n",
    "        break\n",
    "    else:\n",
    "        print(\"Não entendi!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**EXERCICIO:** construa uma interface grafica para esse phonebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}