cap6-numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introdução a Python - Capítulo 6 - NumPy\n",
    "<br>\n",
    "\n",
    "**NumPy** é a abreviação de _Numerical Python_ e é um dos pacotes mais importantes para processamento numérico em Python. Esta biblioteca oferece a base para a maioria dos pacotes de aplicações científicas que utilizem dados numéricos em Python (estruturas de dados e algoritmos). Pode-se destacar os seguintes recursos que o pacote contém:\n",
    "\n",
    "- Um poderoso objeto array multidimensional;\n",
    "- Funções matemáticas sofisticadas para operações com _arrays_ sem a necessidade de utilização de laços `for`;\n",
    "- Recursos de algebra linear e geração de números aleatórios\n",
    "\n",
    "Além de seus óbvios usos científicos, o pacote **NumPy** também é muito utilizado em análise de dados como um eficiente contêiner multidimensional de dados genéricos para transporte entre diversos algoritmos e bibliotecas em Python. Para saber mais, você pode acessar a [documentação](https://numpy.org/doc/).\n",
    "\n",
    "---\n",
    "<br>\n",
    "\n",
    "### Índice<a id='indice'></a>\n",
    "1 - [Arrays NumPy](#1)<br>\n",
    "2 - [Operações aritméticas com arrays NumPy](#2)<br>\n",
    "3 - [Seleções com arrays NumPy](#3)<br>\n",
    "4 - [Atributos e métodos de arrays NumPy](#4)<br>\n",
    "5 - [Estatísticas com arrays Numpy](#5)<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.7.3\n"
     ]
    }
   ],
   "source": [
    "!python --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Arrays Numpy<a id='1'></a>\n",
    "**Obs.**: Eventualmente você irá encontrar apenas o termo _array_ neste capítulo, tenha em mente que se tratam sempre de _arrays_ NumPy.\n",
    "### 1.1. Arrays unidimensionais\n",
    "Para começar, vamos usar uma das _built functions_ para criar um _array_ unidimensional, o primeiro passo é importar a biblioteca:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando a função `arange()` podemos criar um _array_ muito facilmente passando apenas um parâmetro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "lista1 = np.arange(5)\n",
    "print(lista1)\n",
    "print(type(lista1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora vamos utilizar uma das funções da biblioteca NumPy para ler um conjunto de dados de um arquivo externo (txt) e transformar estas informações em _arrays_ NumPy. \n",
    "\n",
    "Utilizamos o método [`np.loadtxt()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.loadtxt.html?highlight=loadtxt#numpy.loadtxt) para carregar o conteúdo de um arquivo como um _array_ NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "km = np.loadtxt('data/carros-km.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de \"printar\" o resultado verificamos o tamanho do _array_ com o método [`size`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.size.html):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n",
      "258\n"
     ]
    }
   ],
   "source": [
    "print(km.dtype)\n",
    "print(km.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sabendo que se trata de um número grande de valores para \"printar\" na tela, vamos apresentar apenas os dez primeiros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([44410.,  5712., 37123.,     0., 25757., 10728.,     0., 77599.,\n",
       "       99197., 37978.])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "km[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este arquivo que foi importado possui como conteúdo a quilometragem de carros.\n",
    "\n",
    "Agora vamos importar o arquivo que contém o ano de fabricação de cada um desses carros. Mas agora vamos especificar o tipo de dados dos valores contidos no arquivo, isso é feito passando um segundo parâmetro para o método."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "anos = np.loadtxt('data/carros-anos.txt', dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n",
      "258\n",
      "[2003 1991 1990 2019 2006 2012 2019 2009 2010 2011]\n"
     ]
    }
   ],
   "source": [
    "print(anos.dtype)\n",
    "print(anos.size)\n",
    "print(anos[:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por fim, vamos calcular a quilometragem média que cada carrou andou por ano. Faremos isso para duas situações: até o ano de 2019 (ano de fabricação mais recente) e o atual. Então, começando por 2020:\n",
    "<a id='oper_arrays'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "km_media_20 = km / (2020 - anos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2612.35294118,  196.96551724, 1237.43333333,    0.        ,\n",
       "       1839.78571429, 1341.        ,    0.        , 7054.45454545,\n",
       "       9919.7       , 4219.77777778])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "km_media_20[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\cesar\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "km_media_19 = km / (2019 - anos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2775.625     ,   204.        ,  1280.10344828,            nan,\n",
       "        1981.30769231,  1532.57142857,            nan,  7759.9       ,\n",
       "       11021.88888889,  4747.25      ])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "km_media_19[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que quando calculamos em relação ao ano de 2020 não recebemos nenhum <font color=red>warning</font>, enquanto que para 2019 recebemos um mensagem. Isso se deve a divisões por zero que aconteceram na segunda situação, pois alguns carros foram fabricados em 2019. Perceba que os respectivos elementos no _array_ de quilometragem média receberam o valor `nan` (not a number)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "do3kUOLbltjE"
   },
   "source": [
    "### 1.2. Arrays com duas dimensões\n",
    "Arrays dimensionais... Observe a lista abaixo que foi atribuida a variável `dados`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 425
    },
    "colab_type": "code",
    "id": "Gt1dL27GltpB",
    "outputId": "93a154b3-dd3d-476f-e0a6-62ec03ed38ca",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "dados = [ \n",
    "    ['Rodas de liga', 'Travas elétricas', 'Piloto automático', 'Bancos de couro', 'Ar condicionado', 'Sensor de estacionamento', 'Sensor crepuscular', 'Sensor de chuva'],\n",
    "    ['Central multimídia', 'Teto panorâmico', 'Freios ABS', '4 X 4', 'Painel digital', 'Piloto automático', 'Bancos de couro', 'Câmera de estacionamento'],\n",
    "    ['Piloto automático', 'Controle de estabilidade', 'Sensor crepuscular', 'Freios ABS', 'Câmbio automático', 'Bancos de couro', 'Central multimídia', 'Vidros elétricos']\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "IlbYeZPkltpC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "lista: ['Rodas de liga', 'Travas elétricas', 'Piloto automático', 'Bancos de couro', 'Ar condicionado', 'Sensor de estacionamento', 'Sensor crepuscular', 'Sensor de chuva']\n",
      "lista: ['Central multimídia', 'Teto panorâmico', 'Freios ABS', '4 X 4', 'Painel digital', 'Piloto automático', 'Bancos de couro', 'Câmera de estacionamento']\n",
      "lista: ['Piloto automático', 'Controle de estabilidade', 'Sensor crepuscular', 'Freios ABS', 'Câmbio automático', 'Bancos de couro', 'Central multimídia', 'Vidros elétricos']\n"
     ]
    }
   ],
   "source": [
    "print(len(dados))\n",
    "for lista in dados:\n",
    "    print('lista: {}'.format(lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "TDM9HskUltpD",
    "outputId": "510eedab-e026-49cf-e31a-ab52bb3b1bae"
   },
   "source": [
    "Vamos criar um _array_ multidimensional a partir desta \"lista de listas\" que armazenamos na variável `dados`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "bBmnzpF5ltpE",
    "outputId": "cdd9cf12-9f2d-4bb5-efcc-817398b2855f"
   },
   "outputs": [],
   "source": [
    "acessorios = np.array(dados)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos até ver a dimensão deste _array_ com o método `shape`, que retorna uma tuplno seguinte formato: `(linhas, colunas)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(258,)\n",
      "(3, 8)\n"
     ]
    }
   ],
   "source": [
    "print(km.shape)\n",
    "print(acessorios.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cPbkST9pltpE"
   },
   "source": [
    "### 1.3. Comparando desempenho"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos avaliar o tempo de execução de iteração sobre esses dois tipos de dados: _arrays_ NumPy e listas. Para isso vamos usar o `%time`, que é uma _built function_ que retorna o tempo utilizado para executar um código.\n",
    "\n",
    "Então criamos dois iteráveis (uma lista e um _array_ NumPy) de mesmo tamanho e rodamos um `for` para repetir uma ação por 100 vezes, esta ação no caso é multiplicar cada elemento do iterável por 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tTPC-G4vltpE"
   },
   "outputs": [],
   "source": [
    "np_array = np.arange(1000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PIC-ndg9ltpF"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 125 ms\n"
     ]
    }
   ],
   "source": [
    "%time for _ in list(range(100)): np_array *= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "vXy57nk2ltpF",
    "outputId": "887c4318-de05-42f7-8b08-ec0f44805f33"
   },
   "outputs": [],
   "source": [
    "py_list = list(range(1000000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "I94lVgCRltpG",
    "outputId": "09665988-9e30-404f-ced3-94bb0f59fb8f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 21.5 s\n"
     ]
    }
   ],
   "source": [
    "%time for _ in list(range(100)): py_list = [x * 2 for x in py_list]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que utilizando um _array_ NumPy foi possível executar a ação quase 200 vezes mais rápido."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ul4MuKyTltpG"
   },
   "source": [
    "## 2. Operações aritméticas com arrays NumPy<a id='2'></a>\n",
    "### 2.1. Operações entre arrays e constantes\n",
    "Vamos determinar a idade dos carros abaixo a partir do ano de fabricação que está armazenado em uma lista e em um _array_ NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "63KVHPK0ltpH"
   },
   "outputs": [],
   "source": [
    "km = [44410., 5712., 37123., 0., 25757.]\n",
    "anos = [2003, 1991, 1990, 2019, 2006]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AryIZaBIltpH"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'int' and 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-22-4084c5e6fc93>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0midade\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m2019\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0manos\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'int' and 'list'"
     ]
    }
   ],
   "source": [
    "idade = 2019 - anos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando tentamos realizar uma operação aritmética entre um inteiro e uma lista, recebemos um aviso de erro dizendo que esta operação não é suportada. Para que isso seja possível com uma lista, devemos utilizar um laço `for` para realizar a operação do inteiro com cada item da lista.\n",
    "\n",
    "Vamos novamente tentar fazer isso, mas agora a operação será entre um _array_ e um inteiro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "s8GvEk4HltpI"
   },
   "outputs": [],
   "source": [
    "km = np.array([44410., 5712., 37123., 0., 25757.])\n",
    "anos = np.array([2003, 1991, 1990, 2019, 2006])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aUnYV7OultpI"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[16 28 29  0 13]\n"
     ]
    }
   ],
   "source": [
    "idade = 2019 - anos\n",
    "print(idade)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qn1PUsM9ltpJ"
   },
   "source": [
    "### 2.2. Operações com arrays de duas dimensões\n",
    "Como já foi visto no [incício](#oper_arrays) deste guia, podemos realizar operações entre dois (ou mais) _arrays_. Além disso podemos realizar operações em _arrays_ multidimensionais. Vamos criar um _array_ de duas dimensões usando os últimos _arrays_ criados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "n0rPxgY1ltpL",
    "outputId": "37cff722-ea36-42ef-dce3-f635e6121c21"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410.,  5712., 37123.,     0., 25757.],\n",
       "       [ 2003.,  1991.,  1990.,  2019.,  2006.]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados = np.array([km, anos])\n",
    "dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VT71Pbb3ltpN"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "jIQU2ugKltpP",
    "outputId": "facf9fbe-a73b-43a0-b7ec-885b57f9fcd7"
   },
   "source": [
    "Vemos que se trata de uma matriz com duas linhas e cinco colunas, em que a primeira linha representa a quilometragem rodada e a segunda o ano de fabricação. Na imagem abaixo é possível ver a representação dos índices de cada elemento da matriz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dsgz-E5ZltpP"
   },
   "source": [
    "![1410-img01.png](https://caelum-online-public.s3.amazonaws.com/1410-pythondatascience/01/1410-img01.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Novamente vamos calcular a quilometragem média, mas agora usando as linhas da matriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "imANn6HultpQ",
    "outputId": "25b27625-593e-460c-80ab-f2b10254c11b"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\cesar\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([2775.625     ,  204.        , 1280.10344828,           nan,\n",
       "       1981.30769231])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "km_media = dados[0] / (2019 - dados[1])\n",
    "km_media"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4CAwtS0-ltpR"
   },
   "source": [
    "## 3. Seleções com arrays Numpy<a id='3'></a>\n",
    "Para selecionar um elemento específico de um _array_ multidimensional basta seguir a sintaxe abaixo e ir passando o índice de cada \"*subarray*\":\n",
    "\n",
    "`ndarray[ linha ][ coluna ]` ou `ndarray[ linha, coluna ]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "Nxc3uY-ZltpZ",
    "outputId": "82bcfdd7-0fb9-4f07-86d6-659de36d65dd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1990.0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados[1][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "xp8ByjualtpZ",
    "outputId": "ba078aaf-cc7d-4696-b66b-5f493a0eec1f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1990.0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados[1,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7osmTUC4ltpa"
   },
   "source": [
    "### 3.1. Fatiamentos\n",
    " \n",
    "A sintaxe para realizar fatiamento em um _array_ NumPy é $i : j : k$ onde $i$ é o índice inicial, $j$ é o índice de parada, e $k$ é o indicador de passo ($k\\neq0$). Note que nos fatiamentos, o item com índice $i$ é **incluído** e o item com índice $j$ **não é incluído** no resultado.\n",
    "\n",
    "Vamos começar experimentando com um _array_ unidimensional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "tlaD1SENltpb",
    "outputId": "1c126afe-6ce1-4a99-8fe2-0807f37720a8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contador = np.arange(10)\n",
    "contador"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "vXLIO1cVltpc",
    "outputId": "e4bc0c09-fc11-49d1-8013-bd98d1b2bfef"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contador[1:8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "kYLgsQcHltpc",
    "outputId": "75041cfe-d698-418c-df94-a2a515170195"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contador[1:8:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "H2MJpIasltpd",
    "outputId": "c92dece1-fa73-4805-db15-8d3bd885bdc9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#pegando apenas os números pares\n",
    "contador[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "YVzf4fNCltpe",
    "outputId": "7c087f8e-e82b-487c-ddbb-3819bb6cfeff"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#pegando apenas os números impares\n",
    "contador[1::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora vamos testar com nosso _array_ bidimensional, calculando a quilometragem média apenas para alguns carros. Basta seguir a síntaxe de seleção multidimensional passando o fatiamento desejado para cada dimensão:\n",
    "\n",
    "`ndarray[ slice line ][ slice column ]` ou `ndarray[ slice line, slice column ]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "bPyQsUFPltpf",
    "outputId": "decb9b9d-1365-4abc-b931-0bf7c7c25902"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410.,  5712., 37123.,     0., 25757.],\n",
       "       [ 2003.,  1991.,  1990.,  2019.,  2006.]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "wfoJ84haltph",
    "outputId": "cc831053-a80d-4f17-81df-5110e67a3b27"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5712., 37123.],\n",
       "       [ 1991.,  1990.]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# seleciono as duas linhas e as colunas de índice 1 e 2\n",
    "dados[:, 1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "id": "UeejSXUAltph",
    "outputId": "f3f4e506-88a6-44d9-c185-11948413900a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 204.        , 1280.10344828])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "km_media = dados[:, 1:3][0] / (2019 - dados[:, 1:3][1])\n",
    "km_media"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-fW4EXIqltpi"
   },
   "source": [
    "### 3.2. Indexação com array booleano\n",
    "\n",
    "É possível selecionar um grupo de linhas e colunas segundo os rótulos ou um _array_ booleano. Vontando ao nosso _array_ de exemplo, vamos selecionar apenas os elementos maiores que `5`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "MgmH-rCSltpi",
    "outputId": "fdce327f-6fc8-4beb-bc07-401c5c4d4050"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contador"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "HN1i-BlLltpj",
    "outputId": "8c8cac71-a75c-4d96-8829-ebcf81393aa5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False,  True,  True,  True,\n",
       "        True])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contador > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "iXJa9tL4ltpj",
    "outputId": "61ec0c5a-8959-4fae-afcc-6f16c6d832d1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 7, 8, 9])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contador[contador > 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora vamos calcular novamente a quilometragem média, mas apenas para carros fabricados depois do ano `2000` **e** que possuem quilometragem maior que `zero`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "54gH6X5eltpk",
    "outputId": "0b7bcbdb-f0da-4362-f9d4-da3b832895f6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410.,  5712., 37123.,     0., 25757.],\n",
       "       [ 2003.,  1991.,  1990.,  2019.,  2006.]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "F3z6zMELltpk",
    "outputId": "0847c7bf-7203-47e1-c3fb-6fb98c642385"
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-42-c3b6ada04f14>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# tentativa de selecionar todas as linhas e (nas colunas) combinar condições que envolvem as duas linhas\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mdados\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdados\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mdados\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m2000\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "# tentativa de selecionar todas as linhas e (nas colunas) combinar condições que envolvem as duas linhas\n",
    "dados[:, dados[0] > 0 or dados[1] > 2000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aparentemente, não é possível definir uma condição para o fatiamento das colunas que seja uma combinação de condições para cada linha. Portanto, devemos fazer cada fatiamento em separado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410.,  5712., 37123., 25757.],\n",
       "       [ 2003.,  1991.,  1990.,  2006.]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# seleciono todas as linhas e colunas em que a quilometragem é maior que zero\n",
    "dados = dados[:, dados[0] > 0]\n",
    "dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410., 25757.],\n",
       "       [ 2003.,  2006.]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# seleciono todas as linhas e colunas em que o ano de fabricação é maior que 2000\n",
    "dados = dados[:, dados[1] > 2000]\n",
    "dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "pk8A68z1ltpl",
    "outputId": "384b5017-e439-43d6-aa21-f080ee6881e4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2775.625     , 1981.30769231])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "km_media = dados[0] / (2019 - dados[1])\n",
    "km_media"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "WUVMN29_ltpm",
    "outputId": "65384f27-5bb7-43af-bcb0-02879a6b0a38"
   },
   "source": [
    "E por fim, calculamos a quilometragem média apenas para os veículos fabricados depois do ano 2000 e que possuem quilometragem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2775.625     , 1981.30769231])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "km_media = dados[0] / (2019 - dados[1])\n",
    "km_media"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Acw1DffHltpn"
   },
   "source": [
    "## 4. Atributos e métodos de arrays NumPy<a id='4'></a>\n",
    "Os _arrays_ NumPy possuem uma série de atributos e métodos muito úteis, você pode acessar as respectivas documentações de [atributos](https://numpy.org/doc/1.17/reference/arrays.ndarray.html#array-attributes) e [métodos](https://numpy.org/doc/1.17/reference/arrays.ndarray.html#array-methods) para obter maiores detalhes. Vamos passar por alguns dos mais comuns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "stjvD6m8ltpo",
    "outputId": "32e25cd2-f033-4837-e02c-88f77438a997"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410.,  5712., 37123.,     0., 25757.],\n",
       "       [ 2003.,  1991.,  1990.,  2019.,  2006.]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados = np.array([km, anos])\n",
    "dados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uKqPxg2Zltpo"
   },
   "source": [
    "### 4.1. `ndarray.shape`\n",
    "Retorna uma tupla com as dimensões do array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "gmaZhF04ltpp",
    "outputId": "ddc2e444-3bce-4795-b4e1-70c050c3cccb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[44410.,  5712., 37123.,     0., 25757.],\n",
       "        [ 2003.,  1991.,  1990.,  2019.,  2006.]],\n",
       "\n",
       "       [[44410.,  5712., 37123.,     0., 25757.],\n",
       "        [ 2003.,  1991.,  1990.,  2019.,  2006.]]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados_3d = np.array([[km, anos], [km, anos]])\n",
    "dados_3d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2, 5)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados_3d.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XaY6oXkmltpp"
   },
   "source": [
    "### 4.2. `ndarray.ndim`\n",
    "Retorna o número de dimensões do array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "inJ4HDjaltpq",
    "outputId": "7abafd3f-aa10-4798-f7d4-3c106ccfaaf9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados_3d.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ESgVt5xOltpq"
   },
   "source": [
    "### 4.3. `ndarray.size`\n",
    "Retorna o número de elementos do array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "BWr4efoiltpq",
    "outputId": "2c465a85-49a4-4410-b98f-69375c926bc2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados_3d.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ox8JlBM3ltpr"
   },
   "source": [
    "### 4.4. `ndarray.dtype`\n",
    "Retorna o tipo de dados dos elementos do array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "npiL84Vfltpu",
    "outputId": "e0922ec0-a1d4-4097-8328-79e7a9048aa2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "j7uPN16oltpv"
   },
   "source": [
    "### 4.5. `ndarray.T`\n",
    "Retorna o array transposto, isto é, converte linhas em colunas e vice versa. É equivalente ao método `transpose()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 102
    },
    "colab_type": "code",
    "id": "bLjrrx56ltpv",
    "outputId": "54439045-02cb-40d1-9862-475e9d350aa3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410.,  5712., 37123.,     0., 25757.],\n",
       "       [ 2003.,  1991.,  1990.,  2019.,  2006.]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 102
    },
    "colab_type": "code",
    "id": "5A9SlJQvltpw",
    "outputId": "830c7107-c7ce-4cbc-c2d0-de6fa5c98781"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410.,  2003.],\n",
       "       [ 5712.,  1991.],\n",
       "       [37123.,  1990.],\n",
       "       [    0.,  2019.],\n",
       "       [25757.,  2006.]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410.,  2003.],\n",
       "       [ 5712.,  1991.],\n",
       "       [37123.,  1990.],\n",
       "       [    0.,  2019.],\n",
       "       [25757.,  2006.]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados.transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SR9KYy-0ltpw"
   },
   "source": [
    "### 4.6. `ndarray.tolist()`\n",
    "Retorna o array como uma lista Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "C2aTAwOXltpw",
    "outputId": "fa7a9260-94dc-4a0e-f83f-2aaff67e864d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[44410.0, 5712.0, 37123.0, 0.0, 25757.0],\n",
       " [2003.0, 1991.0, 1990.0, 2019.0, 2006.0]]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados.tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bHxcxugPltpx"
   },
   "source": [
    "### 4.7. `ndarray.reshape(shape[, order])`\n",
    "Retorna um _array_ que contém os mesmos dados com uma nova forma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "lwESxO71ltpx",
    "outputId": "25e45d80-e0ac-42d1-cb75-c284a7974264"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contador = np.arange(10)\n",
    "contador"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 102
    },
    "colab_type": "code",
    "id": "sh9poyfzltpy",
    "outputId": "749190d1-f59e-4e86-f134-46bc32af6400"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5],\n",
       "       [6, 7],\n",
       "       [8, 9]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contador.reshape((5,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que a nova forma deve ser capaz de conter todos os elementos originais:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 102
    },
    "colab_type": "code",
    "id": "5332Xu8-ltpy",
    "outputId": "be1bd786-2632-4740-f356-1ece1681bad2"
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "cannot reshape array of size 10 into shape (3,3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-62-aecde39673a4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mcontador\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: cannot reshape array of size 10 into shape (3,3)"
     ]
    }
   ],
   "source": [
    "contador.reshape((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "cannot reshape array of size 10 into shape (3,4)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-63-8b0e74855a68>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mcontador\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: cannot reshape array of size 10 into shape (3,4)"
     ]
    }
   ],
   "source": [
    "contador.reshape((3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.7.1. Indexação\n",
    "Por padrao, a indexação utilizada é a da linguagem C, mas podem ser usadas outras, como por exemplo a do Fortran:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 102
    },
    "colab_type": "code",
    "id": "2RoZvbgHltpz",
    "outputId": "00c856c5-6b66-4bba-9cae-54882c1fb729"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5],\n",
       "       [6, 7],\n",
       "       [8, 9]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contador.reshape((5,2), order='C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 5],\n",
       "       [1, 6],\n",
       "       [2, 7],\n",
       "       [3, 8],\n",
       "       [4, 9]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contador.reshape((5,2), order='F')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos utilizar um exemplo para verificar a utilidade deste método. Partindo de duas listas que contém a quilometragem e o ano de fabricação de cinco carros. Vamos concatenar as duas listas, transformar a resultante em um _array_ e alterar sua forma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6q0dJZ-dltp0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[44410, 5712, 37123, 0, 25757, 2003, 1991, 1990, 2019, 2006]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "km = [44410, 5712, 37123, 0, 25757]\n",
    "anos = [2003, 1991, 1990, 2019, 2006]\n",
    "info_carros = km + anos\n",
    "info_carros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos alterar a forma do _array_ unidimensional para um bidimensional de 2 linhas e cinco colunas, com a primeira linha contendo a quilometragem e a segunda os anos de fabricação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "bs56aGrkltp0",
    "outputId": "151668b5-b428-4139-a941-091203c8a827"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410,  5712, 37123,     0, 25757],\n",
       "       [ 2003,  1991,  1990,  2019,  2006]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(info_carros).reshape((2,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "s_GkTk2fltp1",
    "outputId": "9e6b7037-8ec0-485d-fc38-c3189e728caf"
   },
   "source": [
    "Mas também podemos mudar a forma para auma matriz de 5 linhas e 2 colunas, assim, ao invés de termos cada carro representado por uma coluna, teremos um carro por linha. Para isso basta alterar o tipo de indexação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 102
    },
    "colab_type": "code",
    "id": "xodm8DVZltp1",
    "outputId": "7fe87021-3ac5-4e5b-cb64-c24739104564"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410,  2003],\n",
       "       [ 5712,  1991],\n",
       "       [37123,  1990],\n",
       "       [    0,  2019],\n",
       "       [25757,  2006]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(info_carros).reshape((5,2), order='F')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Tdj5iArbltp2"
   },
   "source": [
    "### 4.8. `ndarray.resize(new_shape[, refcheck])`\n",
    "Altera a forma e o tamanho do array.\n",
    "\n",
    "Já sabemos que para fazer uma cópia de um _array_ não basta apenas atribuir este _array_ a uma variável, dessa forma estamos apenas passando a referência a este _array_. Mas mesmo quando fazemos a cópia de um _array_ usando o método `copy()`, ainda existe uma refência entre os dois _arrays_.\n",
    "\n",
    "Podemos verificar este comportamento usando o método `resize()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "vB2zxCDtltp2",
    "outputId": "1709d905-c9b5-4365-9e40-08b422050b09"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410.,  5712., 37123.,     0., 25757.],\n",
       "       [ 2003.,  1991.,  1990.,  2019.,  2006.]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_dados = dados.copy()\n",
    "new_dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "IMv0m4Multp2"
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "cannot resize an array that references or is referenced\nby another array in this way.\nUse the np.resize function or refcheck=False",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-70-e9618c30a705>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnew_dados\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mresize\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: cannot resize an array that references or is referenced\nby another array in this way.\nUse the np.resize function or refcheck=False"
     ]
    }
   ],
   "source": [
    "new_dados.resize((3,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perceba que quando tentamos aumentar o tamanho do _array_ obtemos um erro, pois não foi especifícado que a referência ao _array_ original devia ser ignorada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "wpAi9928ltp3",
    "outputId": "3e74adf2-de07-4f6b-e753-f2c8e352fbcf"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44410.,  5712., 37123.,     0., 25757.],\n",
       "       [ 2003.,  1991.,  1990.,  2019.,  2006.],\n",
       "       [    0.,     0.,     0.,     0.,     0.]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_dados.resize((3,5), refcheck=False)\n",
    "new_dados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que aumentamos o tamanho, adicionando uma linha, podemos colocar a quilometragem média nesta nova linha.  \n",
    "Obs.: É apresentada a matriz transposta apenas por fins estéticos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "CJyuKqaFltp3",
    "outputId": "aa61e9f3-ae59-4bae-80f7-7721129c6c83"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\cesar\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[44410.        ,  2003.        ,  2775.625     ],\n",
       "       [ 5712.        ,  1991.        ,   204.        ],\n",
       "       [37123.        ,  1990.        ,  1280.10344828],\n",
       "       [    0.        ,  2019.        ,            nan],\n",
       "       [25757.        ,  2006.        ,  1981.30769231]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_dados[2] = new_dados[0] / (2019 - new_dados[1])\n",
    "new_dados.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 119
    },
    "colab_type": "code",
    "id": "bj_iPZAultp4",
    "outputId": "89d42d11-ba8f-45f0-eae7-ef8cdcda706d"
   },
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GPSk7Q_Dltp4"
   },
   "source": [
    "## 5. Estatísticas com arrays Numpy<a id='5'></a>\n",
    "\n",
    "Agora vamos explorar alguns métodos utilizados para calcular grandezas estatísticas. Vamos passar apenas pelos mais comuns, caso você queira conhecer outros métodos para cálculos [estatísticos](https://numpy.org/doc/1.17/reference/routines.statistics.html) e [matemáticos](https://numpy.org/doc/1.17/reference/routines.math.html), pode acessar a documentação.\n",
    "\n",
    "Vamos começar carregando três arquivos para _arrays_ NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RH2u1orXltp5"
   },
   "outputs": [],
   "source": [
    "anos = np.loadtxt(fname='data/carros-anos.txt', dtype = int)\n",
    "km = np.loadtxt(fname='data/carros-km.txt')\n",
    "valor = np.loadtxt(fname='data/carros-valor.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "wbITF7r6ltp5",
    "outputId": "b8aa6e88-3d2a-4bd8-801b-211fd0cbc6eb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(258,)\n",
      "(258,)\n",
      "(258,)\n"
     ]
    }
   ],
   "source": [
    "print(anos.shape)\n",
    "print(km.shape)\n",
    "print(valor.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "U_x3SOVDltp7"
   },
   "source": [
    "Podemos ver os três _arrays_ são unidimensionais, portanto, vamos juntá-los em apenas um. Para isso vamos usar o método [`column_stack()`](https://numpy.org/doc/1.17/reference/generated/numpy.column_stack.html) que coloca cada _array_ como uma coluna do novo _array_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "wefxl-XBltp8",
    "outputId": "7d31e768-4d29-4c2e-8893-0b71f1bf1da1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  2003.  ,  44410.  ,  88078.64],\n",
       "       [  1991.  ,   5712.  , 106161.94],\n",
       "       [  1990.  ,  37123.  ,  72832.16],\n",
       "       [  2019.  ,      0.  , 124549.07],\n",
       "       [  2006.  ,  25757.  ,  92612.1 ],\n",
       "       [  2012.  ,  10728.  ,  97497.73],\n",
       "       [  2019.  ,      0.  ,  56445.2 ],\n",
       "       [  2009.  ,  77599.  , 112310.44],\n",
       "       [  2010.  ,  99197.  , 120716.27],\n",
       "       [  2011.  ,  37978.  ,  76566.49]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset = np.column_stack((anos, km, valor))\n",
    "dataset[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "OzDTTmj8ltp_",
    "outputId": "ab5c3112-2b74-4adb-8129-6efecc5a0856",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(258, 3)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Me6yUU_RltqA"
   },
   "source": [
    "### 5.1. `np.mean()`\n",
    "\n",
    "Retorna a média dos elementos do array ao longo do eixo especificado.\n",
    "\n",
    "Se o eixo não for especificado, o método vai simplesmente retornar a média de todos os elementos do _array_. Você pode obter mais [informações](https://numpy.org/doc/1.17/reference/arrays.ndarray.html#calculation) sobre o argumento `axis` na documentação."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "MNEKcP38ltqA",
    "outputId": "b88f235c-a375-44c8-b30c-2c7b9a176714"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2007.51162791, 44499.41472868, 98960.51310078])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# calcula a média de todas as colunas, ou seja, ao longo do eixo vertical\n",
    "np.mean(dataset, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Considerando que não faz sentido calcular a média do ano de fabricação, podemos excluir esta coluna do cálculo. Fazendo um fatiamento no _array_ `dataset` para obter todas as linhas e retirar a primeira coluna:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "sekHQ84zltqB",
    "outputId": "80164c3a-6f6b-4774-dc17-88930e1fac58"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([44499.41472868, 98960.51310078])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(dataset[:, 1:], axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "71jViVBUltqE"
   },
   "source": [
    "### 5.2. `np.std()`\n",
    "\n",
    "Retorna o desvio padrão dos elementos do array ao longo do eixo especificado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "lEwUbPx2ltqE",
    "outputId": "50758772-5a03-4041-e067-5208434654cd",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98960.51310077519"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# calcula apenas para o valor dos carros\n",
    "np.mean(dataset[:, 2], axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JTUH-vAeltqG"
   },
   "source": [
    "### 5.3. `ndarray.sum()`\n",
    "\n",
    "Retorna a soma dos elementos do array ao longo do eixo especificado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "jIi3yoaWltqG",
    "outputId": "74d5043b-9e9d-4231-bf71-a8d127df0fa8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  517938.        , 11480849.        , 25531812.37999999])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.sum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "X3QYbdYLltqH",
    "outputId": "c5baaa9e-a26c-4baf-844c-0dbeaddf2c05"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11480849.0"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# calcula a quilometragem rodada por todos os carros\n",
    "dataset[:,1].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WbBD5ixaltqH"
   },
   "source": [
    "### 5.3. `np.sum()`\n",
    "\n",
    "Retorna a soma dos elementos do array ao longo do eixo especificado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "omB6kgWgltqH",
    "outputId": "dc6ccc67-663e-4960-fcb6-7679473254d6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  517938.        , 11480849.        , 25531812.37999999])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(dataset, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "LiD4G3kQltqI",
    "outputId": "7f4a5b05-15fe-45dc-b4fa-3bd405ccea45"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25531812.38"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# calcula o valor total de todos os carros\n",
    "np.sum(dataset[:,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kpakpnntltqJ"
   },
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "Python_para_Data_Science_Numpy.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}