PS - Talus Insper - 2020.2 - Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NOTEBOOK COM TUTORIAIS RELEVANTES\n",
    "<br>\n",
    "\n",
    "- <a href=\"#tutorial-jupyter\">Tutorial simples de Jupyter</a>\n",
    "- <a href=\"#variaveis\">Tipos de variáveis</a>\n",
    "- <a href=\"#operacoes-numeros\">Operações básicas</a>\n",
    "- <a href=\"#operacoes-strings\">Operações com strings</a>\n",
    "- <a href=\"#estruturas\">Estruturas básicas</a>\n",
    "- <a href=\"#condicionais\">Condicionais</a>\n",
    "- <a href=\"#loops\">Estruturas de repetição</a>\n",
    "- <a href=\"#funcoes\">Funções</a>\n",
    "- <a href=\"#arquivos\">Arquivos</a>\n",
    "- <a href=\"#poo\">Programação Orientada a Objetos (POO)</a>\n",
    "- <a href=\"#pydata\">Stack básica de PyData</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tutorial Jupyter\n",
    "<div id=\"tutorial-jupyter\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Caso você não saiba como usar jupyter, aqui vai um tutorial simples mas que satisfaz as necessidades para esse tutorial e o desafio."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Célula são essas estruturas nas quais escrevemos texto e código no Jupyter, para editar uma célula de código basta clicar nessa, se for uma célula de texto, clique duas vezes.\n",
    "\n",
    "Para executar uma célula, você pode usar o botão __Run__ na toolbar do Jupyter. Ou ainda usando as teclas <kbd>Shift</kbd>+<kbd>Enter</kbd>.\n",
    "\n",
    "<img src=\"./img/run-jupyter-cell.png\">\n",
    "\n",
    "Ainda nessa imagem, a tecla de <kbd>+</kbd> adiciona novas células. A tecla com as setas permitem mover uma célula no jupyter.\n",
    "\n",
    "Além de executar uma célula, você pode interromper a execução com o botão com um quadrado no meio. Você pode ainda interromper o kernel, sem entrar nos detalhes, isso resetaria tudo que já foi feito no jupyter, nada será apagado, mas variáveis criadas e tudo mais serão esquecidas.\n",
    "\n",
    "O botão com duas setas roda todas as células até que chegue no fim ou encontre um erro.\n",
    "\n",
    "No campo escrito __Markdown__ você pode mudar o tipo da célula. Células de texto são do tipo Markdown e células de código do tipo Code.\n",
    "\n",
    "Ferramentas de edição como retornar células excluídas, copiar e colar células... podem ser achadas na opção __Edit__.\n",
    "\n",
    "Você pode ainda reiniciar o kernel e rodar todas as células ou simplesmente limpar o output na opção __Kernel__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variáveis e tipos de variáveis\n",
    "<div id=\"variaveis\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diferente de outras linguagens de programação tradicionais, em Python você não precisa declarar o tipo de uma variável. Você pode declarar variáveis simplesmente atribuindo um valor a elas e também pode mudar a qualquer momento:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a função usada para verificar o tipo de uma variável é a função type()\n",
    "print('{0} é uma variável do tipo {1}'.format(-1,type(-1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode simplesmente invocar a função e passar o argumento que ao executar a célula terá como output o tipo\n",
    "type(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alguns outros tipos de variáveis comuns em python são:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# inteiros (e.g. 0, -1, 2)\n",
    "print('{0} é uma variável do tipo {1}'.format(2,type(2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# float/números reais/pontos flutuantes (e.g. 1.0, 3.14, -2.71)\n",
    "print('{0} e {1} são variáveis do tipo {2}'.format(2.0,3.14,type(2.0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# complex/números complexos (e.g. 3 + 4j, -1j)\n",
    "# atente que, ao contrário da literatura clássica, aqui a raiz complexa é j\n",
    "print('{0} é uma variável do tipo {1}'.format(3+4j,type(3+4j)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# string/caracteres/texto (e.g. 'isso eh uma string', 'a', 'string')\n",
    "print(\"{0} é uma variável do tipo {1}\".format('Uma string',type('Uma string')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# OBS.: strings devem estar entre aspas (\"\") ou aspas simples ('')\n",
    "# do contrário será interpretado como uma variável sem valor\n",
    "# rode a célula abaixo para verificar o erro que será obtido se esquecer as aspas\n",
    "type(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# booleano (e.g. True ou False)\n",
    "print('{0} é uma variável do tipo {1}'.format(True,type(True)))\n",
    "# perceba que True e False não precisam de aspas, no entanto a primeira letra deve ser maiúscula\n",
    "# nunca nomeie variáveis com esse nome, é uma boa prática de programação!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# None/vazio/sem valor\n",
    "print('{0} é uma variável do tipo {1}'.format(None,type(None)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pode ser útil comparar o tipo de variáveis e até mesmo converter o tipo da variável para outro. Verifique como fazer isso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# para comparar o tipo de uma variável, usamos a função isinstance()\n",
    "# ela retorna um booleano com o resultado da comparação\n",
    "print('isinstance(\"Uma string\",str) = {0}'.format(isinstance('Uma string',str)))\n",
    "print('isinstance(-1,float) = {0}'.format(isinstance(-1,float)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# para converter o tipo da variável, basta passar esta por uma função específica de cada variável\n",
    "string_para_converter = '-1'\n",
    "type(string_para_converter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string_convertida = float(string_para_converter)\n",
    "type(string_convertida)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diferentemente de outras linguagens tradicionais, não é preciso declarar o tipo de uma variável quando esta é declarada. O que permite substituir e converter variáveis muito mais fácil, como visto nas células acima"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a maneira correta de declarar uma variável é variavel = valor\n",
    "# nunca use valor = variavel\n",
    "var = 1\n",
    "print('{0} do tipo {1}'.format(var,type(var)))\n",
    "var = float(var)\n",
    "print('{0} do tipo {1}'.format(var,type(var)))\n",
    "var = 'string'\n",
    "print('{0} do tipo {1}'.format(var,type(var)))\n",
    "\n",
    "# a mesma variável com valores e tipos diferentes!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lembre-se que Python é uma linguagem case sensity\n",
    "# isso significa que letras maiusculas e minusculas no corpo de uma variável são diferentes\n",
    "var = 2\n",
    "Var = 3\n",
    "print(var, Var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operações básicas\n",
    "<div id=\"operacoes-numeros\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É importante ainda saber realizar operações com variáveis em Python. Veja algumas das operações principais:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# soma\n",
    "a = 2\n",
    "b = 3\n",
    "c = a + b\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você ainda pode fazer isso diretamente, sem atribuir a um novo valor\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# é possível ainda realizar operações com ints e floats\n",
    "c + 3.14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# não é possível somar números com variáveis não numéricas\n",
    "5 + 'string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# entretanto é possível somar strings\n",
    "# a essa operação damos o nome de 'concatenação'\n",
    "str1 = 'Eu vou passar'\n",
    "str2 = 'no case da Talus'\n",
    "str_res = str1 + ' ' + str2\n",
    "str_res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# subtração\n",
    "a = 5\n",
    "b = 2.5\n",
    "a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# não é possível realizar o mesmo com strings novamente\n",
    "str1 = 'Eu vou passar no case da Talus'\n",
    "str2 = 'Talus'\n",
    "str1 - str2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiplicação\n",
    "a = 3.14\n",
    "b = -2\n",
    "a*b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dessa vez é possível usar essa operação com strings\n",
    "str1 = '*'\n",
    "str1*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# divisão\n",
    "a = 5\n",
    "b = 2\n",
    "a/b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# se usarmos duas barras inclinadas conseguiremos apenas a parte inteira da divisão\n",
    "a//b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cuidado ao dividir por zero!\n",
    "# veja o erro que você obteria\n",
    "3.14/0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exponenciação\n",
    "# a operação de exponenciação é realizada usando dois asteriscos de multiplicação\n",
    "a = 4\n",
    "a**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# também é possível realizar a operação utilizando a função pow()\n",
    "pow(16,0.5)\n",
    "# note que o resultado da radiação é um float e não um inteiro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# módulo\n",
    "# o operador módulo representada por '%' devolve o resto da divisão entre dois números\n",
    "5%2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# arredondamento\n",
    "# é possível arredondar números usando a função round\n",
    "pi = 3.14159265359\n",
    "print('O número completo é {0}\\nO número arredondado para duas casas decimais é {1}'.format(pi, round(pi,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# valor absoluto\n",
    "# a função abs() retorna o valor absoluto de um número\n",
    "abs(-2.71)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# serve inclusive para números complexos\n",
    "# seja um número complexo z = a + bj -> abs(z) = raiz(a² + b²)\n",
    "z = 3 + 4j\n",
    "abs(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ainda sobre números complexos\n",
    "# é possível obter a parte real e imaginária de um número complexo\n",
    "# basta usar os atribulos .real e .imag\n",
    "print('A parte real de {0} é {1} e a parte imaginária é {2}'.format(z, z.real, z.imag))\n",
    "\n",
    "# não se preocupe agora com o significado de atributo\n",
    "# você também verá isso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# comparação\n",
    "# esse conjunto de operações retorna um valor booleano que verifica a veracidade do que foi dito\n",
    "a = 2\n",
    "b = 3.14\n",
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perceba que a comparação é feita utilizando dois símbolos de igualdade\n",
    "# um único símbolo tem valor de atribuição, duplo símbolos têm valor de comparação\n",
    "# da mesma forma, é possível verificar a desigualdade, nesse caso usamos como sinal '!='\n",
    "a != b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode usar ainda símbolos como >, <, >= (maior que ou igual), <= (menor que ou igual)\n",
    "a <= b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manipulação de strings\n",
    "<div id=\"operacoes-strings\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vimos, existem algumas operações de números são aplicáveis a strings. Nessa parte, vamos ver algumas operações desse tipo de variável"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# se quiser acrescentar cotações ou marcações com aspas em uma string\n",
    "# é preciso mesclar entre aspas simples e aspas duplas\n",
    "string = '\"Make it work, make it right, make it fast.\"\\n-Kent Beck'\n",
    "print(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perceba que usamos uma estrutura peculiar na string anterior: um '\\n'\n",
    "# essas estruturas nos permitem adicionar elementos de espaçamento a uma string\n",
    "# como quebra de linha ou tabeamento (nesse caso seria \\t)\n",
    "string = 'exemplo de\\ttabeamento'\n",
    "print(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nesse caso, perceba que simplesmente convocar a string e executar a célula\n",
    "# não ocuta a estrutura de espaçamento\n",
    "string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# é possível convocar caracteres ou grupos de caracteres de uma string\n",
    "# para isso, passamos, entre colchetes, o index do caracter\n",
    "# lembre-se que em Python a indexação inicia-se em 0\n",
    "# então em 'Talus Insper' o elemento 0 é o 'T' e o elemento 1 é o 'a'\n",
    "string = 'Talus Insper'\n",
    "string[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode passar ainda uma range de valores\n",
    "# atente que em Python a range de 0 a n invocaria os n primeiros elementos, portanto de 0 a n-1\n",
    "string[0:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perceba que o último caracter apresentado é o 'u' que tem index 3\n",
    "# é possível ainda regular o tamanho do passo\n",
    "string[0:4:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nessa célula, nós pedimos dos elementos 0 a 3 pulando de dois em dois elementos\n",
    "# a sintaxe então seria [index_start:index_stop+1:step]\n",
    "# uma curiosidade é que números negativos também são possível\n",
    "string[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nesse caso foi printado do elemento final até o inicial, já que o step é negativo\n",
    "# e portanto está voltando\n",
    "# você pode ainda controlar o elemento final sem contar os caracteres\n",
    "# imagine que você não quer os últimos três caracteres de uma string\n",
    "string[:-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ou que você não queira os três primeiros\n",
    "string[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# atente que você pode mudar uma string por outra\n",
    "# mas não pode mudar um único caracter\n",
    "string[0] = 'C'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# existem algumas funções muito práticas para lidarmos com strings\n",
    "# como a função len() que nos devolve o tamanho de uma string\n",
    "print(\"{0} possui {1} caracteres\".format(string, len(string)))\n",
    "\n",
    "# espaço e elementos como \\n como UM único caracter\n",
    "print(len('\\n'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# os métodos upper() e lower() deixam uma string maiuscula ou minuscula, respectivamente\n",
    "string.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# os métodos NÃO altera a string original\n",
    "# métodos devem ser passados após a variável diferente de funções\n",
    "# calma que você ainda vai entender o porque"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o método split() divide a string em função de um caracter\n",
    "string.split('s')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perceba que a string foi dividida em função de 's'\n",
    "# caso não passe nenhum argumento, a string será dividida em função do espaço ' '\n",
    "string.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o método count() devolve o número de aparições de um caracter ou de uma substring\n",
    "string.count('s')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# caso de uma substring\n",
    "string.count('Talus')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o método find() acha o index da primeira aparição de um caracter\n",
    "string.find('s')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python é uma linguagem muito prática pois várias estruturas de condição seguem a linguagem natural falada\n",
    "# por exemplo a seguinte linha de código verifica se a substring 'Insper' está contida em 'Talus Insper'\n",
    "'Insper' in 'Talus Insper'\n",
    "\n",
    "# bem intuitivo, não?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estruturas básicas\n",
    "<div id=\"estruturas\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Python temos algumas estruturas muito úteis que ajudam a guardar e manipular mais facilmente dados e variáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A primeira estrutura útil são as __listas__!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# O primeiro objeto é a lista. Diferentemente de várias linguagems\n",
    "# em Python não possuimos arrays propriamente ditos,\n",
    "# usamos sempre uma lista para guardar uma série de dados.\n",
    "\n",
    "# para declararmos uma lista, basta escrevermos os elementos separados por vírgulas entre colchetes\n",
    "lista = [2, 4, 6, 8, 10]\n",
    "\n",
    "print(lista)\n",
    "print(type(lista))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perceba que pode haver, ainda, listas vazias\n",
    "# ou listas com elementos de vários tipos\n",
    "\n",
    "# perceba que até listas podem estar dentro de listas!\n",
    "lista1 = [1, -2, 'string', 3.14, []]\n",
    "\n",
    "lista2 = []\n",
    "\n",
    "print(lista1)\n",
    "print(lista2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você ainda pode gerar listas usando a função list()\n",
    "\n",
    "lista = list()\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# essa função pode receber argumentos e eles serão convertidos em listas\n",
    "\n",
    "lista = list('Talus')\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode se referir a um item de uma lista convocando seu index\n",
    "# como visto, a contagem em python começa do zero\n",
    "# então se quisermos o termo -2 da lista1, por exemplo, ele é o termo de index 1\n",
    "\n",
    "print(lista1[1])\n",
    "print(lista1[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode ainda remover ou acrescentar novos elementos a uma lista\n",
    "lista = []\n",
    "print('Lista antes de acrescentar elemento: {}'.format(lista))\n",
    "\n",
    "# para acrescentar elementos usamos o método .append()\n",
    "lista.append('Talus')\n",
    "lista.append('Insper')\n",
    "print('Lista após acrescentar elementos: {}'.format(lista))\n",
    "\n",
    "# e, para excluirmos, podemos usar o método .remove()\n",
    "lista.remove('Insper')\n",
    "print('Lista após remover um elemento: {}'.format(lista))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perceba que uma lista pode ser vista como um vetor unidimensional de elementos\n",
    "# podemos, ainda, criar listas com dimensões maiores\n",
    "# para isso, criamos uma \"lista de listas\"\n",
    "\n",
    "lista2D = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "print(lista2D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a lista criada pode ser vista como uma matriz de números\n",
    "# pode ser mais fácil visualizar da seguinte maneira\n",
    "\n",
    "print(\"{0}\\n{1}\\n{2}\".format(lista2D[0],lista2D[1],lista2D[2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode ainda criar listas de 3, 4, 10, 50 ou quantas dimensões quiser\n",
    "# para tratar de vetores em dimensões mais altas usamos tensores\n",
    "# eles são uma das criações matemáticas responsáveis pela ascensão do Deep Learning\n",
    "# mas você vai aprender mais sobre isso quando você se juntar a gente! 😉"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# para se referir a um elemento de um vetor de mais dimensões\n",
    "# temos que criar uma cadeia de index que precisamos passar até chegar nesse\n",
    "# por exemplo, em lista2D, o elemento 6 tem index 2 para a lista da qual faz parte\n",
    "# essa lista, por sua vez, tem index 1 para a lista2D\n",
    "# logo a cadeira será 1 -> 2 para acessarmos o elemento 6\n",
    "\n",
    "print(lista2D[1][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É possível fazer ainda operações com listas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# somar listas\n",
    "lista1 = [1,2,3]\n",
    "lista2 = [4,5,6]\n",
    "\n",
    "lista1+lista2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode até multiplicar uma lista por um inteiro\n",
    "# é o equivalente a somar aquela lista com sigo mesma\n",
    "lista = [1,2,3]\n",
    "\n",
    "lista*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perceba que listas são muito parecidas com strings\n",
    "# na verdade, strings é que são parecidos com listas!\n",
    "# assim como em outras linguagens, uma string é um array/vetor/lista de caracteres\n",
    "# então as operações de string também servem aquim\n",
    "\n",
    "lista = ['Talus','Insper',10,'Machine Learning']\n",
    "print('Talus' in lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algumas funções built-in úteis para listas são:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# obter tamanho de uma lista\n",
    "# para isso usamos a função len()\n",
    "\n",
    "lista = [0,1,2,3,4,5,6,7]\n",
    "len(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# retornar o máximo valor de uma lista\n",
    "\n",
    "max(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# retornar o mínimo valor de uma lista\n",
    "\n",
    "min(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# contar o número de termos numa lista\n",
    "\n",
    "lista = ['Talus','Insper','Talus','Machine Learning','IA']\n",
    "lista.count('Talus')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pegar o index da primeira aparição\n",
    "\n",
    "lista.index('Insper')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# inserir elementos em outra posição\n",
    "\n",
    "# acrescentando 'Data Science' a posição de index 2\n",
    "lista.insert(2, 'Data Science')\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reverter a ordem dos elementos\n",
    "\n",
    "lista.reverse()\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sortear os elementos de uma lista\n",
    "\n",
    "lista = [3.14, -1, 5, 0, 2]\n",
    "lista.sort()\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagine agora que você precisasse criar uma maneira de relacionar as disciplinas do primeiro ano de engenharia do Insper com o semestre dessa disciplina. Com os conhecimentos até aqui você poderia pensar em criar duas listas: uma com os nomes das disciplinas e, para cada disciplina, o semestre em outra lista com o mesmo index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "disciplinas = ['GDE','DeSoft','ModSim','InstruMed','NatDes','MatVar','CDados','Acionas','CoDes','FisMov']\n",
    "semestre = ['1° Semestre','1° Semestre','1° Semestre','1° Semestre','1° Semestre',\n",
    "            '2° Semestre','2° Semestre','2° Semestre','2° Semestre','2° Semestre']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dessa forma\n",
    "\n",
    "print('{0} é uma matéria do {1}. Já {2} é uma matéria do {3}'\n",
    "      .format(disciplinas[5],semestre[5],disciplinas[0],semestre[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma maneira ainda mais eficiente seria criar uma única lista com dois elementos: 1° e 2° semestre e outra lista com duas listas: uma com as matérias do primeiro semestre e outra com as matérias do segundo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "semestre = ['1° Semestre','2° Semestre']\n",
    "disciplinas = [['GDE','DeSoft','ModSim','InstruMed','NatDes'],['MatVar','CDados','Acionas','CoDes','FisMov']]\n",
    "\n",
    "print('{0} é uma matéria do {1}. Já {2} é uma matéria do {3}'\n",
    "      .format(disciplinas[1][2],semestre[1],disciplinas[0][1],semestre[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas ainda existe um jeito ainda mais eficiente. A próxima estrutura que vamos falar sobre resolve esse problema muito mais fácil. Essa estrutura são os __dicionários__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Um dicionário simples contendo o nome, sobrenome e a idade de uma pessoa.\n",
    "dicionario = {'Nome': 'Joseph', 'Sobrenome': 'Joestrela', 'Idade': 69}\n",
    "\n",
    "# Vamos acessar o sobrenome dessa pessoa usando a chave 'Sobrenome'\n",
    "print(dicionario['Sobrenome'])\n",
    "\n",
    "# Vamos acessar agora a idade dessa pessoa com a chave 'Idade'\n",
    "print(dicionario['Idade'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode ainda criar dicionários através da função dict()\n",
    "\n",
    "dicionario = dict()\n",
    "dicionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# é possível adicionar elementos a esse dicionário da seguinte forma\n",
    "\n",
    "dicionario['key'] = 'value'\n",
    "dicionario['pi'] = 3.14\n",
    "dicionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assim como a lista, o dicionário possui algumas funções muito uteis para facilitar sua manipulação.\n",
    "# A função values() retorna todos os valores das chaves do dicionário.\n",
    "\n",
    "dicionario = {'Nome': 'Joseph', 'Sobrenome': 'Joestrela', 'Idade': 69}\n",
    "\n",
    "dicionario.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A função keys() retorna todas as chaves do dicionário\n",
    "\n",
    "dicionario = {'Nome': 'Joseph', 'Sobrenome': 'Joestrela', 'Idade': 69}\n",
    "\n",
    "dicionario.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A função pop() nos dicionários funciona de uma maneira muito semelhante a sua semelhante nas listas, contudo, usaremos\n",
    "# as chaves ao inves dos indices\n",
    "\n",
    "dicionario = {'Nome': 'Joseph', 'Sobrenome': 'Joestrela', 'Idade': 69}\n",
    "\n",
    "nome = dicionario.pop('Nome')\n",
    "\n",
    "# O nome da pessoa obtido através da função pop()\n",
    "print(nome)\n",
    "\n",
    "# Perceba que a chave 'Nome', assim como seu valor foram perdidos\n",
    "print(dicionario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A função popitem() funciona como a função pop() em listas quando não especificamos o indice, removendo o ultimo\n",
    "# item junto a sua chave e os retornando.\n",
    "\n",
    "dicionario = {'Nome': 'Joseph', 'Sobrenome': 'Joestrela', 'Idade': 69}\n",
    "\n",
    "idade = dicionario.popitem()\n",
    "\n",
    "# A idade da pessoa\n",
    "print(idade)\n",
    "\n",
    "# Perceba como o ultimo item do dicionario foi perdido junto a sua chave\n",
    "print(dicionario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sendo assim, veja como poderíamos solucionar o problema das disciplinas\n",
    "\n",
    "semestre_disciplina = {'1° Semestre':['GDE','DeSoft','ModSim','InstruMed','NatDes'],\n",
    "                       '2° Semestre':['MatVar','CDados','Acionas','CoDes','FisMov']}\n",
    "\n",
    "semestre = '1° Semestre'\n",
    "print('{0} são disciplinas do {1}'\n",
    "      .format(semestre_disciplina[semestre], semestre))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Condicionais\n",
    "<div id=\"condicionais\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Python existem estruturas condicionais como em outras linguagens de programação. Veja como utilizar algumas delas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# em Python é possível realizar comparações sem uma estrutura de comparação\n",
    "\n",
    "print(5 > 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# vê? Afinal, 5 realmente é maior que 2 até o momento em que escrevo isso\n",
    "# podemos relacionar essas condições com uma ação\n",
    "# como um \"acionador\"\n",
    "# veja como podemos fazer isso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# condicional if\n",
    "\n",
    "if 5>2:\n",
    "    print(\"5 é maior que 2, ufa!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algumas coisas são importantes notar:\n",
    "\n",
    "- Em Python não precisamos por as condições entre parênteses. Mas se você usar também funciona!\n",
    "- Python não possui chave para separar os blocos de código, mas a identação é muito importante!\n",
    "- Não esqueça os dois pontos também!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiplas condições\n",
    "# é possível usar multiplas condições em um único if usando operadores lógicos and e or\n",
    "\n",
    "if (5 > 2 and 3 < 6):\n",
    "    print(\"Deu certo!\")\n",
    "    \n",
    "if (5 > 2 or 3 > 6):\n",
    "    print(\"Também deu certo!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o condicional and é equivalente a utilizar um if dentro de outro\n",
    "\n",
    "if 5 > 2:\n",
    "    if 3 < 6:\n",
    "        print(\"Vê?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# já o condicional or é equivalente a escrever dois if separadamente com a mesma ação\n",
    "\n",
    "if 5 > 2:\n",
    "    print(\"Okay, né?\")\n",
    "if 3 > 6:\n",
    "    print(\"Okay, né?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Até agora fizemos operações usando os operadores \"maior que\" (>) e \"menor que\" (<). Mas atente para outros sinais:\n",
    "\n",
    "- maior que ou igual (>=)\n",
    "- menor que ou igual (<=)\n",
    "- igual (==)\n",
    "- diferente (!=)\n",
    "\n",
    "perceba que o operador de igualdade é \"==\", um único \"=\" significa atribuição, conforme vimos em variáveis. Dois \"=\" significam comparação."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 'Python' != 'Javascript':\n",
    "    print('Python é diferente de Javascript')\n",
    "\n",
    "lista1 = [1,2,3,4]\n",
    "lista2 = [5,6,7,8]\n",
    "\n",
    "if len(lista1) == len(lista2):\n",
    "    print('As lista têm o mesmo tamanho')\n",
    "    \n",
    "dicionario = {'Machine':'Learning','Inteligência':'Artificial'}\n",
    "\n",
    "if 'Machine' in dicionario:\n",
    "    print(dicionario['Machine'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# acho que isso ficou claro\n",
    "# imagine agora que a condição não seja atendida\n",
    "# mas que sua negação também implique em uma ação\n",
    "# como você atacaria esse problema?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# em alguns casos, a resposta é simples\n",
    "# basta fazermos dois if: um com a condição e outro com sua negação\n",
    "\n",
    "if 3 > 6:\n",
    "    print('Algo está errado aqui...')\n",
    "if 3 <= 6:\n",
    "    print('Ufa!')\n",
    "    \n",
    "# a negação de \"3 maior que 6\" é \"3 menor que OU IGUAL a 6\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mas em alguns casos, pensar na negação não é tão simples\n",
    "# para poupar-nos desse sofrimento, existe uma estrutura que faz isso por nós\n",
    "# esse é o else\n",
    "\n",
    "if 3 > 6:\n",
    "    print('Algo está errado aqui...')\n",
    "else:\n",
    "    print('Ufa!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o else não exige nenhuma condição\n",
    "# ele sempre nega o if imediatamente anterior a este\n",
    "# se houver alguma estrutura entre estes você terá um erro\n",
    "\n",
    "num1 = 3\n",
    "num2 = 6\n",
    "\n",
    "if num1 > num2:\n",
    "    print('Algo está errado aqui...')\n",
    "    \n",
    "num1 = 5\n",
    "    \n",
    "else:\n",
    "    print('Ufa!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mas nesse caso de verificar se um número é maior que outro\n",
    "# ou em outros casos\n",
    "# a negação inclui várias possibilidades\n",
    "# nesse caso, por exemplo, num1 poderia ser menor que num2 ou poderia ser igual\n",
    "# o else inclui ambas possibilidades\n",
    "# se você quiser atacar cada uma separadamente pode usar a estrutura elif\n",
    "\n",
    "num1 = 3\n",
    "num2 = 6\n",
    "\n",
    "if num1 > num2:\n",
    "    print('{} > {}'.format(num1, num2))\n",
    "elif num1 == num2:\n",
    "    print('{} = {}'.format(num1, num2))\n",
    "elif num1 < num2:\n",
    "    print('{} < {}'.format(num1, num2))\n",
    "    \n",
    "# já o elif requer uma condição"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estruturas de loop e repetição\n",
    "<div id=\"loops\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora imagine que você queira realizar uma ação constantemente __enquanto__ a condição for verdadeira.\n",
    "\n",
    "Para isso, você pode utilizar as funções de loop do Python. Começando pela mais simples de todas (e com o nome mais intuitivo) o *while*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imagine que você quer printar o valor de um contador enquanto ele for menor que um certo limite\n",
    "# sendo esse contador acrescido de uma unidade após cada comparação\n",
    "# o if não atenderia sua demanda pois, do contrário, você teria que escrever vários if consecutivamente\n",
    "\n",
    "# printar o valor de count enquanto count < limit:\n",
    "\n",
    "count = 0\n",
    "limit = 10\n",
    "if count < limit:\n",
    "    count += 1\n",
    "else:\n",
    "    print(count)\n",
    "    \n",
    "if count < limit:\n",
    "    count += 1\n",
    "else:\n",
    "    print(count)\n",
    "    \n",
    "# ...\n",
    "# você já entendeu onde isso vai dar e, claramente, não é o mais eficiente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o while pode te ajudar com esse problema, veja como funciona a estrutura:\n",
    "\n",
    "count = 0\n",
    "limit = 10\n",
    "\n",
    "while count < limit:\n",
    "    count += 1\n",
    "print(count)\n",
    "\n",
    "# muito simples, né?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o while também aceita um condicional else\n",
    "\n",
    "count = 0\n",
    "limit = 10\n",
    "\n",
    "while count < limit:\n",
    "    print('Count ainda é menor que limit')\n",
    "    count += 1\n",
    "else:\n",
    "    print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# essa estrutura acima é chamada de while controlado por contador\n",
    "# nesse caso, a variável controlada também é usada na condição\n",
    "# mas existem outros tipos, por exemplo, while controlado por sentinela\n",
    "# nesse caso, a condição usa um valor \"sentinela\" definido para parar o loop\n",
    "\n",
    "sentinel = 'h'\n",
    "position = 0\n",
    "word = 'Python'\n",
    "letter = word[position]\n",
    "\n",
    "while letter != sentinel:\n",
    "    position += 1\n",
    "    letter = word[position]\n",
    "print('{0} está na posição {1} na palavra {2}'.format(sentinel, position, word))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# existem diversos outros tipos, mas não é nosso foco estudarmos isso\n",
    "# esses dois tipos já nos satisfazem bem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# existem alguns comandos úteis que podem ser usados em conjunto com o while\n",
    "# veja alguns destes\n",
    "\n",
    "# pass\n",
    "# este pode ser usado para pular uma etapa do while\n",
    "\n",
    "count = 0\n",
    "limit = 10\n",
    "\n",
    "while count < limit:\n",
    "    if count < 4:\n",
    "        pass\n",
    "    else:\n",
    "        print(count)\n",
    "    count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perceba que o pass não ignora o código fora do if\n",
    "\n",
    "count = 0\n",
    "limit = 10\n",
    "\n",
    "while count < limit:\n",
    "    if count < 4:\n",
    "        pass\n",
    "    print(count)\n",
    "    count += 1\n",
    "\n",
    "# mas existe um comando com uma utilidade parecida que o faz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# continue\n",
    "\n",
    "count = 0\n",
    "limit = 10\n",
    "\n",
    "while count < limit:\n",
    "    count += 1\n",
    "    if count < 4:\n",
    "        continue\n",
    "    print(count)\n",
    "    \n",
    "# perceba que o print, mesmo fora do if, foi ignorado\n",
    "# o continue literalmente pula essa etapa do while\n",
    "# se você não colocar a soma antes do continue, você iria ver que o while ficaria rodando infinitamente\n",
    "# uma vez que ele ignoraria essa ação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# break\n",
    "# este é um comando ainda mais radical uma vez que ele aborta o while, independente da condição superior\n",
    "\n",
    "count = 0\n",
    "limit = 10\n",
    "\n",
    "while count < limit:\n",
    "    if count == 4:\n",
    "        break\n",
    "    count += 1\n",
    "    print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existe uma estrutura de loop que substitui e while e é mais prático algumas vezes. Este é o *for*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o for é muito usado para ler listas, dicionários, sequências...\n",
    "# veja um exemplo\n",
    "\n",
    "carrinho = ['Machine Learning - Tom Mitchell', 'Deep Learning - Goodfellow et al', 'Hands-on Machine Learning - Aurelion Geron']\n",
    "\n",
    "for item in carrinho:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode ainda varrer as chaves ou valores de um dicionário\n",
    "\n",
    "carrinho = {'Machine Learning':{'autor':'Mitchell, Tom', 'publisher':'McGraw-Hill'},\n",
    "            'Deep Learning':{'autor':'Goodfellow et al', 'publisher':'MIT Press'},\n",
    "            'Hands-on Machine Learning':{'autor':'Geron, Aurelion', 'publisher':'OReilly Media'}}\n",
    "\n",
    "print('TÍTULOS DOS LIVROS')\n",
    "for title in carrinho.items():\n",
    "    print(title)\n",
    "    \n",
    "print('\\nAUTORES DOS LIVROS')\n",
    "for item in carrinho.values():\n",
    "    print(item['autor'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o for pode ser usado em combinação com o range\n",
    "# o range gera uma 'lista' de números inteiros\n",
    "# entre aspas pois o range NÃO é uma lista\n",
    "# ainda que possa ser transformado em uma\n",
    "\n",
    "print(type(range(10)))\n",
    "print(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o exemplo acima gera os 10 primeiros números inteiros a partir do zero\n",
    "\n",
    "for integer in range(10):\n",
    "    print(integer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o range recebe 3 argumentos:\n",
    "# range(start, stop, step)\n",
    "# se apenas um for passado, ele considera start=0 e step=1\n",
    "# veja um caso completo\n",
    "\n",
    "for integer in range(3,20,2):\n",
    "    print(integer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o step pode, inclusive, ser negativo\n",
    "# só atente que, nesse caso, stop < start\n",
    "\n",
    "for integer in range(10,0,-1):\n",
    "    print(integer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# os comandos pass, continue e break também se aplicam ao for\n",
    "# a usabilidade do for é parecida com a do while, entretanto ele é mais fácil de ser inicializado e mais prático\n",
    "# veja um exemplo de como ele pode ser mais prático\n",
    "# imagine que você queira ler os itens da lista usada no primeiro exemplo\n",
    "# veja como seria com while\n",
    "\n",
    "count = 0\n",
    "carrinho = ['Machine Learning - Tom Mitchell', 'Deep Learning - Goodfellow et al', 'Hands-on Machine Learning - Aurelion Geron']\n",
    "limit = len(carrinho)\n",
    "\n",
    "while count < limit:\n",
    "    print(carrinho[count])\n",
    "    count += 1\n",
    "    \n",
    "# esse é apenas um exemplo\n",
    "# se você se dedicar a esse caminho desafiador do machine learning, você com certeza topará em vários outros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funções\n",
    "<div id=\"funcoes\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagine agora que você desenvolva uma estrutura de código com tudo que você já aprendeu até aqui e deseje testar a mesma estrutura com diferentes variáveis. Você sempre pode copiar e colar o código e mudar aquilo que julgar melhor, mas existe um jeito ainda mais fácil: transformar aquele seu código em uma *função*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "em Python usamos o comando *def* para criar uma função\n",
    "\n",
    "```python\n",
    "def funcao(input1, input2, input3, ...):\n",
    "    codigo_aqui\n",
    "    return output\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# veja um exemplo\n",
    "\n",
    "def somar_dois_numeros(num1, num2):\n",
    "    soma = num1 + num2\n",
    "    return soma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "somar_dois_numeros(10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode até mesmo usar funções dentro de funções\n",
    "\n",
    "def soma(num1, num2):\n",
    "    return num1+num2\n",
    "\n",
    "def multiplicacao(num1, num2):\n",
    "    return num1*num2\n",
    "\n",
    "def subtracao(num1, num2):\n",
    "    return num1-num2\n",
    "\n",
    "def divisao(num1, num2):\n",
    "    if num2 == 0:\n",
    "        return 'Impossível dividir um número por zero!'\n",
    "    return num1/num2\n",
    "\n",
    "def fatoracao(num1):\n",
    "    if num1 < 0:\n",
    "        return 'Impossível fatorar números negativos! E não venha com suas teorias de doutorado de que é possível!'\n",
    "    else:\n",
    "        fat = 1\n",
    "        while num1 > 1:\n",
    "            fat *= num1\n",
    "            num1 -= 1\n",
    "        return fat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculadora(num1, symbol, num2=0):\n",
    "    \n",
    "    '''\n",
    "    Função que simula uma calculadora simples\n",
    "    - num1: input1\n",
    "    - num2: input2, opcional no caso de fatorial\n",
    "    - symbol: símbolo que representa a operação desejada\n",
    "        - '+' para soma\n",
    "        - '-' para subtração\n",
    "        - '*' para multiplicação\n",
    "        - '/' para divisão\n",
    "        - '!' para fatoração\n",
    "    '''\n",
    "    \n",
    "    if symbol == '+':\n",
    "        return soma(num1, num2=0)\n",
    "    elif symbol == '-':\n",
    "        return subtracao(num1, num2=0)\n",
    "    elif symbol == '*':\n",
    "        return multiplicacao(num1, num2=1)\n",
    "    elif symbol == '/':\n",
    "        return divisao(num1, num2=1)\n",
    "    elif symbol == '!':\n",
    "        return fatoracao(num1)\n",
    "    \n",
    "    return 'Cheque seus inputs!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# percebeu aquele imenso texto vermelho entre aspas simples?\n",
    "# isso se chama doc string\n",
    "# é uma string que explica o funcionamento de sua função, a documentação\n",
    "# é uma boa prática colocá-la sempre\n",
    "\n",
    "help(calculadora)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trabalhando com arquivos\n",
    "<div id=\"arquivos\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se você é um usuário frequente de computador (imagino que você seja) você possui na sua máquina vários arquivos (files). Eles são ótimos para acessar, armazenar e manipular dados. Você vai ver agora como fazer isso com Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ler arquivos\n",
    "# para ler o conteúdo de um arquivo precisamos primeiro abrí-lo\n",
    "\n",
    "# para abrir um arquivo você usará a função open\n",
    "# ela recebe dois argumentos: o caminho (path) para o arquivo e uma letra que indica o que será feito\n",
    "# r no caso significa read, w significa write, a significa append...\n",
    "# existe uma variedade de outros, recomendamos que leia a documentação para conhecer mais\n",
    "file = open('./data/demo_read_file.txt','r')\n",
    "texto = file.read()\n",
    "print(texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode ler quantos caracteres quiser\n",
    "\n",
    "texto = file.read(5)\n",
    "print(texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pera, o que aconteceu aqui?\n",
    "# você também obteve um monte de NADA?\n",
    "# isso acontece porque, quando você lê um arquivo, o cursor é posto no final do texto\n",
    "# se você abrir o arquivo novamente, o cursor volta pra posição zero\n",
    "\n",
    "file = open('./data/demo_read_file.txt','r')\n",
    "texto = file.read(5)\n",
    "print(texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode voltar para uma determinada posição usando o método seek()\n",
    "\n",
    "# nesse caso, estamos voltando à posição 0, o começo do arquivo\n",
    "file.seek(0,0)\n",
    "texto = file.read(6)\n",
    "print(texto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "se quiser entender mais sobre como ler arquivos, vale dar uma lida nesse <a href=\"https://www.w3schools.com/python/python_file_open.asp\" target=\"_blank\">link</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode ainda escrever em arquivos\n",
    "\n",
    "# antes de rodar essa célula!\n",
    "# verifique a pasta data e perceba que o arquivo demo_write_file.txt não existe\n",
    "# caso você já tenha rodado, tudo bem, apague esse arquivo e continue como se nada tivesse acontecido\n",
    "\n",
    "file = open('./data/demo_write_file.txt', 'w')\n",
    "texto = \"Hello! I'm the demo_write_file!\"\n",
    "file.write(texto)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# agora olhe a pasta novamente\n",
    "# viu que o arquivo foi criado?\n",
    "# isso é porque a tag 'w' cria um arquivo caso esse não exista\n",
    "# outra coisa que você deve notar é que eu usei agora um método .close()\n",
    "# isso porque o arquivo deve ser fechado após ser escrito"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# vamos ver o que você escreveu no arquivo agora!\n",
    "\n",
    "file = open('./data/demo_write_file.txt','r')\n",
    "texto = file.read()\n",
    "print(texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# atenção!\n",
    "# se você precisar acrescentar algo a seu arquivo não use a tag 'w' novamente\n",
    "# isso porque você irá SOBRESCREVER o que você escreveu antes\n",
    "\n",
    "file = open('./data/demo_write_file.txt', 'w')\n",
    "texto = \"Ops! Algo de errado aconteceu aqui...\"\n",
    "file.write(texto)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open('./data/demo_write_file.txt','r')\n",
    "texto = file.read()\n",
    "print(texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# se quiser acrescentar algo, use a tag 'a' para fazer append de algo\n",
    "# eu sei, eu sei\n",
    "# talvez você saiba que existem outras formas de fazer isso\n",
    "# mas não vem ao caso aqui\n",
    "\n",
    "file = open('./data/demo_write_file.txt', 'a')\n",
    "texto = \"\\nDa próxima vez use a tag 'a' para acrescentar algo!\"\n",
    "file.write(texto)\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open('./data/demo_write_file.txt','r')\n",
    "texto = file.read()\n",
    "print(texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# e não é só .txt que você pode manipular não\n",
    "# veja como poderíamos ler o arquivo housing.csv que você irá usar no projeto mais pra frente\n",
    "\n",
    "file = open('./data/housing.csv','r')\n",
    "conteudo = file.read()\n",
    "print(conteudo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bem desorganizado né?\n",
    "# isso tudo é um único texto\n",
    "# mas talvez seja útil separar esse texto em partes menores\n",
    "# as linhas talvez?\n",
    "\n",
    "# separando o texto pelo '\\n' que marca uma quebra de linha\n",
    "rows = conteudo.split('\\n')\n",
    "type(rows)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# agora você pode ver uma única linha\n",
    "rows[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "futuramente você vai aprender como tratar e visualizar esse tipo de arquivo de um jeito bem mais simples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programação Orientada a Objetos (POO)\n",
    "<div id=\"poo\"><div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um dos diferenciais de Python é que esta é uma língua orientada a objeto. Todos os tipos de variáveis estudadas até aqui são objetos (strings, floats...), com seus métodos e seus atributos. De agora em diante vamos ensiná-lo a criar seus próprios objetos, tipos de variáveis únicos.\n",
    "\n",
    "Programação Orientada a Objetos é só uma das formas de programação que existem. Se quiser entender mais sobre isso dá uma lida nesse <a href=\"https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_orientada_a_objetos\" target=\"_blank\">link</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# para declararmos um objeto usamos a expressão class\n",
    "\n",
    "class Filme():\n",
    "    \n",
    "    # a função init é sempre necessária, sim, tem esses '_' mesmo\n",
    "    def __init__(self):\n",
    "        # self é uma expressão que usamos para nos referirmos ao objeto criado\n",
    "        self.titulo = 'Toy Story'\n",
    "        self.diretor = 'John Lasseter'\n",
    "        print('Você acabou de criar um objeto da classe filme!')\n",
    "        \n",
    "    def imprimir_titulo_e_autor(self):\n",
    "        print('{0} é um filme dirigido por {1}'.format(self.titulo, self.diretor))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# agora, para criar um objeto desse tipo, basta chamarmos o objeto\n",
    "# da mesma forma que para criarmos uma lista podemos apenas invocar a classe list()\n",
    "\n",
    "filme = Filme()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode se perguntar qual o tipo dessa variável que criou, veja:\n",
    "\n",
    "type(filme)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode estar se perguntando de que serve aquele self.titulo, aquela função que imprime os dados...\n",
    "# pois bem, agora você vai entender a diferença entre um atributo e um método"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# de maneira bem simples, atributos são propriedades (características) de um objeto\n",
    "# já os métodos são as ações que estes objetos podem fazer\n",
    "\n",
    "# atributos são convocados da seguinte forma:\n",
    "print(filme.titulo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# já os métodos são de uma maneira bem parecida, mas você precisa acrescentar () ao fim\n",
    "filme.imprimir_titulo_e_autor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# caso não tenha ficado claro, imagine que gato fosse um objeto\n",
    "# atributos seriam coisas como tamanho, raça, cor, nome...\n",
    "# já os métodos seriam coisas como miar, caçar passarinho ou dormir em cima do teclado do seu dono"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# legal né?\n",
    "# mas você pode ter percebido que aquela classe não é bem uma classe filme que possa representar qualquer filme\n",
    "# está mais para uma classe Filme_do_Toy_Story\n",
    "# você pode trocar os atributos da sua classe\n",
    "\n",
    "filme.titulo = 'Rio'\n",
    "filme.diretor = 'Carlos Saldanha'\n",
    "filme.imprimir_titulo_e_autor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mas existe um jeito de inicializar o objeto já com os atributos desejados\n",
    "# veja como deveriamos ter construído a classe nesse caso\n",
    "\n",
    "class Filme():\n",
    "    def __init__(self, titulo, diretor):\n",
    "        self.titulo = titulo\n",
    "        self.diretor = diretor\n",
    "        print('Você acabou de criar um objeto da classe filme!')\n",
    "        \n",
    "    def imprimir_titulo_e_autor(self):\n",
    "        print('{0} é um filme dirigido por {1}'.format(self.titulo, self.diretor))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Você acabou de criar um objeto da classe filme!\n",
      "Você acabou de criar um objeto da classe filme!\n"
     ]
    }
   ],
   "source": [
    "filme1 = Filme('Seila','Naosei')\n",
    "filme2 = Filme('Tantofaz','Deixa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Tantofaz', 'Deixa')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string1 = 'Seila'\n",
    "string2 = 'Tantofaz'\n",
    "string1 = string2\n",
    "string2 = 'Deixa'\n",
    "string1, string2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Nadademais', 'Nadademais')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filme1 = filme2\n",
    "filme1.titulo = 'Qualquercoisa'\n",
    "filme2.titulo = 'Nadademais'\n",
    "filme1.titulo, filme2.titulo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# veja agora:\n",
    "filme = Filme('Os Incríveis','Brad Bird')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filme.imprimir_titulo_e_autor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# uma vantagem desse tipo de programação é a capacidade de que uma classe herde atributos de outra\n",
    "# por exemplo, imagine que você deseje criar uma classe para cachorros e outra classe para gatos\n",
    "# mas você deve concordar que estes objetos compartilham de diversos métodos\n",
    "# por exemplo comer, correr, morder sua perna... vários\n",
    "# enquanto outros são bem particulares: latir, miar...\n",
    "# para isso podemos criar uma super-classe e, a partir desta, criar outras sub-classes que herdem atributos dessa\n",
    "# veja como fazer isso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando a super-classe\n",
    "\n",
    "class Animal():\n",
    "    \n",
    "    def __init__(self, tamanho, peso):\n",
    "        self.tamanho = tamanho\n",
    "        self.peso = peso\n",
    "        \n",
    "    def comer(self):\n",
    "        print('Comendo...')\n",
    "        \n",
    "    def dormir(self):\n",
    "        print('zzz...')\n",
    "        \n",
    "# nossa super-classe é a classe animal\n",
    "# nela colocamos atributos e métodos comuns à maioria dos animais"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando sub-classe\n",
    "\n",
    "class Gato(Animal):\n",
    "    \n",
    "    def __init__(self, tamanho, peso):\n",
    "        # tamanho em cm\n",
    "        # peso em kg\n",
    "        Animal.__init__(self, tamanho, peso)\n",
    "        print('Gato criado!')\n",
    "        \n",
    "    def miar(self):\n",
    "        print('Seu gato está miando! Pode ser fome...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criamos agora um objeto Gato\n",
    "\n",
    "tiberius = Gato()\n",
    "# \"Tiberius é o nome do meu gato\" - Caio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# viram que, apesar de Gato não necessitar do atributo tamanho e peso você obteve um erro?\n",
    "# isso porque gatos são animais (pelo menos o meu é) e Animal necessita desses dois atributos\n",
    "\n",
    "tiberius = Gato(27, 4.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# agora convoque um método da sub-classe gato\n",
    "\n",
    "tiberius.miar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perceba que, como Gato recebe Animal como parâmetros, ele também possui os métodos desse\n",
    "\n",
    "tiberius.dormir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# esse é o conceito de herdar características de outra classe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pacotes úteis\n",
    "<div id=\"pydata\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ensinar agora alguns pacotes úteis de Python. Com estes você já será totalmente capaz de resolver o desafio que vamos te passar.\n",
    "\n",
    "Nós vamos apenas raspar a casca desse mundo de pacotes de data science, sempre consulte a documentação!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essa é uma library poderosa para lidar com arrays (vetores) n-dimensionais de uma maneira mais eficiente. A título de curiosidade, essa biblioteca é usada não só para machine learning, mas em áreas como química, biologia, computação quântica... ela foi usada até para produzir aquela imagem que você viu um tempo atrás do primeiro buraco negro \"fotografado\".\n",
    "\n",
    "Vamos aprender um pouco sobre ela aqui, mas atenção, isso não substitui (nem chega perto de substituir) a documentação do pacote que você pode achar <a href=\"https://numpy.org/\" target=\"_blank\">aqui</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# para importar um módulo você precisa instalá-lo através do pip\n",
    "# você possivelmente já tem esse pacote, mas você pode rodar essa célula se não tiver\n",
    "\n",
    "!pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# para usar o pacote, você deve importá-lo\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode ainda importar um único método ou função de um pacote\n",
    "\n",
    "from numpy import arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o atributo __version__ indica a versão do pacote\n",
    "\n",
    "np.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# vamos ver como criar um array\n",
    "# você pode sempre usar a função help() para entender como funciona uma função\n",
    "\n",
    "help(np.array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você também pode posicionar o cursor no método ou atributo que deseja consultar e apertar shift+tab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o método array() gera um array de uma lista do Python\n",
    "\n",
    "array = np.array([1,2,3])\n",
    "array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o atributo dtype devolve o tipo das variáveis armazenadas no array\n",
    "\n",
    "array.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# vamos consultar o tipo do array que criamos\n",
    "\n",
    "type(array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o atributo shape devolve o tamanho do array\n",
    "# a ausência de um número após a vírgula significa 1\n",
    "array.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# existem métodos muito úteis para gerar arrays automaticamente\n",
    "\n",
    "# o método arange gera um array dentro de uma determinada range\n",
    "np.arange(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o método reshape é útil para auterar a forma desse array\n",
    "\n",
    "np.arange(10).reshape(2,5)\n",
    "\n",
    "# duas linhas, cinco colunas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode ainda gerar um array de zeros ou de uns\n",
    "# precisando especificar apenas o shape\n",
    "\n",
    "np.zeros((5,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perceba que o shape pode ter quantas entradas você quiser\n",
    "\n",
    "# uma \"stack\" de quatro matrizes, com 4 linhas e 2 colunas\n",
    "# é como se fosse um paralelepipedo de 4x4x2\n",
    "np.ones((4,4,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o método linspace(i,f,n) cria uma quantidade de n números num intervalo de i a f igualmente espaçados\n",
    "\n",
    "np.linspace(0,1,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# uma coisa importante de saber é que você pode aplicar uma mesma função a um array de elementos\n",
    "\n",
    "from numpy import pi\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.linspace(0, 2*pi, 100)\n",
    "f_x = np.sin(x)\n",
    "\n",
    "plt.plot(x,f_x)\n",
    "plt.show()\n",
    "\n",
    "# relaxa que você vai aprender a plotar gráficos mais pra frente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# também é possível aplicar uma mesma operação a todos os elementos de um array\n",
    "\n",
    "10*np.arange(1,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(5) - 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5<np.arange(3,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o elemento array do numpy também possui várias operações únicas\n",
    "\n",
    "array1 = np.array([1,1,0,1]).reshape(2,2)\n",
    "array2 = np.array([2,0,3,4]).reshape(2,2)\n",
    "\n",
    "# produto de elemento por elemento:\n",
    "print(\"produto de elemento por elemento\")\n",
    "print(array1*array2)\n",
    "\n",
    "# produto matricial\n",
    "print(\"\\nproduto matricial\")\n",
    "print(array1@array2)\n",
    "\n",
    "# ou você pode usar o método dot\n",
    "print(\"\\ntambém produto matricial mas usando método dot\")\n",
    "print(array1.dot(array2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você também pode usar vários métodos de listas aqui\n",
    "# mas vamos ver alguns métodos úteis de np.array\n",
    "\n",
    "array = np.arange(10)\n",
    "print('Média: {}\\n'.format(array.mean()))\n",
    "print('Mínimo: {}\\n'.format(array.min()))\n",
    "print('Máximo: {}\\n'.format(array.max()))\n",
    "print('Soma: {}\\n'.format(array.sum()))\n",
    "print('Desvio Padrão: {}\\n'.format(array.std()))\n",
    "print('Soma cumulativa: {}\\n'.format(array.cumsum()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# como dito, numpy é muito útil para lidar com arrays n-dimensionais\n",
    "# isso inclui matrizes\n",
    "# portanto numpy possui vários atributos úteis para essa estrutura, como transposição\n",
    "\n",
    "array = np.arange(15).reshape(3,5)\n",
    "print(array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o atributo T devolve a transposta da matriz\n",
    "\n",
    "array.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o atributo linalg do numpy possui vários métodos úteis\n",
    "\n",
    "# calcular a inversa\n",
    "array = np.arange(1,5).reshape(2,2)\n",
    "np.linalg.inv(array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# e até um método para solucionar equações lineares\n",
    "\n",
    "y = np.array([5,7]).reshape(2,1)\n",
    "np.linalg.solve(array,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# enfim, uma infinidade de funções, métodos, atributos...\n",
    "# por enquanto é isso, você pode achar muito mais, se necessário, na documentação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você pode ter notado que a apresentação do arquivo CSV que abrimos anteriormente não é das mais bonitas e eu lhe garanto que também não é das mais fáceis de trabalhar. Para isso existe uma library muito prática e com diversas funções que tornam a análise de dados e arquivos muito mais prático.\n",
    "\n",
    "De novo, dê uma lida na <a href=\"https://pandas.pydata.org/\" target=\"_blank\">documentação</a>!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rode essa célula caso você não possua a library\n",
    "\n",
    "!pip install pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importe a library e confira a versão\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "pd.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o grande diferencial do pandas está no seu objeto Series\n",
    "# que possui uma série de atributos e métodos para processar dados\n",
    "\n",
    "series = pd.Series([1,2,3,np.nan,5,6])\n",
    "series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o elemento NaN ou np.nan representa a ausência de um valor\n",
    "# cuidado! ele é diferente de um objeto null ou None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# como sempre, vamos conferir o tipo de series\n",
    "\n",
    "type(series)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# com Pandas você criar uma ainda objetos do tipo DatetimeIndex\n",
    "# muito útil para trabalhar com séries temporais\n",
    "\n",
    "dates = pd.date_range('20200101', periods=9)\n",
    "dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(dates)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tá bom, mas você pode estar pensando\n",
    "# \"que saco, que saco, numpy já não fazia isso?\"\n",
    "# mas é aqui que entra um diferencial do Pandas em relação ao Numpy\n",
    "# com pandas você pode unir duas ou mais séries e formar um DataFrame\n",
    "# DataFrames são estruturas ótimas para lidar com tabelas e bases de dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = pd.DataFrame(np.arange(5), index=['a','b','c','d','e'])\n",
    "dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(dataframe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# e isso seria só arranhar a superfície, você pode criar dataframes ainda mais complexos\n",
    "\n",
    "df = pd.DataFrame({'Coluna 1':pd.date_range('20200101', periods=9),\n",
    "                   'Coluna 2':np.arange(9),\n",
    "                   'Coluna 3':'foo'})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode conferir o tipo de cada coluna\n",
    "\n",
    "df.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plotar apenas uma ou mais colunas\n",
    "\n",
    "df['Coluna 1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# e inclusive conferir o nome das colunas do dataframe\n",
    "\n",
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# só pro caso de eu ainda não ter convencido você\n",
    "# olha como fica o arquivo csv que tinhamos lido antes\n",
    "\n",
    "df = pd.read_csv('./data/housing.csv')\n",
    "type(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# para visualizar só algunas linhas do dataframe\n",
    "# é útil usar métodos como head(n) ou tail(n)\n",
    "# head devolve as n primeiras linhas\n",
    "# tail devolve as n últimas linhas\n",
    "# se não for passado n, o valor default será 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# muito melhor apresentado, não acha?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# um dataframe possui vários atributos e métodos em comuns com os arrays que vimos\n",
    "# olha só alguns\n",
    "\n",
    "# shape\n",
    "df.shape\n",
    "\n",
    "# 20640 linhas e 10 colunas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# média, desvio padrão, máximo...\n",
    "\n",
    "print('MÉDIA')\n",
    "print(df.mean())\n",
    "\n",
    "print('\\nDESVIO PADRÃO')\n",
    "print(df.std())\n",
    "\n",
    "print('\\nE por aí vai...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mas existe um método que te volve todos esses valores e mais alguns\n",
    "# é o método describe\n",
    "\n",
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o atribulo loc é muito útil para filtrar colunas ou linhas\n",
    "\n",
    "# df.loc[linhas, colunas] ou \":\" se quiser ler todas as linhas ou colunas\n",
    "df.loc[10:15, ['longitude','latitude']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# caso você não conheça o nome da coluna ou linha\n",
    "# você pode filtrar por posição usando iloc\n",
    "\n",
    "df.iloc[300:305, 4:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode ainda passar uma condição ao dataframe\n",
    "\n",
    "# filtrando apenas as linhas onde o valor da coluna population for maior que 1000\n",
    "df[df['population'] > 1000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode, ainda, fazer uma cópia de um dataframe\n",
    "# é muito útil para não passar modificações direto no dataframe\n",
    "\n",
    "df_copy = df.copy()\n",
    "df_copy.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# e falando sobre passar modificações num dataframe\n",
    "# o método apply é muito útil para aplicar funções em uma ou mais colunas de um dataframe\n",
    "\n",
    "df_copy['population'].apply(lambda x: x**2)\n",
    "# nesse caso, para cada elemento da coluna, calculamos o valor desse ao quadrado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# e falando em operações, você pode criar novas séries a partir de operações com as colunas do dataframe\n",
    "\n",
    "df['total_bedrooms']/df['total_rooms']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o resultado também é uma série e, portanto, você pode atribuir a uma nova coluna\n",
    "\n",
    "df['razao_AreaQuarto_AreaTotal'] = df['total_bedrooms']/df['total_rooms']\n",
    "df.head()\n",
    "\n",
    "# veja lá no fim a nova coluna criada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o método value_counts devolve o número de aparições de cada elemento de uma coluna\n",
    "\n",
    "df['ocean_proximity'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# se você passar True pelo método, é possível conseguir a frequência relativa\n",
    "# número de aparições/total de linhas\n",
    "\n",
    "df['ocean_proximity'].value_counts(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ainda é possível plotar uma variável numérica usando o método plot()\n",
    "\n",
    "df.head(50)['population'].plot(figsize=(15,8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ou plotar uma variável por outra\n",
    "\n",
    "df.plot.scatter(x='latitude',y='longitude',alpha=0.3,figsize=(12,12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O que você vê acima é uma tentativa (mais ou menos bem executada) de plotar um mapa da Califórnia (de onde foi tirado os dados do dataset) através dos valores de latitude e longitura.\n",
    "\n",
    "Bom, podemos fazer um trabalho bem melhor. E vamos, depois de vermos próxima e última parte do tutorial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como de praxe, não deixe de consultar a <a href=\"https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.html\" target=\"_blank\">documentação</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bom, nós não vamos bem aprender sobre matplolib\n",
    "# mas sobre pyplot, uma subcoleção de funções do matplotlib para platar gráficos\n",
    "# de novo, caso não possua a library, rode essa célula\n",
    "\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o conceito é bem simples\n",
    "# você plota um gráfico através do método plot\n",
    "# personalizado da maneira que preferir\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plotando um gráfico simples\n",
    "\n",
    "x = np.linspace(0, 2*np.pi, 100)\n",
    "y = np.sin(x)\n",
    "plt.plot(x,y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# você pode ainda plotar mais de uma figura no mesmo gráfico\n",
    "y1 = np.cos(x)\n",
    "y2 = np.tan(x)\n",
    "plt.plot(x,y)\n",
    "plt.plot(x,y1)\n",
    "plt.plot(x,y2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# meio difícil de ver, né?\n",
    "# vamos usar o parametro figsize para ajeitarmos isso\n",
    "\n",
    "fig = plt.figure(figsize=(20,15))\n",
    "plt.plot(x,y)\n",
    "plt.plot(x,y1)\n",
    "plt.plot(x,y2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# é, não tá bom ainda\n",
    "# mas é claro, pois a função tangente explode para infinito em alguns pontos\n",
    "# sendo assim, vamos limitar o intervalo mostrado nos eixos\n",
    "\n",
    "plt.ylim((-1.5,1.5))\n",
    "plt.plot(x,y)\n",
    "plt.plot(x,y1)\n",
    "plt.plot(x,y2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tá, desisto\n",
    "# melhor só tirar o tangente e plotar separado mesmo kkk\n",
    "# mas você aprendeu várias coisas com essa nossa tentativa!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a propósito, também é possível plotar tipos diferentes de gráfico\n",
    "\n",
    "x = np.arange(20)\n",
    "y = x**2\n",
    "plt.scatter(x,y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# também é possível maquiar seu gráfico colocando legendas ou mudando a cor\n",
    "\n",
    "plt.scatter(x,y,color='red')\n",
    "plt.xlabel('eixo X')\n",
    "plt.ylabel('eixo Y')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ou gráficos de barra\n",
    "\n",
    "values = df['ocean_proximity'].value_counts(True)\n",
    "values.plot.bar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# enfim, uma infinidade de parametros e atributos\n",
    "# com isso, é possível criar gráficos como esse\n",
    "\n",
    "df.plot(kind=\"scatter\", x=\"longitude\", y=\"latitude\", alpha=0.4,\n",
    "    s=df[\"population\"]/100, label=\"population\", figsize=(10,7),\n",
    "    c=\"median_house_value\", cmap=plt.get_cmap(\"jet\"), colorbar=True,\n",
    "    sharex=False)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mas relaxa, por enquanto você não precisa fazer algo como isso"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com isso acabamos o tutorial!\n",
    "\n",
    "Boa sorte no projeto! Estamos esperando por você na segunda fase!"
   ]
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}