1. Jupyter Básico/1.1.Importacao.Dados.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Importar Bibliotecas \n",
    "\n",
    "import pandas as pd\n",
    "pd.set_option('display.max_columns', 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importando Dados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que já conhecemos um pouco sobre as principais estruturas do Pandas (*Series e Dataframes*), agora é a vez de aprender a como **importar dados** para tais estruturas.\n",
    "\n",
    "> Embora a criação de estruturas de dados de forma manual seja útil para determinadas aplicações ou até mesmo para rápidos testes e validações, na prática, a nossa fonte de 🎲🎲 normalmente será via enormes arquivos!\n",
    "\n",
    "Em ciência de dados, muitos projetos obrigam seus cientistas a reunir uma miscelânea de padrões de fontes de dados, tais como **CSV**, **TSV**, **XLS**, **JSON**, ou outro formato. Assim, é crucial saber lidar com os principais formatos de dados em Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arquivos Texto - CSV\n",
    "\n",
    "Um dos formatos **mais utilizados** é o CSV, que nada mais são que arquivos de texto **separados por vírgulas**. A figura abaixo mostra um arquivo CSV.\n",
    "\n",
    "![Exemplo de Arquivo CSV](./img/CSV.png)\n",
    "\n",
    "> **Como importar importar arquivos CSV utilizando o pandas?** 🤔\n",
    "\n",
    "Simples! Basta segui os comandos abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "spotify_Charts_df = pd.read_csv('./datasets/spotify_charts_complete.csv', sep=',')\n",
    "spotify_Charts_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "\n",
    "⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Erro na Linha 46: ❌\n",
    "\n",
    "\n",
    "Note que nós temos **seis** colunas do arquivo de entrada: \n",
    "- chart_week\n",
    "- position\n",
    "- track_name\n",
    "- artist\n",
    "- streams\n",
    "- song_id\n",
    "\n",
    "> **Como o Pandas está enxergando a linha: 46** 🔎\n",
    "\n",
    " _2020-01-02$\\color{#ff0000}{,}$45$\\color{#ff0000}{,}$10$\\color{#ff0000}{,}$**000 Hours (with Justin Bieber)**$\\color{#ff0000}{,}$Dan + Shay$\\color{#ff0000}{,}$10360035$\\color{#ff0000}{,}$2wrJq5XKLnmhRXHIAf9xBa_\n",
    "\n",
    "> **Como o Pandas deveria enxergar:** 👀\n",
    "\n",
    " _2020-01-02$\\color{#ff0000}{,}$45$\\color{#ff0000}{,}$**10,000 Hours (with Justin Bieber)**$\\color{#ff0000}{,}$Dan + Shay$\\color{#ff0000}{,}$10360035$\\color{#ff0000}{,}$2wrJq5XKLnmhRXHIAf9xBa_\n",
    " \n",
    "Erro de **tokenização** é um problema muito comum quando lidamos com arquivos CSV. \n",
    "\n",
    "> **Como resolver esse problema?** 🤔\n",
    "\n",
    "Neste caso, para que esse tipo de erro seja evitado, teríamos que **escapar todas as Strings usando aspas (')**. Desta forma, todas as vírgulas de campos textuais não serão consideradas como separador de campo. Ou seja, todas as linhas do arquivo deveriam se parecer com:\n",
    "\n",
    "_'2020-01-02',45,**'10,000 Hours (with Justin Bieber)'**,**'Dan + Shay'**,10360035,2wrJq5XKLnmhRXHIAf9xBa_\n",
    "\n",
    "> Embora não seja necessário, é comum que todos os campos de arquivos CSVs sejam escapados por aspas, não se limitando apenas aos campos textuais! 🤓"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Leitura sem erro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spotify_Charts_df = pd.read_csv('./datasets/spotify_charts_complete_Line45.csv', sep=',')\n",
    "spotify_Charts_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arquivos Texto - TSV\n",
    "\n",
    "Uma alternativa aos arquivos CSV, são os arquivos TSV (valores separados por tabulação). Neste tipo de arquivo, como o delimitador de campo é uma **tabulação**, não deparamos com o problema de tokenização. \n",
    "\n",
    "A figura abaixo mostra um arquivo TSV.\n",
    "\n",
    "![Exemplo de Arquivo TSV](./img/TSV.png)\n",
    "\n",
    " A leitura deste tipo de arquivo é feita utilizando a mesma função **read_csv**. No entanto, precisamos especificar que o separador é a tabulação (\\t). \n",
    " \n",
    " > ⚠️ Se não for especificado o delimitador, o python retornará um erro de **Parser**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spotify_Charts_df = pd.read_csv('./datasets/spotify_charts_complete.tsv', sep='\\t')\n",
    "spotify_Charts_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 💡 Uma função alternativa para a leitura de arquivos deste tipo é a **read_table()**\n",
    "\n",
    "Neste caso, não é necessário o uso de outros parâmetros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A função read_table é utilizada para ler arquivos .tsv\n",
    "charts = pd.read_table('./datasets/spotify_charts_complete.tsv')\n",
    "charts.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arquivos de Planilhas - XLS\n",
    "\n",
    "Outro formato bastante popular são os arquivos que já se encontram em estrutura tabulares, tais como arquivos do Microsoft Excel. A figura abaixo mostra um arquivo XLS.\n",
    "\n",
    "![Exemplo de Arquivo XLS](./img/XLSX.png)\n",
    "\n",
    "O pandas possui a função **read_excel(‘arquivo.xlsx’)** para efetuar a leitura de arquivos em formato de planilhas eletrônicas.\n",
    "\n",
    "> ⚠️ Para a importação de uma **planilha específica** em um mesmo arquivo (uma **aba**), é preciso utilizar o parâmetro **sheet_name**.\n",
    "\n",
    "Na figura acima, o arquivo chamado ‘dados.xlsx’ possui duas abas: _**spotify_artists**_ e _**spotify_charts**_. \n",
    "\n",
    "Para importar apenas o conteúdo da segunda aba (**spotify_charts**) do arquivo dados.xlsx, programa-se: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spotify_charts = pd.read_excel ('./datasets/dados.xlsx', sheet_name='spotify_charts')\n",
    "spotify_charts.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ⚠️ Caso o `sheet_name` não seja especificado, importa-se a primeira aba."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spotify_artists = pd.read_excel ('./datasets/dados.xlsx')\n",
    "spotify_artists.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arquivos JSON (JavaScript Object Notation)\n",
    "\n",
    "Um arquivo JSON armazena estruturas de dados simples, além de serem leves, textuais, legíveis por humanos e editáveis com editor de texto. Arquivos JSON representam dados com o conceito de chave e valor:\n",
    "\n",
    "cada valor tem uma chave que descreve seu significado. Por exemplo, o par de _**chave:valor**_ **name:‘Michael Jackson’** representa o artista ‘Michael Jackson’. A figura abaixo mostra um trecho de um arquivo JSON.\n",
    "\n",
    "![Exemplo de Arquivo JSON](./img/JSON.png)\n",
    "\n",
    "> 💡  Note que é possível compreender os dados, e alterá-los utilizando um editor de texto.\n",
    "\n",
    "\n",
    "Para importar arquivos JSON, o pandas tem a função **read_json()**, com funcionamento similar às anteriores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "tracks = pd.read_json('./datasets/Michael_Jackson_tracks.json')\n",
    "tracks.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No entanto, a saída acima parece um pouco desajeitada, certo? 🤔\n",
    "\n",
    "Isso acontece pois este é um arquivo **JSON aninhado**, ou seja, ele possui vários níveis de pares [chave:valor]. \n",
    "\n",
    "O primeiro nível é a chave _**tracks**_, ou seja, cada linha do dataframe retornado é um valor para 'track'. Neste caso, não é possível transformar um arquivo JSON __aninhado__ diretamente em um dataframe, pois a função __*read_json*__ faz a leitura de strings JSON mais simples.\n",
    "\n",
    "Para o nosso exemplo, a obtenção de um dataframe organizado demanda a divisão deste JSON aninhado. Para isso, a função *__json_normalize()__* é utilizada para ler a __STRING__ JSON aninhada e devolver um DataFrame.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Precisamos importar a biblioteca JSON\n",
    "import json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Primeiro Passo:\n",
    "ler a string JSON com a função **json.loads()** da biblioteca JSON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('./datasets/Michael_Jackson_tracks.json','r') as f:\n",
    "    data = json.loads(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Segundo Passo: \n",
    "\n",
    "Passamos o objeto JSON (data) para a função **json_normalize()** que retornará um DataFrame contendo os dados necessários. Para isso, é preciso informar o primeiro nível de chave (_tracks_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tracks_df = pd.json_normalize(data['tracks'])\n",
    "\n",
    "tracks_df.head()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A coluna __*artists*__ também é composta por mais um nível do arquivo json. \n",
    "\n",
    "Para melhor visualizar esta coluna, é preciso repetir o processo acima construindo um novo dataframe, no entanto é preciso informar a linha que se deseja recuperar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "artist_df = pd.json_normalize(data['tracks'][0]['artists'])\n",
    "\n",
    "artist_df.head()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Outros formatos\n",
    "\n",
    "Além desses formatos, é possível carregar dados de XML e de bancos de dados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 'TJSE')\n",
      "(2, 'TRIBUNAL DE JUSTICA DO ESTADO DE GOIAS')\n",
      "(3, 'TJPR')\n",
      "(4, 'TRIBUNAL DE JUSTIÇA DO ESTADO DE MATO GROSSO')\n",
      "(5, 'TJ-TO')\n",
      "(6, 'JFTO')\n",
      "(7, 'JFMG')\n",
      "(8, 'Poder Judiciário do RN')\n",
      "(9, 'TRIBUNAL DE JUSTIÇA DO ESTADO DO PIAUÍ')\n",
      "(10, 'TRIBUNAL DE JUSTICA DO ESTADO DO CEARA')\n"
     ]
    }
   ],
   "source": [
    "# Primeiro, importa o driver para o MySQL\n",
    "import mysql.connector\n",
    "\n",
    "# O seguinte código faz a conexão:\n",
    "conn = mysql.connector.connect(user='jai',              # Seu User\n",
    "                                password='senha',       # Sua senha\n",
    "                                host='127.0.0.1',       # Endereço do servidor\n",
    "                                database='jusbd')       # Base de Dados\n",
    "\n",
    "# Criar um cursor\n",
    "cursor = conn.cursor()\n",
    "\n",
    "# Elabora uma consulta\n",
    "query = (\"SELECT * from orgão limit 10\")\n",
    "\n",
    "# Executa a consulta\n",
    "cursor.execute(query)\n",
    "\n",
    "# Exibe o resultado da consulta\n",
    "for l in cursor.fetchall():\n",
    "    print(l)\n",
    "\n",
    "# Fecha o cursor\n",
    "cursor.close()\n",
    "# Fecha a conexão\n",
    "conn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusão"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este notebook apresentou como importar dados de diversos formatos para o pandas.\n",
    "\n",
    "> 🔎 **Se interessou?** Dê uma olhada na documentação da biblioteca *pandas* para informações extras sobre leitura de dados:\n",
    "[IO Tools](https://pandas.pydata.org/docs/user_guide/io.html)\n",
    "\n",
    "---\n",
    "\n",
    "O próximo notebook ([3.2.Limpeza.ipynb](3.2.Limpeza.ipynb)) apresenta como fazer a limpeza dos dados."
   ]
  }
 ],
 "metadata": {
  "julynter-results": {
   "filteredId": [],
   "filteredIndividual": [],
   "filteredRestart": [],
   "filteredType": [],
   "hash": "6b27a9fb782d43d181404925077b28607a688e69",
   "visible": []
  },
  "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.8.10"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}