Python 9 - Numpy e Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy e Pandas\n",
    "  \n",
    "  \n",
    "## Numpy\n",
    "Numpy é um biblioteca do Python que nos permite trabalhar com vetores, matrizes e tensores de forma geral (_arrays_) de forma mais eficiente que as ferramentas nativas da linguagem que usa listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#importando biblioteca\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Criando um array usando a biblioteca Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Criando lista e a convertendo para o formato \"Numpy array\"\n",
    "x=np.array([1,2])\n",
    "print(x)\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando trabalhamos com vetores e matrizes no Python com funções nativas, usamos o conceito de listas e isso significa que o processo por trás é diferente do caso em usamos o conceito de _array_ do pacote Numpy, por exemplo. Geralmente, quando optamos por trabalhar com _arrays_ ao invés de listas, os processos ficam mais rápidos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista:  [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "3.84 µs ± 109 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "#comparando \n",
    "lista =[1,2,3,4,5,6,7,8,9]\n",
    "array=np.arange(10) # função arange(Limite_inferior,Limite_Superior,passo), \n",
    "                    # funciona igual o range normal do python\n",
    "\n",
    "print(\"Lista: \",lista)\n",
    "#tempo de execução do comando\n",
    "quadradoL=None\n",
    "%timeit quadradoL = [el**2 for el in lista] #elevar todos elementos ao quadrado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array:  [0 1 2 3 4 5 6 7 8 9]\n",
      "794 ns ± 71.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"Array: \",array)\n",
    "#tempo de execução do comando\n",
    "quadradoA=None\n",
    "%timeit quadradoA = array**2  #elevar todos elementos ao quadrado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A diferença pode parecer pequena, mas quando passamos a trabalhar com processos mais complexos, essa diferença passa a crescer exponencialmente. Por conta comodidade (tempo de execução e funções) de se trabalhar com o pacote Numpy, vamos usá-lo daqui para frente. Agora iremos conhecer alguns métodos do pacote para podermos utilizá-lo da melhor maneira."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primeiramente, vamos aprender a inicializar um _array_ de diversas maneiras com as funções do Numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array unidimensional: \n",
      "[1 2 3] \n",
      "\n",
      "Array Bidimensional(matriz): \n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "#inicializando um array\n",
    "\n",
    "#array unidimensional (vetor)\n",
    "arrayU=np.array([1,2,3])\n",
    "print(\"Array unidimensional: \")\n",
    "print(arrayU,'\\n')\n",
    "\n",
    "#array bidimensional(matriz)\n",
    "arrayB=np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print(\"Array Bidimensional(matriz): \")\n",
    "print(arrayB,'\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos criar _arrays_ apenas com zeros com o método np.zeros(). No argumento do método colocamos o formato que o _array_ assumirá:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array de zeros:  [0. 0. 0.]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "numpy.float64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#podemos criar um array apenas com zeros\n",
    "arrayZeros = np.zeros(3)\n",
    "print(\"Array de zeros: \",arrayZeros)\n",
    "\n",
    "#Automaticamente, a função faz com que os números sejam do tipo float\n",
    "type(arrayZeros[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array de zeros Inteiros:  [0 0 0]\n"
     ]
    }
   ],
   "source": [
    "#basta fazer o seguinte para mudar o tipo da variável\n",
    "arrayZeros = np.zeros(3,dtype=int)\n",
    "print(\"Array de zeros Inteiros: \",arrayZeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos criar também _arrays_ de números 1 com o método np.ones() e _arrays_ vazios com o método np.empty():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array de 1: \n",
      "[[1. 1.]\n",
      " [1. 1.]\n",
      " [1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "#Array de 1s\n",
    "arrayOne = np.ones([3,2])\n",
    "print(\"array de 1: \")\n",
    "print(arrayOne)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array vazio: \n",
      "[0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "#Array vazio\n",
    "arrayEmpty= np.empty(3) #inicializa com o endereço de memória da variável\n",
    "print(\"array vazio: \")\n",
    "print(arrayEmpty)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos criar uma matriz identidade facilmente com np.identity() ou np.eye():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0.]\n",
      " [0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "#Matriz identidade\n",
    "MatrizIdentidade = np.eye(2) # argumento vai quantidade de 1 que queremos\n",
    "print(MatrizIdentidade)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também criar uma matriz diagonal com o método np.diag:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matriz Diagonal:\n",
      "[[1 0 0 0]\n",
      " [0 2 0 0]\n",
      " [0 0 3 0]\n",
      " [0 0 0 4]]\n"
     ]
    }
   ],
   "source": [
    "MatrizDiag= np.diag([1,2,3,4])\n",
    "print(\"Matriz Diagonal:\")\n",
    "print(MatrizDiag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outro comando interessante é o np.linspace(). Com ele nós podemos definir pontos de corte equidistantes em um intervalo númerico, podendo escolher em quantas vezes queremos dividí-lo. O Numpy retorna um _array_ com os pontos de corte:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array Intervalo:  [0.   0.25 0.5  0.75 1.  ]\n"
     ]
    }
   ],
   "source": [
    "#criando intervalo (dividino [0,1] em 5 pontos)\n",
    "arrayIntervalo = np.linspace(0,1,5)\n",
    "print(\"Array Intervalo: \",arrayIntervalo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também modificar um _array_ já criado mudando seu formato (shape)  como for necessário. Usar método np.shape():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array com formato inicial:  [1 2 3 4]\n",
      "Dimensões do array:  (4,)\n"
     ]
    }
   ],
   "source": [
    "#criando um array normal\n",
    "arrayShape = np.array([1,2,3,4])\n",
    "print(\"Array com formato inicial: \",arrayShape)\n",
    "print(\"Dimensões do array: \",arrayShape.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array modificado: \n",
      "[[1 2]\n",
      " [3 4]]\n",
      "Dimensões do array:  (2, 2)\n"
     ]
    }
   ],
   "source": [
    "#modificando\n",
    "arrayShape.shape =(2,2)\n",
    "print(\"Array modificado: \")\n",
    "print(arrayShape)\n",
    "print(\"Dimensões do array: \",arrayShape.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array modificado: \n",
      "[[1]\n",
      " [2]\n",
      " [3]\n",
      " [4]]\n",
      "Dimensões do array:  (4, 1)\n"
     ]
    }
   ],
   "source": [
    "#modificando\n",
    "arrayShape.shape =(4,1)\n",
    "print(\"Array modificado: \")\n",
    "print(arrayShape)\n",
    "print(\"Dimensões do array: \",arrayShape.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É possível também realizar cortes de diversas maneiras no _array_ unidimensional. Agora estudaremos como fazer isso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array inicial:  [1 2 3 4 5 6 7 8 9]\n",
      "Array ao contrário:  [9 8 7 6 5 4 3 2 1]\n",
      "Array do meio pra frente:  [6 7 8 9]\n",
      "Array cortado compassado  [3 5 7]\n"
     ]
    }
   ],
   "source": [
    "#vamos criar array\n",
    "arrayCortes = np.arange(1,10)\n",
    "\n",
    "#podemos printar o array inteiro com [:]\n",
    "print(\"Array inicial: \",arrayCortes[:])\n",
    "\n",
    "#podemos printar o array ao contrário com [::-1]\n",
    "print(\"Array ao contrário: \",arrayCortes[::-1])\n",
    "\n",
    "#podemos cortar do meio pra frente\n",
    "print(\"Array do meio pra frente: \",arrayCortes[5:])\n",
    "\n",
    "#podemos criar um espaço pra cortar e o intervalo de cada corte\n",
    "print(\"Array cortado compassado \",arrayCortes[2:7:2]) # no espaço entre os index 2 e 7, \n",
    "                                                      #pegamos de 2 em 2 números\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O mesmo vale para matrizes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matriz inicial: \n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "#criando matriz bidimensional\n",
    "arrayCortes.shape= (3,3)\n",
    "print(\"Matriz inicial: \")\n",
    "print(arrayCortes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matriz Coluna: \n",
      "[2 5 8]\n"
     ]
    }
   ],
   "source": [
    "#podemos imprimir só uma coluna específica\n",
    "print(\"Matriz Coluna: \")\n",
    "print(arrayCortes[:,1]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matriz Linha: \n",
      "[4 5 6]\n"
     ]
    }
   ],
   "source": [
    "#ou uma linha específica\n",
    "print(\"Matriz Linha: \")\n",
    "print(arrayCortes[1,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matriz pedaço: \n",
      "[[5 6]\n",
      " [8 9]]\n"
     ]
    }
   ],
   "source": [
    "#até mesmo um pedaço da matriz\n",
    "print(\"Matriz pedaço: \")\n",
    "print(arrayCortes[1:,1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar esses comandos para substituir valores em um _array_ com mais facilidade:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matriz Novos valores: \n",
      "[[ 1  2  3]\n",
      " [ 4 99 99]\n",
      " [ 7 99 99]]\n"
     ]
    }
   ],
   "source": [
    "#mudando valores da matriz\n",
    "arrayCortes[1:,1:]=99\n",
    "print(\"Matriz Novos valores: \")\n",
    "print(arrayCortes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora vamos ver alguns métodos matemáticos do Numpy:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array Inicial:  [1 0 3 6 2 1 7 5 2]\n"
     ]
    }
   ],
   "source": [
    "#Criando array\n",
    "A = np.array([1,0,3,6,2,1,7,5,2])\n",
    "print(\"Array Inicial: \",A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array ordenado:  [0 1 1 2 2 3 5 6 7]\n"
     ]
    }
   ],
   "source": [
    "#Ordenando o array\n",
    "A.sort()\n",
    "print(\"Array ordenado: \",A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array somado:  27\n"
     ]
    }
   ],
   "source": [
    "#Soma elementos do array\n",
    "print(\"Array somado: \",A.sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array somado:  3.0\n"
     ]
    }
   ],
   "source": [
    "#Média dos elementos do array\n",
    "print(\"Array somado: \",A.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array maior elemento:  7\n"
     ]
    }
   ],
   "source": [
    "#Maior elemento\n",
    "print(\"Array maior elemento: \",A.max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variância:  5.333333333333333\n"
     ]
    }
   ],
   "source": [
    "#Variância \n",
    "print(\"Variância: \",A.var())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Desvio-Padrão:  2.581988897471611\n"
     ]
    }
   ],
   "source": [
    "#Desvio-Padrão\n",
    "print(\"Desvio-Padrão: \",A.std())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transposta: \n",
      "[[0 2 5]\n",
      " [1 2 6]\n",
      " [1 3 7]]\n"
     ]
    }
   ],
   "source": [
    "#Transposta de um matriz\n",
    "A.shape =(3,3)\n",
    "print(\"Transposta: \")\n",
    "print(A.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Determinante: \n",
      "3.0000000000000004\n"
     ]
    }
   ],
   "source": [
    "#Determinante\n",
    "print(\"Determinante: \")\n",
    "print(np.linalg.det(A) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inversa: \n",
      "[[-1.33333333 -0.33333333  0.33333333]\n",
      " [ 0.33333333 -1.66666667  0.66666667]\n",
      " [ 0.66666667  1.66666667 -0.66666667]]\n"
     ]
    }
   ],
   "source": [
    "#Matriz Inversa\n",
    "print(\"Inversa: \")\n",
    "print(np.linalg.inv(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos realizar operações algébricas de maneira muito simples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array A:  [1 2 3 4]\n",
      "Array B:  [5 6 7 8]\n",
      "Array A - soma:  [11 12 13 14]\n",
      "Array B - multiplicação:  [50 60 70 80]\n",
      "Divisao Array A pelo B:  [0.2        0.33333333 0.42857143 0.5       ]\n"
     ]
    }
   ],
   "source": [
    "#Vamos criar arrays\n",
    "a = np.array([1,2,3,4])\n",
    "b=np.array([5,6,7,8])\n",
    "\n",
    "print(\"Array A: \",a)\n",
    "print(\"Array B: \",b)\n",
    "\n",
    "#Soma\n",
    "print(\"Array A - soma: \",a+10)\n",
    "\n",
    "#Multiplicação\n",
    "print(\"Array B - multiplicação: \",b*10)\n",
    "\n",
    "#Inclusive entre eles\n",
    "print(\"Divisao Array A pelo B: \",a/b) #elemento por elemento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com matrizes (_array_ bidimensional) é a mesma coisa, com exceção da multiplicação - a veremos agora. Primeiramente, lembremos que para multiplicar duas matrizes (A e B) o número de colunas da matriz A tem que ser iqual ao número de linhas da Coluna B:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matriz A: \n",
      "[[1 2]\n",
      " [3 4]] \n",
      "\n",
      "Matriz B: \n",
      "[[5 6]\n",
      " [7 8]] \n",
      "\n",
      "Matriz A X B : \n",
      "[[19 22]\n",
      " [43 50]] \n",
      "\n",
      "Array [2,3] x A : \n",
      "[11 16]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([1,2,3,4])\n",
    "B=np.array([5,6,7,8])\n",
    "\n",
    "A.shape=(2,2)\n",
    "B.shape=(2,2)\n",
    "\n",
    "print(\"Matriz A: \")\n",
    "print(A, \"\\n\")\n",
    "\n",
    "print(\"Matriz B: \")\n",
    "print(B, \"\\n\")\n",
    "\n",
    "#Matriz A X B\n",
    "print(\"Matriz A X B : \")\n",
    "print(A @ B, \"\\n\")\n",
    "\n",
    "#Array X matriz\n",
    "print(\"Array [2,3] x A : \")\n",
    "print( [2,3] @ A)\n",
    "\n",
    "#Na aula de Álgebra Linear apresentaremos outra maneira de se realizar\n",
    "#a multiplicação de matrizes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos copiar um array com a função np.copyto():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array Original:  [1 2 3]\n",
      "Array Copia:  [1 2 3]\n"
     ]
    }
   ],
   "source": [
    "#Criando array original\n",
    "Original = np.array ([1,2,3])\n",
    "print( \"Array Original: \",Original)\n",
    "\n",
    "#Fazendo copiar\n",
    "Copia = np.empty_like(Original) # cria array vazio na mesma forma do Original\n",
    "np.copyto(Copia,Original)\n",
    "\n",
    "print( \"Array Copia: \", Copia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos realizar comparações entre elementos dos _arrays_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array A:  [1 2 3 4]\n",
      "Array B:  [5 2 7 8]\n",
      "Comparação entre A e B:  [False  True False False]\n",
      "Elemento do array B > 6:  [False False  True  True]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3,4])\n",
    "b=np.array([5,2,7,8])\n",
    "\n",
    "print(\"Array A: \",a)\n",
    "print(\"Array B: \",b)\n",
    "\n",
    "#entre os proprios array\n",
    "print(\"Comparação entre A e B: \", a==b)\n",
    "\n",
    "# do array entre algum numero\n",
    "print(\"Elemento do array B > 6: \",b>6 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercícios\n",
    "\n",
    "1- Refaça alguns exercícios feito anteriormente com lista usando o Numpy e compare o tempo de execução.\n",
    "\n",
    "2- Crie uma array com 9 entradas, transforme-o em uma matriz 3x3 e faça os exercícios abaixo com ela.\n",
    "\n",
    "3- Faça a Multiplicação de uma matriz 3x3 sem utilizar a função de multiplicações de matrizes da Numpy.\n",
    "\n",
    "4- Faça a transposta de uma matriz sem utilizar a função de transposta da Numpy.\n",
    "\n",
    "5- Ache a inversa de uma Matriz 3x3 sem utilizar a função da inversa da Numpy.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Pandas\n",
    "\n",
    "Conheceremos agora uma das bibliotecas mais importantes e mais usadas para fazer a análise de dados no Python - o Pandas. O Pandas oferece diversas funções que facilitam a manipulação e visualização dos dados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Importando a biblioteca\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como dito anteriormente, o Pandas facilita a visualização de dados por causa da estrutura que ele é capaz de comportar as bases de daods - essa estrutura é chamada de DataFrame. Vamos criar um dicionário e depois transformá-lo em DataFrame para vermos sua estrutura:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     Capital           País  População    Área\n",
      "0   Brasília         Brasil      200.4   8.516\n",
      "1     Moscou         Rússia      143.5  17.100\n",
      "2  Nova Deli          Índia     1252.0   3.286\n",
      "3     Pequim          China     1357.0   9.597\n",
      "4   Pretória  África do Sul       52.9   1.221\n"
     ]
    }
   ],
   "source": [
    "dicionario =  {\"País\": [\"Brasil\", \"Rússia\", \"Índia\", \"China\", \"África do Sul\"],\n",
    "       \"Capital\": [\"Brasília\", \"Moscou\", \"Nova Deli\", \"Pequim\", \"Pretória\"],\n",
    "       \"Área\": [8.516, 17.10, 3.286, 9.597, 1.221],\n",
    "       \"População\": [200.4, 143.5, 1252, 1357, 52.9]}\n",
    "               \n",
    "Brics = pd.DataFrame(dicionario)\n",
    "print(Brics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Devido a um _bug_ do Pandas, ele pode mudar a ordem das colunas. Vamos consertar isso agora:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            País    Capital    Área  População\n",
      "0         Brasil   Brasília   8.516      200.4\n",
      "1         Rússia     Moscou  17.100      143.5\n",
      "2          Índia  Nova Deli   3.286     1252.0\n",
      "3          China     Pequim   9.597     1357.0\n",
      "4  África do Sul   Pretória   1.221       52.9\n"
     ]
    }
   ],
   "source": [
    "Brics = Brics[['País','Capital','Área','População']] \n",
    "print(Brics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos ver que temos uma estrutura feita em tabela, o que torna a visualização dos dados muito mais fácil. Agora vamos supor que usaremos uma base de dados grande. Nesse caso, não podemos colocar toda base de dados no próprio código usando um dicionário, então usamos um arquivo externo do tipo **.csv**. Os arquivos _csv_ são arquivos com informações separadas por vírgulas dispostas em colunas. A biblioteca Pandas entende automaticamente esses dados e os converte em Data Frame.\n",
    "\n",
    "...\n",
    "\n",
    "_Formato de um .csv:_\n",
    "\n",
    "descrição1,descrição2,...,descriçãoN\n",
    "\n",
    "dado da descrição1, dado da descrição2,...,dado da descriçãoN\n",
    "\n",
    "dado da descrição1, dado da descrição2,...,dado da descriçãoN\n",
    "\n",
    "dado da descrição1, dado da descrição2,...,dado da descriçãoN\n",
    "\n",
    "\n",
    "_Exemplo:_\n",
    "\n",
    "País,Capital,Área,População\n",
    "\n",
    "Brasil,Brasília,8.516,200.4\n",
    "\n",
    "Rússia,Moscou,143.5,17.100\n",
    "\n",
    "...\n",
    "\n",
    "\n",
    "Podemos criar um arquivo _.csv_ de diversar maneiras e as mais fáceis são editar um bloco de notas e salvá-lo como _.csv_ ou podemos ir no Google Planilhas/Excel e colocar cada dado em uma coluna e na hora de baixar ou salvar, escolher a opção \"_csv_ separado por vírgulas\". No entanto, geralmente trabalharemos com arquivos _csv_ já prontos, criados por terceiros. Por favor baixe o arquivo \"Pokemon.csv\" da nossa pasta para trabalharmos agora:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>#</th>\n",
       "      <th>Nome</th>\n",
       "      <th>Tipo_1</th>\n",
       "      <th>Tipo_2</th>\n",
       "      <th>Total</th>\n",
       "      <th>HP</th>\n",
       "      <th>Ataque</th>\n",
       "      <th>Defesa</th>\n",
       "      <th>Vel.Ataque</th>\n",
       "      <th>Sp.Def</th>\n",
       "      <th>Velocidade</th>\n",
       "      <th>Geração</th>\n",
       "      <th>Lendario</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Bulbasaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>318</td>\n",
       "      <td>45</td>\n",
       "      <td>49</td>\n",
       "      <td>49</td>\n",
       "      <td>65</td>\n",
       "      <td>65</td>\n",
       "      <td>45</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Ivysaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>405</td>\n",
       "      <td>60</td>\n",
       "      <td>62</td>\n",
       "      <td>63</td>\n",
       "      <td>80</td>\n",
       "      <td>80</td>\n",
       "      <td>60</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Venusaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>525</td>\n",
       "      <td>80</td>\n",
       "      <td>82</td>\n",
       "      <td>83</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Charmander</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>309</td>\n",
       "      <td>39</td>\n",
       "      <td>52</td>\n",
       "      <td>43</td>\n",
       "      <td>60</td>\n",
       "      <td>50</td>\n",
       "      <td>65</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Charmeleon</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>58</td>\n",
       "      <td>64</td>\n",
       "      <td>58</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   #        Nome Tipo_1  Tipo_2  Total  HP  Ataque  Defesa  Vel.Ataque  \\\n",
       "0  1   Bulbasaur  Grama  Veneno    318  45      49      49          65   \n",
       "1  2     Ivysaur  Grama  Veneno    405  60      62      63          80   \n",
       "2  3    Venusaur  Grama  Veneno    525  80      82      83         100   \n",
       "3  4  Charmander   Fogo     NaN    309  39      52      43          60   \n",
       "4  5  Charmeleon   Fogo     NaN    405  58      64      58          80   \n",
       "\n",
       "   Sp.Def  Velocidade  Geração  Lendario  \n",
       "0      65          45        1     False  \n",
       "1      80          60        1     False  \n",
       "2     100          80        1     False  \n",
       "3      50          65        1     False  \n",
       "4      65          80        1     False  "
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Abrindo dataset\n",
    "dataset = pd.read_csv(\"Pokemon.csv\") #Colocamos o caminho do arquivo entre (),\n",
    "                                     #Não há a necessidade de colocar o caminho\n",
    "                                     #caso o arquivo já esteja na pasta do Jupyter Notebook.\n",
    "\n",
    "#Vamos dar um display no nosso dataset\n",
    "dataset.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O metodo _.head()_ mostra apenas as 5 primeiras observações de nosso dataset. Para vermos todos os nomes de variáveis, usamos o comando _.columns_. Ademais, podemos contar as linhas e colunas de nosso dataset com o metodo _.count()_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['#', 'Nome', 'Tipo_1', 'Tipo_2', 'Total', 'HP', 'Ataque', 'Defesa',\n",
       "       'Vel.Ataque', 'Sp.Def', 'Velocidade', 'Geração', 'Lendario'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Variáveis\n",
    "dataset.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#             9\n",
       "Nome          9\n",
       "Tipo_1        9\n",
       "Tipo_2        4\n",
       "Total         9\n",
       "HP            9\n",
       "Ataque        9\n",
       "Defesa        9\n",
       "Vel.Ataque    9\n",
       "Sp.Def        9\n",
       "Velocidade    9\n",
       "Geração       9\n",
       "Lendario      9\n",
       "dtype: int64"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#contando dados diferentes de vazio por variável\n",
    "dataset.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observamos que existem dois contadores no canto esquerdo e isso ocorre pois o dataset usado já contém um contador e o Pandas gera outro automaticamente. Para tiramos o contador do Pandas basta fazer o seguinte:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Nome</th>\n",
       "      <th>Tipo_1</th>\n",
       "      <th>Tipo_2</th>\n",
       "      <th>Total</th>\n",
       "      <th>HP</th>\n",
       "      <th>Ataque</th>\n",
       "      <th>Defesa</th>\n",
       "      <th>Vel.Ataque</th>\n",
       "      <th>Sp.Def</th>\n",
       "      <th>Velocidade</th>\n",
       "      <th>Geração</th>\n",
       "      <th>Lendario</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Squirtle</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>314</td>\n",
       "      <td>44</td>\n",
       "      <td>48</td>\n",
       "      <td>65</td>\n",
       "      <td>50</td>\n",
       "      <td>64</td>\n",
       "      <td>43</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Wartortle</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>59</td>\n",
       "      <td>63</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>58</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Blastoise</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>530</td>\n",
       "      <td>79</td>\n",
       "      <td>83</td>\n",
       "      <td>100</td>\n",
       "      <td>85</td>\n",
       "      <td>105</td>\n",
       "      <td>78</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Nome Tipo_1 Tipo_2  Total  HP  Ataque  Defesa  Vel.Ataque  Sp.Def  \\\n",
       "#                                                                           \n",
       "7   Squirtle   Agua    NaN    314  44      48      65          50      64   \n",
       "8  Wartortle   Agua    NaN    405  59      63      80          65      80   \n",
       "9  Blastoise   Agua    NaN    530  79      83     100          85     105   \n",
       "\n",
       "   Velocidade  Geração  Lendario  \n",
       "#                                 \n",
       "7          43        1     False  \n",
       "8          58        1     False  \n",
       "9          78        1     False  "
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Basta adicionar index_col =0 na hora de pegar o csv\n",
    "dataset = pd.read_csv(\"Pokemon.csv\",index_col =0)\n",
    "dataset.tail(3) #mostra os ultimos itens do csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também fazer os cortes que desejarmos no _csv_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Nome</th>\n",
       "      <th>Tipo_1</th>\n",
       "      <th>Tipo_2</th>\n",
       "      <th>Total</th>\n",
       "      <th>HP</th>\n",
       "      <th>Ataque</th>\n",
       "      <th>Defesa</th>\n",
       "      <th>Vel.Ataque</th>\n",
       "      <th>Sp.Def</th>\n",
       "      <th>Velocidade</th>\n",
       "      <th>Geração</th>\n",
       "      <th>Lendario</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Charmander</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>309</td>\n",
       "      <td>39</td>\n",
       "      <td>52</td>\n",
       "      <td>43</td>\n",
       "      <td>60</td>\n",
       "      <td>50</td>\n",
       "      <td>65</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Charmeleon</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>58</td>\n",
       "      <td>64</td>\n",
       "      <td>58</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Charizard</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>Voador</td>\n",
       "      <td>534</td>\n",
       "      <td>78</td>\n",
       "      <td>84</td>\n",
       "      <td>78</td>\n",
       "      <td>109</td>\n",
       "      <td>85</td>\n",
       "      <td>100</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Nome Tipo_1  Tipo_2  Total  HP  Ataque  Defesa  Vel.Ataque  Sp.Def  \\\n",
       "#                                                                             \n",
       "4  Charmander   Fogo     NaN    309  39      52      43          60      50   \n",
       "5  Charmeleon   Fogo     NaN    405  58      64      58          80      65   \n",
       "6   Charizard   Fogo  Voador    534  78      84      78         109      85   \n",
       "\n",
       "   Velocidade  Geração  Lendario  \n",
       "#                                 \n",
       "4          65        1     False  \n",
       "5          80        1     False  \n",
       "6         100        1     False  "
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Dando display em um intervalo do dataset\n",
    "dataset[3:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também escolher determinadas colunas (variáveis) da seguinte forma:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#\n",
       "1     Bulbasaur\n",
       "2       Ivysaur\n",
       "3      Venusaur\n",
       "4    Charmander\n",
       "5    Charmeleon\n",
       "6     Charizard\n",
       "7      Squirtle\n",
       "8     Wartortle\n",
       "9     Blastoise\n",
       "Name: Nome, dtype: object"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset['Nome']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Agua     3\n",
       "Fogo     3\n",
       "Grama    3\n",
       "Name: Tipo_1, dtype: int64"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Também é possível agrupar as colunas pelo método value_counts()\n",
    "pd.value_counts(dataset[\"Tipo_1\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Nome</th>\n",
       "      <th>Tipo_1</th>\n",
       "      <th>Tipo_2</th>\n",
       "      <th>Total</th>\n",
       "      <th>HP</th>\n",
       "      <th>Ataque</th>\n",
       "      <th>Defesa</th>\n",
       "      <th>Vel.Ataque</th>\n",
       "      <th>Sp.Def</th>\n",
       "      <th>Velocidade</th>\n",
       "      <th>Geração</th>\n",
       "      <th>Lendario</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Charmander</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>309</td>\n",
       "      <td>39</td>\n",
       "      <td>52</td>\n",
       "      <td>43</td>\n",
       "      <td>60</td>\n",
       "      <td>50</td>\n",
       "      <td>65</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Nome Tipo_1 Tipo_2  Total  HP  Ataque  Defesa  Vel.Ataque  Sp.Def  \\\n",
       "#                                                                            \n",
       "4  Charmander   Fogo    NaN    309  39      52      43          60      50   \n",
       "\n",
       "   Velocidade  Geração  Lendario  \n",
       "#                                 \n",
       "4          65        1     False  "
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#A função \"loc\" mostra os dados da linha desejada \n",
    "dataset.loc[dataset['Nome'] == 'Charmander']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Nome</th>\n",
       "      <th>Tipo_1</th>\n",
       "      <th>Tipo_2</th>\n",
       "      <th>Total</th>\n",
       "      <th>HP</th>\n",
       "      <th>Ataque</th>\n",
       "      <th>Defesa</th>\n",
       "      <th>Vel.Ataque</th>\n",
       "      <th>Sp.Def</th>\n",
       "      <th>Velocidade</th>\n",
       "      <th>Geração</th>\n",
       "      <th>Lendario</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Ivysaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>405</td>\n",
       "      <td>60</td>\n",
       "      <td>62</td>\n",
       "      <td>63</td>\n",
       "      <td>80</td>\n",
       "      <td>80</td>\n",
       "      <td>60</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Venusaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>525</td>\n",
       "      <td>80</td>\n",
       "      <td>82</td>\n",
       "      <td>83</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Charmander</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>309</td>\n",
       "      <td>39</td>\n",
       "      <td>52</td>\n",
       "      <td>43</td>\n",
       "      <td>60</td>\n",
       "      <td>50</td>\n",
       "      <td>65</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Charmeleon</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>58</td>\n",
       "      <td>64</td>\n",
       "      <td>58</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Charizard</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>Voador</td>\n",
       "      <td>534</td>\n",
       "      <td>78</td>\n",
       "      <td>84</td>\n",
       "      <td>78</td>\n",
       "      <td>109</td>\n",
       "      <td>85</td>\n",
       "      <td>100</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Wartortle</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>59</td>\n",
       "      <td>63</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>58</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Blastoise</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>530</td>\n",
       "      <td>79</td>\n",
       "      <td>83</td>\n",
       "      <td>100</td>\n",
       "      <td>85</td>\n",
       "      <td>105</td>\n",
       "      <td>78</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Nome Tipo_1  Tipo_2  Total  HP  Ataque  Defesa  Vel.Ataque  Sp.Def  \\\n",
       "#                                                                             \n",
       "2     Ivysaur  Grama  Veneno    405  60      62      63          80      80   \n",
       "3    Venusaur  Grama  Veneno    525  80      82      83         100     100   \n",
       "4  Charmander   Fogo     NaN    309  39      52      43          60      50   \n",
       "5  Charmeleon   Fogo     NaN    405  58      64      58          80      65   \n",
       "6   Charizard   Fogo  Voador    534  78      84      78         109      85   \n",
       "8   Wartortle   Agua     NaN    405  59      63      80          65      80   \n",
       "9   Blastoise   Agua     NaN    530  79      83     100          85     105   \n",
       "\n",
       "   Velocidade  Geração  Lendario  \n",
       "#                                 \n",
       "2          60        1     False  \n",
       "3          80        1     False  \n",
       "4          65        1     False  \n",
       "5          80        1     False  \n",
       "6         100        1     False  \n",
       "8          58        1     False  \n",
       "9          78        1     False  "
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Podemos também fazer isso para selecionar subconjuntos específicos do dataset\n",
    "dataset.loc[dataset['Ataque'] > 50]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos ordenar os dados de acordo com valores de uma variável com o método \".sort_values\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Nome</th>\n",
       "      <th>Tipo_1</th>\n",
       "      <th>Tipo_2</th>\n",
       "      <th>Total</th>\n",
       "      <th>HP</th>\n",
       "      <th>Ataque</th>\n",
       "      <th>Defesa</th>\n",
       "      <th>Vel.Ataque</th>\n",
       "      <th>Sp.Def</th>\n",
       "      <th>Velocidade</th>\n",
       "      <th>Geração</th>\n",
       "      <th>Lendario</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Squirtle</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>314</td>\n",
       "      <td>44</td>\n",
       "      <td>48</td>\n",
       "      <td>65</td>\n",
       "      <td>50</td>\n",
       "      <td>64</td>\n",
       "      <td>43</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bulbasaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>318</td>\n",
       "      <td>45</td>\n",
       "      <td>49</td>\n",
       "      <td>49</td>\n",
       "      <td>65</td>\n",
       "      <td>65</td>\n",
       "      <td>45</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Charmander</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>309</td>\n",
       "      <td>39</td>\n",
       "      <td>52</td>\n",
       "      <td>43</td>\n",
       "      <td>60</td>\n",
       "      <td>50</td>\n",
       "      <td>65</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Ivysaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>405</td>\n",
       "      <td>60</td>\n",
       "      <td>62</td>\n",
       "      <td>63</td>\n",
       "      <td>80</td>\n",
       "      <td>80</td>\n",
       "      <td>60</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Wartortle</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>59</td>\n",
       "      <td>63</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>58</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Charmeleon</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>58</td>\n",
       "      <td>64</td>\n",
       "      <td>58</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Venusaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>525</td>\n",
       "      <td>80</td>\n",
       "      <td>82</td>\n",
       "      <td>83</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Blastoise</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>530</td>\n",
       "      <td>79</td>\n",
       "      <td>83</td>\n",
       "      <td>100</td>\n",
       "      <td>85</td>\n",
       "      <td>105</td>\n",
       "      <td>78</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Charizard</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>Voador</td>\n",
       "      <td>534</td>\n",
       "      <td>78</td>\n",
       "      <td>84</td>\n",
       "      <td>78</td>\n",
       "      <td>109</td>\n",
       "      <td>85</td>\n",
       "      <td>100</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Nome Tipo_1  Tipo_2  Total  HP  Ataque  Defesa  Vel.Ataque  Sp.Def  \\\n",
       "#                                                                             \n",
       "7    Squirtle   Agua     NaN    314  44      48      65          50      64   \n",
       "1   Bulbasaur  Grama  Veneno    318  45      49      49          65      65   \n",
       "4  Charmander   Fogo     NaN    309  39      52      43          60      50   \n",
       "2     Ivysaur  Grama  Veneno    405  60      62      63          80      80   \n",
       "8   Wartortle   Agua     NaN    405  59      63      80          65      80   \n",
       "5  Charmeleon   Fogo     NaN    405  58      64      58          80      65   \n",
       "3    Venusaur  Grama  Veneno    525  80      82      83         100     100   \n",
       "9   Blastoise   Agua     NaN    530  79      83     100          85     105   \n",
       "6   Charizard   Fogo  Voador    534  78      84      78         109      85   \n",
       "\n",
       "   Velocidade  Geração  Lendario  \n",
       "#                                 \n",
       "7          43        1     False  \n",
       "1          45        1     False  \n",
       "4          65        1     False  \n",
       "2          60        1     False  \n",
       "8          58        1     False  \n",
       "5          80        1     False  \n",
       "3          80        1     False  \n",
       "9          78        1     False  \n",
       "6         100        1     False  "
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.sort_values(by='Ataque') #Para inverter a ordem,\n",
    "                                 #basta adicionar no argumento ascending=False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um outro método muito importante é o .describe(). O método faz uma análise descritiva básica da base de dados com as principais estatísticas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Total</th>\n",
       "      <th>HP</th>\n",
       "      <th>Ataque</th>\n",
       "      <th>Defesa</th>\n",
       "      <th>Vel.Ataque</th>\n",
       "      <th>Sp.Def</th>\n",
       "      <th>Velocidade</th>\n",
       "      <th>Geração</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>9.000000</td>\n",
       "      <td>9.000000</td>\n",
       "      <td>9.000000</td>\n",
       "      <td>9.000000</td>\n",
       "      <td>9.000000</td>\n",
       "      <td>9.000000</td>\n",
       "      <td>9.000000</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>416.111111</td>\n",
       "      <td>60.222222</td>\n",
       "      <td>65.222222</td>\n",
       "      <td>68.777778</td>\n",
       "      <td>77.111111</td>\n",
       "      <td>77.111111</td>\n",
       "      <td>67.666667</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>93.955368</td>\n",
       "      <td>15.857000</td>\n",
       "      <td>14.584048</td>\n",
       "      <td>18.053932</td>\n",
       "      <td>19.173187</td>\n",
       "      <td>17.961378</td>\n",
       "      <td>18.500000</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>309.000000</td>\n",
       "      <td>39.000000</td>\n",
       "      <td>48.000000</td>\n",
       "      <td>43.000000</td>\n",
       "      <td>50.000000</td>\n",
       "      <td>50.000000</td>\n",
       "      <td>43.000000</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>318.000000</td>\n",
       "      <td>45.000000</td>\n",
       "      <td>52.000000</td>\n",
       "      <td>58.000000</td>\n",
       "      <td>65.000000</td>\n",
       "      <td>65.000000</td>\n",
       "      <td>58.000000</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>405.000000</td>\n",
       "      <td>59.000000</td>\n",
       "      <td>63.000000</td>\n",
       "      <td>65.000000</td>\n",
       "      <td>80.000000</td>\n",
       "      <td>80.000000</td>\n",
       "      <td>65.000000</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>525.000000</td>\n",
       "      <td>78.000000</td>\n",
       "      <td>82.000000</td>\n",
       "      <td>80.000000</td>\n",
       "      <td>85.000000</td>\n",
       "      <td>85.000000</td>\n",
       "      <td>80.000000</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>534.000000</td>\n",
       "      <td>80.000000</td>\n",
       "      <td>84.000000</td>\n",
       "      <td>100.000000</td>\n",
       "      <td>109.000000</td>\n",
       "      <td>105.000000</td>\n",
       "      <td>100.000000</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Total         HP     Ataque      Defesa  Vel.Ataque      Sp.Def  \\\n",
       "count    9.000000   9.000000   9.000000    9.000000    9.000000    9.000000   \n",
       "mean   416.111111  60.222222  65.222222   68.777778   77.111111   77.111111   \n",
       "std     93.955368  15.857000  14.584048   18.053932   19.173187   17.961378   \n",
       "min    309.000000  39.000000  48.000000   43.000000   50.000000   50.000000   \n",
       "25%    318.000000  45.000000  52.000000   58.000000   65.000000   65.000000   \n",
       "50%    405.000000  59.000000  63.000000   65.000000   80.000000   80.000000   \n",
       "75%    525.000000  78.000000  82.000000   80.000000   85.000000   85.000000   \n",
       "max    534.000000  80.000000  84.000000  100.000000  109.000000  105.000000   \n",
       "\n",
       "       Velocidade  Geração  \n",
       "count    9.000000      9.0  \n",
       "mean    67.666667      1.0  \n",
       "std     18.500000      0.0  \n",
       "min     43.000000      1.0  \n",
       "25%     58.000000      1.0  \n",
       "50%     65.000000      1.0  \n",
       "75%     80.000000      1.0  \n",
       "max    100.000000      1.0  "
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Total         416.111111\n",
       "HP             60.222222\n",
       "Ataque         65.222222\n",
       "Defesa         68.777778\n",
       "Vel.Ataque     77.111111\n",
       "Sp.Def         77.111111\n",
       "Velocidade     67.666667\n",
       "Geração         1.000000\n",
       "Lendario        0.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Também é possível focar em uma estatística por vez\n",
    "dataset.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count      9.000000\n",
       "mean      68.777778\n",
       "std       18.053932\n",
       "min       43.000000\n",
       "25%       58.000000\n",
       "50%       65.000000\n",
       "75%       80.000000\n",
       "max      100.000000\n",
       "Name: Defesa, dtype: float64"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#É possível também focar em uma só coluna (variável):\n",
    "dataset[\"Defesa\"].describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se quisermos ver o máximo de uma variável específica, é possível fazer da seguinte forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "84"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[\"Ataque\"].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Nome</th>\n",
       "      <th>Tipo_1</th>\n",
       "      <th>Tipo_2</th>\n",
       "      <th>Total</th>\n",
       "      <th>HP</th>\n",
       "      <th>Ataque</th>\n",
       "      <th>Defesa</th>\n",
       "      <th>Vel.Ataque</th>\n",
       "      <th>Sp.Def</th>\n",
       "      <th>Velocidade</th>\n",
       "      <th>Geração</th>\n",
       "      <th>Lendario</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Charizard</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>Voador</td>\n",
       "      <td>534</td>\n",
       "      <td>78</td>\n",
       "      <td>84</td>\n",
       "      <td>78</td>\n",
       "      <td>109</td>\n",
       "      <td>85</td>\n",
       "      <td>100</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Nome Tipo_1  Tipo_2  Total  HP  Ataque  Defesa  Vel.Ataque  Sp.Def  \\\n",
       "#                                                                            \n",
       "6  Charizard   Fogo  Voador    534  78      84      78         109      85   \n",
       "\n",
       "   Velocidade  Geração  Lendario  \n",
       "#                                 \n",
       "6         100        1     False  "
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#É possível dar display em uma linha específica com uma qualidade qualquer.\n",
    "#No exemplo abaixo queríamos a que tinha maior ataque\n",
    "dataset.loc[dataset['Ataque'] == dataset[\"Ataque\"].max()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também adicionar dados na tabela da seguinte forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Nome</th>\n",
       "      <th>Tipo_1</th>\n",
       "      <th>Tipo_2</th>\n",
       "      <th>Total</th>\n",
       "      <th>HP</th>\n",
       "      <th>Ataque</th>\n",
       "      <th>Defesa</th>\n",
       "      <th>Vel.Ataque</th>\n",
       "      <th>Sp.Def</th>\n",
       "      <th>Velocidade</th>\n",
       "      <th>Geração</th>\n",
       "      <th>Lendario</th>\n",
       "      <th>Evolução</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bulbasaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>318</td>\n",
       "      <td>45</td>\n",
       "      <td>49</td>\n",
       "      <td>49</td>\n",
       "      <td>65</td>\n",
       "      <td>65</td>\n",
       "      <td>45</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Ivysaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>405</td>\n",
       "      <td>60</td>\n",
       "      <td>62</td>\n",
       "      <td>63</td>\n",
       "      <td>80</td>\n",
       "      <td>80</td>\n",
       "      <td>60</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Venusaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>525</td>\n",
       "      <td>80</td>\n",
       "      <td>82</td>\n",
       "      <td>83</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Charmander</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>309</td>\n",
       "      <td>39</td>\n",
       "      <td>52</td>\n",
       "      <td>43</td>\n",
       "      <td>60</td>\n",
       "      <td>50</td>\n",
       "      <td>65</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Charmeleon</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>58</td>\n",
       "      <td>64</td>\n",
       "      <td>58</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Charizard</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>Voador</td>\n",
       "      <td>534</td>\n",
       "      <td>78</td>\n",
       "      <td>84</td>\n",
       "      <td>78</td>\n",
       "      <td>109</td>\n",
       "      <td>85</td>\n",
       "      <td>100</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Squirtle</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>314</td>\n",
       "      <td>44</td>\n",
       "      <td>48</td>\n",
       "      <td>65</td>\n",
       "      <td>50</td>\n",
       "      <td>64</td>\n",
       "      <td>43</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Wartortle</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>59</td>\n",
       "      <td>63</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>58</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Blastoise</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>530</td>\n",
       "      <td>79</td>\n",
       "      <td>83</td>\n",
       "      <td>100</td>\n",
       "      <td>85</td>\n",
       "      <td>105</td>\n",
       "      <td>78</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Nome Tipo_1  Tipo_2  Total  HP  Ataque  Defesa  Vel.Ataque  Sp.Def  \\\n",
       "#                                                                             \n",
       "1   Bulbasaur  Grama  Veneno    318  45      49      49          65      65   \n",
       "2     Ivysaur  Grama  Veneno    405  60      62      63          80      80   \n",
       "3    Venusaur  Grama  Veneno    525  80      82      83         100     100   \n",
       "4  Charmander   Fogo     NaN    309  39      52      43          60      50   \n",
       "5  Charmeleon   Fogo     NaN    405  58      64      58          80      65   \n",
       "6   Charizard   Fogo  Voador    534  78      84      78         109      85   \n",
       "7    Squirtle   Agua     NaN    314  44      48      65          50      64   \n",
       "8   Wartortle   Agua     NaN    405  59      63      80          65      80   \n",
       "9   Blastoise   Agua     NaN    530  79      83     100          85     105   \n",
       "\n",
       "   Velocidade  Geração  Lendario  Evolução  \n",
       "#                                           \n",
       "1          45        1     False         1  \n",
       "2          60        1     False         2  \n",
       "3          80        1     False         3  \n",
       "4          65        1     False         1  \n",
       "5          80        1     False         2  \n",
       "6         100        1     False         3  \n",
       "7          43        1     False         1  \n",
       "8          58        1     False         2  \n",
       "9          78        1     False         3  "
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset['Evolução'] = (1,2,3,1,2,3,1,2,3)\n",
    "dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É possível aplicar funções com dados da tabela para preencher dados na propria tabela:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Nome</th>\n",
       "      <th>Tipo_1</th>\n",
       "      <th>Tipo_2</th>\n",
       "      <th>Total</th>\n",
       "      <th>HP</th>\n",
       "      <th>Ataque</th>\n",
       "      <th>Defesa</th>\n",
       "      <th>Vel.Ataque</th>\n",
       "      <th>Sp.Def</th>\n",
       "      <th>Velocidade</th>\n",
       "      <th>Geração</th>\n",
       "      <th>Lendario</th>\n",
       "      <th>Evolução</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bulbasaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>318</td>\n",
       "      <td>45</td>\n",
       "      <td>49</td>\n",
       "      <td>49</td>\n",
       "      <td>65</td>\n",
       "      <td>65</td>\n",
       "      <td>45</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>Forma incial</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Ivysaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>405</td>\n",
       "      <td>60</td>\n",
       "      <td>62</td>\n",
       "      <td>63</td>\n",
       "      <td>80</td>\n",
       "      <td>80</td>\n",
       "      <td>60</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>Primeira evolução</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Venusaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>525</td>\n",
       "      <td>80</td>\n",
       "      <td>82</td>\n",
       "      <td>83</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>Segunda Evolução</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Charmander</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>309</td>\n",
       "      <td>39</td>\n",
       "      <td>52</td>\n",
       "      <td>43</td>\n",
       "      <td>60</td>\n",
       "      <td>50</td>\n",
       "      <td>65</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>Forma incial</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Charmeleon</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>58</td>\n",
       "      <td>64</td>\n",
       "      <td>58</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>Primeira evolução</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Charizard</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>Voador</td>\n",
       "      <td>534</td>\n",
       "      <td>78</td>\n",
       "      <td>84</td>\n",
       "      <td>78</td>\n",
       "      <td>109</td>\n",
       "      <td>85</td>\n",
       "      <td>100</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>Segunda Evolução</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Squirtle</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>314</td>\n",
       "      <td>44</td>\n",
       "      <td>48</td>\n",
       "      <td>65</td>\n",
       "      <td>50</td>\n",
       "      <td>64</td>\n",
       "      <td>43</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>Forma incial</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Wartortle</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>59</td>\n",
       "      <td>63</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>58</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>Primeira evolução</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Blastoise</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>530</td>\n",
       "      <td>79</td>\n",
       "      <td>83</td>\n",
       "      <td>100</td>\n",
       "      <td>85</td>\n",
       "      <td>105</td>\n",
       "      <td>78</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>Segunda Evolução</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Nome Tipo_1  Tipo_2  Total  HP  Ataque  Defesa  Vel.Ataque  Sp.Def  \\\n",
       "#                                                                             \n",
       "1   Bulbasaur  Grama  Veneno    318  45      49      49          65      65   \n",
       "2     Ivysaur  Grama  Veneno    405  60      62      63          80      80   \n",
       "3    Venusaur  Grama  Veneno    525  80      82      83         100     100   \n",
       "4  Charmander   Fogo     NaN    309  39      52      43          60      50   \n",
       "5  Charmeleon   Fogo     NaN    405  58      64      58          80      65   \n",
       "6   Charizard   Fogo  Voador    534  78      84      78         109      85   \n",
       "7    Squirtle   Agua     NaN    314  44      48      65          50      64   \n",
       "8   Wartortle   Agua     NaN    405  59      63      80          65      80   \n",
       "9   Blastoise   Agua     NaN    530  79      83     100          85     105   \n",
       "\n",
       "   Velocidade  Geração  Lendario           Evolução  \n",
       "#                                                    \n",
       "1          45        1     False       Forma incial  \n",
       "2          60        1     False  Primeira evolução  \n",
       "3          80        1     False   Segunda Evolução  \n",
       "4          65        1     False       Forma incial  \n",
       "5          80        1     False  Primeira evolução  \n",
       "6         100        1     False   Segunda Evolução  \n",
       "7          43        1     False       Forma incial  \n",
       "8          58        1     False  Primeira evolução  \n",
       "9          78        1     False   Segunda Evolução  "
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def evolucao(x):\n",
    "    if x == 1:\n",
    "        return \"Forma incial\"\n",
    "    elif x == 2:\n",
    "        return \"Primeira evolução\"\n",
    "    elif x == 3:\n",
    "        return \"Segunda Evolução\"\n",
    "    \n",
    "dataset['Evolução'] = dataset['Evolução'].apply(evolucao)\n",
    "dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por fim, podemos excluir dados com método \".drop\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Nome</th>\n",
       "      <th>Tipo_1</th>\n",
       "      <th>Tipo_2</th>\n",
       "      <th>Total</th>\n",
       "      <th>HP</th>\n",
       "      <th>Ataque</th>\n",
       "      <th>Defesa</th>\n",
       "      <th>Vel.Ataque</th>\n",
       "      <th>Sp.Def</th>\n",
       "      <th>Velocidade</th>\n",
       "      <th>Geração</th>\n",
       "      <th>Evolução</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bulbasaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>318</td>\n",
       "      <td>45</td>\n",
       "      <td>49</td>\n",
       "      <td>49</td>\n",
       "      <td>65</td>\n",
       "      <td>65</td>\n",
       "      <td>45</td>\n",
       "      <td>1</td>\n",
       "      <td>Forma incial</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Ivysaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>405</td>\n",
       "      <td>60</td>\n",
       "      <td>62</td>\n",
       "      <td>63</td>\n",
       "      <td>80</td>\n",
       "      <td>80</td>\n",
       "      <td>60</td>\n",
       "      <td>1</td>\n",
       "      <td>Primeira evolução</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Venusaur</td>\n",
       "      <td>Grama</td>\n",
       "      <td>Veneno</td>\n",
       "      <td>525</td>\n",
       "      <td>80</td>\n",
       "      <td>82</td>\n",
       "      <td>83</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>Segunda Evolução</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Charmander</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>309</td>\n",
       "      <td>39</td>\n",
       "      <td>52</td>\n",
       "      <td>43</td>\n",
       "      <td>60</td>\n",
       "      <td>50</td>\n",
       "      <td>65</td>\n",
       "      <td>1</td>\n",
       "      <td>Forma incial</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Charmeleon</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>58</td>\n",
       "      <td>64</td>\n",
       "      <td>58</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>1</td>\n",
       "      <td>Primeira evolução</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Charizard</td>\n",
       "      <td>Fogo</td>\n",
       "      <td>Voador</td>\n",
       "      <td>534</td>\n",
       "      <td>78</td>\n",
       "      <td>84</td>\n",
       "      <td>78</td>\n",
       "      <td>109</td>\n",
       "      <td>85</td>\n",
       "      <td>100</td>\n",
       "      <td>1</td>\n",
       "      <td>Segunda Evolução</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Squirtle</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>314</td>\n",
       "      <td>44</td>\n",
       "      <td>48</td>\n",
       "      <td>65</td>\n",
       "      <td>50</td>\n",
       "      <td>64</td>\n",
       "      <td>43</td>\n",
       "      <td>1</td>\n",
       "      <td>Forma incial</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Wartortle</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>405</td>\n",
       "      <td>59</td>\n",
       "      <td>63</td>\n",
       "      <td>80</td>\n",
       "      <td>65</td>\n",
       "      <td>80</td>\n",
       "      <td>58</td>\n",
       "      <td>1</td>\n",
       "      <td>Primeira evolução</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Blastoise</td>\n",
       "      <td>Agua</td>\n",
       "      <td>NaN</td>\n",
       "      <td>530</td>\n",
       "      <td>79</td>\n",
       "      <td>83</td>\n",
       "      <td>100</td>\n",
       "      <td>85</td>\n",
       "      <td>105</td>\n",
       "      <td>78</td>\n",
       "      <td>1</td>\n",
       "      <td>Segunda Evolução</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Nome Tipo_1  Tipo_2  Total  HP  Ataque  Defesa  Vel.Ataque  Sp.Def  \\\n",
       "#                                                                             \n",
       "1   Bulbasaur  Grama  Veneno    318  45      49      49          65      65   \n",
       "2     Ivysaur  Grama  Veneno    405  60      62      63          80      80   \n",
       "3    Venusaur  Grama  Veneno    525  80      82      83         100     100   \n",
       "4  Charmander   Fogo     NaN    309  39      52      43          60      50   \n",
       "5  Charmeleon   Fogo     NaN    405  58      64      58          80      65   \n",
       "6   Charizard   Fogo  Voador    534  78      84      78         109      85   \n",
       "7    Squirtle   Agua     NaN    314  44      48      65          50      64   \n",
       "8   Wartortle   Agua     NaN    405  59      63      80          65      80   \n",
       "9   Blastoise   Agua     NaN    530  79      83     100          85     105   \n",
       "\n",
       "   Velocidade  Geração           Evolução  \n",
       "#                                          \n",
       "1          45        1       Forma incial  \n",
       "2          60        1  Primeira evolução  \n",
       "3          80        1   Segunda Evolução  \n",
       "4          65        1       Forma incial  \n",
       "5          80        1  Primeira evolução  \n",
       "6         100        1   Segunda Evolução  \n",
       "7          43        1       Forma incial  \n",
       "8          58        1  Primeira evolução  \n",
       "9          78        1   Segunda Evolução  "
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#vamos excluir a coluna \"Lendario\"\n",
    "dataset.drop([\"Lendario\"],axis=1,inplace= True)\n",
    "dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercícios\n",
    "\n",
    "1-Crie um arquivo.csv com área, país, capital, população e IDH de coluna usando os países do Mercosul como base faça as seguintes manipulações com o csv:\n",
    "   \n",
    "   a) Organize os países por ordem alfabética e depois por IDH;\n",
    "   \n",
    "   b) Descubra a média do IDH do mercosul e selecione todos os países que estiverem acima da média mostrando todos os seus dados;\n",
    "   \n",
    "   c) Adicione uma coluna que classifique um país como de Desenvolvido ou Subdesenvolvido levando em conta o IDH depois tire a tabela de IDH - defina um ponto de corte;\n",
    "    \n",
    "2- Faça o mesmo com os países da União Europeia;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}