aula01/Aula01_Atividade_ExploratoriaManipularDF.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ciência dos Dados - 2020 / Primeiro Semestre\n",
    "\n",
    "## Aula 01 - Atividade Exploratória para Manipular um DataFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Índice\n",
    "\n",
    "- [Introdução](#introducao)\n",
    "    - [Abrindo um arquivo e visualizando seu conteúdo](#abrindo-arquivo)\n",
    "    - [Começando a explorar os dados](#comecando-exploracao)\n",
    "    - [Exercício 1](#ex1)\n",
    "- [Filtrando ou criando novos DataFrame](#filtrando)\n",
    "    - [Selecionando uma variável de um DataFrame](#select1)\n",
    "    - [Selecionando linhas de um DataFrame](#selectlinhas)\n",
    "    - [Selecionando linhas de um DataFrame usando mais de uma condição](#selectlinhas-combinando)\n",
    "    - [Selecionando um subconjunto de um DataFrame](#selectmais)\n",
    "    - [Exercício 2](#ex2)\n",
    "- [Resumo dos comandos](#resumo-comandos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"introducao\"></div>\n",
    "\n",
    "___\n",
    "\n",
    "## Introdução\n",
    "\n",
    "A biblioteca **Pandas** é um conjunto de funções para o Python com intuito de trabalhar com Data Science. Essa biblioteca permite, além de abrir diversos tipos de arquivos, trabalhar também com o ferramental descritivo para responder perguntas sobre seus dados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importando as bibliotecas necessárias para esta atividade\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"abrindo-arquivo\"></div>\n",
    "\n",
    "___\n",
    "\n",
    "### Abrindo um arquivo e visualizando seu conteúdo:\n",
    "\n",
    "Vamos começar abrindo um arquivo no formato Excel. Verifique ANTES se o arquivo `WorldBank.xlsx` está na mesma pasta que salvou este arquivo notebook (pasta de trabalho). O comando a seguir mostra a pasta de trabalho!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "print(f'Esperamos trabalhar no diretório {os.getcwd()}')\n",
    "\n",
    "filename = 'WorldBank.xlsx'\n",
    "if filename in os.listdir():\n",
    "    print(f'Parece que o arquivo {filename} está na pasta do notebook, yay!')\n",
    "else:\n",
    "    print(f'Não encontrei o arquivo {filename}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...\n",
    "\n",
    "Os dados contem informações sobre países disponíveis em um dos mais conhecidos databases da Internet: [World Bank](https://data.worldbank.org/).\n",
    "\n",
    "Primeiramente, abra o arquivo e armazene em uma variável!\n",
    "\n",
    "<div id=\"read_excel\"></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dados = pd.read_excel('WorldBank.xlsx')\n",
    "# Se esse comando não funcionar, pode ser que você não tenha instalado a \n",
    "# biblioteca 'xlrd', leia a mensagem de erro até o fim."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ver quais informações estão disponíveis neste arquivo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...\n",
    "\n",
    "Agora `dados` é uma variável do tipo `DataFrame`, o tipo padrão usado no pandas para representar uma tabela. Podemos ver em **negrito** à esquerda o índice de cada linha e acima os nomes das colunas. Depois de imprimir a tabela o pandas também mostra a quantidade de linhas (168) e colunas (6) disponíveis.\n",
    "\n",
    "Antes de prosseguir, vamos garantir que sabemos o que cada uma das colunas significa:\n",
    "\n",
    "- **Country**: nome do país;\n",
    "- **Population**: população;\n",
    "- **GDPcapita**: PIB per capita;\n",
    "- **surface**: área total em km$^2$;\n",
    "- **region**: região;\n",
    "- **landlocked**: sem litoral (0=com litoral; 1=sem litoral).\n",
    "\n",
    "Voltando ao nosso `DataFrame`, você notou que ele não imprimiu todas as linhas? Isso acontece porque o conjunto de dados pode ser **muito** grande. No nosso caso só queríamos ter uma ideia de quais dados estão disponíveis, então não precisávamos ver todas as linhas. Talvez seria interessante ver até menos do que isso.\n",
    "\n",
    "Para ver somente as primeiras linhas podemos usar o comando `.head()`:\n",
    "\n",
    "<div id=\"head\"></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dados.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você pode especificar mais ou menos linhas passando um número como argumento:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dados.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se preferir, podemos ver as últimas linhas com o comando `.tail()`, que também pode receber a quantidade de linhas:\n",
    "\n",
    "<div id=\"tail\"></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dados.tail(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"comecando-exploracao\"></div>\n",
    "\n",
    "### Começando a explorar os dados\n",
    "\n",
    "A princípio as informações apresentadas nas últimas células não parecem muito úteis. São simplesmente as primeiras ou últimas linhas de uma tabela na qual as linhas estão em ordem alfabética do nome dos países. Mas esses comandos podem se tornar mais úteis se os combinarmos com outras operações.\n",
    "\n",
    "Suponha que ao invés da ordem pelo nome dos países o `DataFrame` estivesse ordenado pelo tamanho da população. Nesse caso, as 5 primeiras linhas seriam os 5 países com menor população. Para obter esta informação vamos tentar utilizar o comando `sort_values`.\n",
    "\n",
    "<div id=\"sort_values\"></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dados.sort_values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A célula acima não funcionou, mas a mensagem de erro nos dá uma dica: está faltando um argumento para a função `sort_values`. Vamos refletir sobre o que queremos fazer. Queremos a tabela armazenada em `dados` ordenada, mas ordenada utilizando qual critério? É para isso que precisamos desse argumento adicional `by`. Devemos indicar qual coluna deve ser utilizada como critério de ordenação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dados.sort_values('Population')  # Equivalente a: dados.sort_values(by='Population')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Importante:** a operação da célula anterior **não** modifica o `DataFrame` original. Para comprovar, vamos verificar que `dados` ainda está em ordem alfabética:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas então, o que aconteceu? Ao executar o `sort_values` um *novo* `DataFrame` é devolvido. Podemos então utilizar o comando `.head()` neste novo `DataFrame` para visualizar os 5 países menos populosos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dados_ordenados_por_população = dados.sort_values(by='Population')\n",
    "dados_ordenados_por_população.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos até evitar a criação de uma nova variável e simplesmente encadear os comandos `.sort_values()` e `.head()` em uma linha só! Isso é um padrão comum de escrita de código quando usamos Pandas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dados.sort_values(by='Population').head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"ex1\"></div>\n",
    "\n",
    "___\n",
    "\n",
    "### EXERCÍCIO 1\n",
    "\n",
    "Liste os 10 países mais ricos utilizando o PIB per capita. Dica: leia a documentação da função `sort_values` do pandas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Coloque seu código aqui...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"filtrando\"></div>\n",
    "\n",
    "___\n",
    "\n",
    "## Filtrando ou criando novos DataFrame\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"select1\"></div>\n",
    "\n",
    "### Selecionando uma variável de um DataFrame\n",
    "\n",
    "Suponha que haja o interesse em trabalhar apenas com a variável `region` - podemos estar interessados em *estatísticas* acerca desta variável, ou talvez quiséssemos montar uma lista impressa das regiões. Como separar apenas essa variável?\n",
    "\n",
    "No Pandas, cada coluna de um `DataFrame` é chamada de `Series`. O `DataFrame` é como uma coleção de `Series` que são indexadas pelo nome da coluna, como se fosse um *dicionário* do Python. Inclusive podemos extrair nossa `Series` do nosso `DataFrame` usando a notação de dicionário!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_region = dados['region']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(dados))\n",
    "print(type(serie_region))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora podemos observar alguns dados desta série:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_region.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note a informação impressa ao término da listagem dos primeiros elementos da série. Temos o nome da série e o `dtype`, que é o tipo de dados (*data type*) da série. Quando o tipo é `object`, geralmente trata-se de uma série de itens de texto puro. Já outras séries podem ter tipos diferentes como:\n",
    "\n",
    "| Tipo | Significado |\n",
    "|---|---|\n",
    "| `int64` | Valores inteiros. |\n",
    "| `float64` | Números reais representados em notação de ponto-flutuante |\n",
    "| `bool` | Variáveis *booleanas* (só podem valer `True` ou `False`) |\n",
    "| `categorical` | Variáveis *categóricas*, que representam elementos de um conjunto finito de categorias (por exemplo: escolhas em um formulário) |\n",
    "| `datetime64` | Datas |\n",
    "| `timedelta[ns]` | Diferenças entre instantes de tempo |\n",
    "\n",
    "Da mesma forma que fizemos acima ao encadear o `.sort_values()` e o `.head()`, podemos evitar a construção de uma variável extra aqui encadeando a seleção da coluna e a aplicação do comando `.head()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Maneira 1:\n",
    "dados['region'].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existe outra maneira de acessar uma coluna do `DataFrame`. O Pandas oferece também o acesso às colunas de um `DataFrame` como se fossem *atributos* do `DataFrame` (lembra de classes e atributos lá de Design de Software?):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Maneira 2:\n",
    "dados.region.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ainda, é possível utilizar o comando `loc` cuja propriedade é acessar um subconjunto de linhas e/ou colunas considerando seus respectivos rótulos. Esse comando é semelhante ao fatiamento (*slicing*) de listas e strings que utilizávamos em Design de Software.\n",
    "\n",
    "De **maneira geral**, funciona da seguinte maneira:\n",
    "\n",
    "`DataFrame.loc[<rótulo linha(s)>,<rótulo coluna(s)>]`\n",
    "\n",
    "Consulte mais detalhes [aqui](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.loc.html).\n",
    "\n",
    "<div id=\"loc\"></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Maneira 3:\n",
    "dados.loc[:,'region'].head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se for utilizado o rótulo da coluna em formato de lista, o resultado se mantem como tipo `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Maneira 4:\n",
    "dados.loc[:,['region']].head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por exemplo, podemos usar essa última variante do comando `.loc[]` para obter um `DataFrame` com apenas as colunas `region` e `Country`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dados.loc[:, ['region', 'Country']].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por fim, também é possível utilizar o comando `iloc` cuja propriedade é acessar um subconjunto de linhas e/ou colunas considerando números inteiros para indicar a posição. Lembrando que a posição começa em $0$ e termina em `length`$-1$.\n",
    "\n",
    "De **maneira geral**, funciona da seguinte maneira:\n",
    "\n",
    "`DataFrame.iloc[<posição linha(s)>,<posição coluna(s)>]`\n",
    "\n",
    "Consulte mais detalhes [aqui](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iloc.html).\n",
    "\n",
    "<div id=\"iloc\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes, para saber a posição da coluna que procura:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(dados).index('region')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalmente, mais uma maneira para selecionar apenas a coluna `region` que está na quinta coluna (ou seja, na posição 4), temos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Maneira 5:\n",
    "dados.iloc[:,4].head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"selectlinhas\"></div>\n",
    "\n",
    "### Selecionando linhas de um DataFrame\n",
    "\n",
    "Suponha que você queira filtrar o `DataFrame`, deixando apenas os países da América do Sul. Em todos os exemplos até aqui usando tanto o `.loc` quanto o `.iloc` utilizamos dois pontos (`:`) no primeiro argumento. Isso é semelhante ao que fazíamos em Design de Software para fazer um fatiamento de uma lista que vai desde o começo até o fim, ou seja, que pega todas as linhas. Assim, utilizaremos esse primeiro argumento do `.loc` e `.iloc` para selecionar apenas algumas linhas específicas.\n",
    "\n",
    "Uma facilidade oferecida pelo pandas é a possibilidade de comparar uma coluna inteira do `DataFrame` (ou seja, uma `Series`) com um valor. Por exemplo:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Regiões:')\n",
    "print(dados['region'])\n",
    "print(\"\\n\\nComparação das regiões com a string 'america_south':\")\n",
    "print(dados['region'] == 'america_south')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O resultado dessa operação foi uma coluna de valores booleanos, que indica para cada elemento da coluna original se ele era igual à string desejada. A vantagem disso é que podemos usar essa coluna de booleanos como filtro do `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtra_linhas = dados['region'] == 'america_south'\n",
    "dados.loc[filtra_linhas, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizamos diversos conceitos na célula anterior. Para facilitar a compreensão, explique para um colega o que está acontecendo no comando acima.\n",
    "\n",
    "**Importante:** no exemplo acima utilizamos o comparador `==`, mas também podemos utilizar os outros comparadores que já conhecemos do Python (desde que faça sentido levando em conta o tipo dos dados da coluna): `<`, `<=`, `>`, `>=`, etc.\n",
    "\n",
    "<div id=\"selectlinhas-combinando\"></div>\n",
    "\n",
    "### Selecionando linhas de um DataFrame usando mais de uma condição\n",
    "\n",
    "É possível que queiramos combinar condições. Por exemplo, queremos todos os países da América do Sul que possuam população menor do que 10.000.000 pessoas. Para combinar condições em Design de Software, utilizávamos a palavras `and` e `or`. Para combinar condições de colunas, vamos utilizar `&` e `|`, que são análogos ao `and` e `or`, respectivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "na_america_do_sul = dados['region'] == 'america_south'\n",
    "populacao_menor_que_10m = dados['Population'] < 10000000\n",
    "dados.loc[na_america_do_sul & populacao_menor_que_10m, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"selectmais\"></div>\n",
    "\n",
    "### Selecionando um subconjunto de um DataFrame\n",
    "\n",
    "Selecione as colunas `Country` e `region` com todas as linhas.\n",
    "\n",
    "Para selecionar apenas uma variável, a linha de comando `dados['region']` funciona, como já vimos anteriormente.\n",
    "\n",
    "Mas usar a mesma ideia para duas colunas: `dados['Country','region']`, dá certo? Faça a tentativa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dados['Country','region']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vimos que não funciona. \n",
    "\n",
    "Aqui vamos precisar ter os rótulos das colunas em uma lista `['Country','region']` para fazer a pesquisa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Maneira 1:\n",
    "dados[['Country','region']].head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outra maneira é usar `.loc[]` como vimos acima. Aqui precisamos indicar que serão selecionadas todas as linhas com `:`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Maneira 2:\n",
    "dados.loc[:,['Country','region']].head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por fim, a terceira maneira é usar `iloc` indicando a posição das duas colunas também em lista.\n",
    "\n",
    "Já sabemos que `region` está na pósição $4$. E `Country`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(dados).index('Country')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Maneira 3\n",
    "dados.iloc[:,[0,4]].head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"ex2\"></div>\n",
    "\n",
    "___\n",
    "\n",
    "### EXERCÍCIO 2\n",
    "\n",
    "Selecione as colunas `Country` e `region` com países que possuem PIB per capita acima de $35$ mil."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Coloque seu código aqui...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"resumo-comandos\"></div>\n",
    "\n",
    "## Resumo dos Comandos\n",
    "\n",
    "Aqui você encontra um resumo dos comandos apresentados neste notebook:\n",
    "\n",
    "- [`read_excel`](#read_excel): abre um arquivo do tipo XLSX;\n",
    "- [`head`](#head): mostra apenas as primeiras linhas do `DataFrame`;\n",
    "- [`tail`](#tail): mostra apenas as últimas linhas do `DataFrame`;\n",
    "- [`sort_values`](#sort_values): devolve um **novo** `DataFrame` com o conteúdo ordenado;\n",
    "- [`loc`](#loc): acessa um subconjunto de linhas e/ou colunas considerando seus respectivos rótulos no DataFrame.\n",
    "- [`iloc`](#iloc): acessa um subconjunto de linhas e/ou colunas considerando números inteiros para indicar a posição.\n",
    "\n",
    "\n",
    "Consulte [aqui](https://medium.com/horadecodar/data-science-tips-02-como-usar-loc-e-iloc-no-pandas-fab58e214d87) estudar mais sobre `loc` e `iloc`."
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 4
}