NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Alt text](https://gistcdn.githack.com/Gbecdox/a45fd09fda68fc656788b7a510ae103d/raw/11f2c6ca24c2f0dd882f98b4ddd1a19a23c7cfd9/HeaderNUM.svg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesse notebook veremos sobre:\n",
    "\n",
    "* **Criação e atributos de ndarrays**\n",
    "\n",
    "* **Tópicos de *indexing* e *slicing***\n",
    "\n",
    "* **Modificação de ndarrays**\n",
    "\n",
    "* **Operações com uma ou mais ndarrays**\n",
    "\n",
    "* **Operadores lógicos**\n",
    "\n",
    "* **Funções randômicas**\n",
    "\n",
    "* **Funções matemáticas**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introdução"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importando e entendendo o funcionamento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de iniciarmos com as aplicações do pacote, vamos entender o essencial: as principais distinções entre as *arrays* do NumPy e as listas nativas do Python. Para isso, elencamos abaixo algumas diferenças fundamentais.\n",
    "\n",
    "**No Python, uma lista:**\n",
    "* pode ser composta por diferentes estruturas de dados, por exemplo, em uma mesma lista podemos ter *strings*, *floats* e inteiros;\n",
    "* possui tamanho variável, isto é, toda vez que se adicionam ou se removem elementos dela, ela é atualizada.\n",
    "\n",
    "\n",
    "**No Numpy, uma ndarray:**\n",
    "* sempre contém uma única estrutura de dados em seu interior, então o pacote sempre irá procurar uma forma de converter todos os dados passados para um mesmo tipo;\n",
    "* possui tamanho fixo, então quando são adicionados ou removidos elementos de uma ndarray ocorre que, na verdade, ela é deletada e cria-se uma nova, tudo automaticamente.\n",
    "\n",
    "Além disso, um fator chave da biblioteca é a diversidade de operações matemáticas que ela traz consigo, operações essas que, no Python nativo, muitas vezes teriam que ser implementadas do zero e ainda estariam sob o risco de possuir um maior tempo de execução. Sem mais, vamos começar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "**Observação:** caso você não esteja habituado à nomenclatura, é importante saber que\n",
    "\n",
    "* ***array*** é, em programação, uma estrutura de dados. Trata-se de um conjunto de elementos que devem ser passíveis de identificação através de um índice ou de uma chave (comumente, é traduzido para o português como \"matriz\", \"vetor\" ou \"arranjo\");\n",
    "\n",
    "* **ndarray** (*n-dimensional array*) é a classe de *arrays* do NumPy, considerada o objeto principal do pacote.\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Criando *arrays* do NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Com auxílio de estruturas do Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Muitos são os métodos possíveis para se criar uma ndarray. Começaremos tudo utilizando a função `np.array()`, ela recebe um `array_like`, basicamente, qualquer estrutura de dados que possa ser convertida em uma ndarray (e.g. inteiros, tuplas, listas, dentre outros) e o transforma em uma ndarray. Caso seja do seu interesse, uma definição mais elaborada de um `array_like` pode ser encontrada através do [Stack Overflow](https://stackoverflow.com/questions/40378427/numpy-formal-definition-of-array-like-objects). De qualquer forma, vamos criar e visualizar as variáveis que transformaremos em ndarrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # Define L como uma lista.\n",
    "T = (\"a\", \"b\", \"c\")                 # Define T como uma tupla.\n",
    "I = 42                              # Define I como um inteiro."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Embora seja dispensável, vamos apenas confirmar se obtivemos o esperado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L (tipo): <class 'list'>\n",
      "T (tipo): <class 'tuple'>\n",
      "I (tipo): <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(\"L (tipo):\", type(L)) # Imprime o tipo de L.\n",
    "print(\"T (tipo):\", type(T)) # Imprime o tipo de T.\n",
    "print(\"I (tipo):\", type(I)) # Imprime o tipo de I."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tudo certo! Então vamos convertê-las para ndarrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "L_np = np.array(L) # Converte L para uma array do NumPy, atribui para L_np.\n",
    "T_np = np.array(T) # Converte T para uma array do NumPy, atribui para T_np.\n",
    "I_np = np.array(I) # Converte I para uma array do NumPy, atribui para I_np."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pronto! Assim já temos as *arrays* do Numpy, como podemos averiguar abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L_np (tipo): <class 'numpy.ndarray'>\n",
      "T_np (tipo): <class 'numpy.ndarray'>\n",
      "I_np (tipo): <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(\"L_np (tipo):\", type(L_np)) # Imprime o tipo de L_np.\n",
    "print(\"T_np (tipo):\", type(T_np)) # Imprime o tipo de T_np.\n",
    "print(\"I_np (tipo):\", type(I_np)) # Imprime o tipo de I_np."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último, para fins meramente comparativos, vamos exibir as variáveis antes e após a conversão."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "L_np: [ 1  2  3  4  5  6  7  8  9 10]\n",
      "\n",
      "T: ('a', 'b', 'c')\n",
      "T_np: ['a' 'b' 'c']\n",
      "\n",
      "I: 42\n",
      "I_np: 42\n"
     ]
    }
   ],
   "source": [
    "print(\"L:\", L)                   # Imprime L.\n",
    "print(\"L_np:\", L_np, end=\"\\n\\n\") # Imprime L_np e pula uma linha.\n",
    "\n",
    "print(\"T:\", T)                   # Imprime T.\n",
    "print(\"T_np:\", T_np, end=\"\\n\\n\") # Imprime T_np e pula uma linha.\n",
    "\n",
    "print(\"I:\", I)                   # Imprime I.\n",
    "print(\"I_np:\", I_np)             # Imprime I_np."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diretamente através do NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se não quisermos utilizar as estruturas de dados do Python para criar ndarrays, é fácil então recorrer a outras funções da biblioteca para realizar isso diretamente, ilustremos algumas:\n",
    "\n",
    "* `np.arange()`: especificado um intervalo, retorna uma ndarray **unidimensional** com elementos igualmente espaçados no interior dele.\n",
    "* `np.linspace()`: especificado um intervalo, retorna uma ndarray de variadas dimensões com elementos igualmente espaçados no interior dele.\n",
    "* `np.zeros()`: especificada uma dimensão, retorna uma ndarray com todos os elementos iguais a 0.\n",
    "* `np.ones()`: especificada uma dimensão, retorna uma ndarray com todos os elementos iguais a 1.\n",
    "* `np.full()`: especificada uma dimensão, retorna uma ndarray com todos os elementos iguais a um certo valor.\n",
    "* `np.empty()`: especificada uma dimensão, retorna uma ndarray com elementos arbitrários, isto é, números essencialmente randômicos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.arange( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para começar, vamos nos aprofundar na primeira função citada. Ao usarmos `np.arrange()` definimos os seguintes argumentos:\n",
    "\n",
    "* `start`: um `scalar` que demarca o início do intervalo — fechado (maior ou igual);\n",
    "* `stop`: um `scalar` que demarca o final do intervalo — aberto (estritamente menor);\n",
    "* `step`: passo, o espaçamento entre os elementos do intervalo;\n",
    "* `dtype`: o tipo (a estrutura de dados) dos elementos da ndarray.\n",
    "\n",
    "Caso deseje, exemplos para o `scalar` que citamos podem ser vistos experimentando o comando `np.ScalarType` ou, mais uma vez, através do [Stack Overflow](https://stackoverflow.com/questions/21968643/what-is-a-scalar-in-numpy). De qualquer modo, no âmbito desse notebook, estaremos considerando um `scalar` simplesmente como um número do tipo `int` ou `float`, por exemplo. Vamos às aplicações."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 1: [0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 1:\", np.arange(0, 10, 1, int)) # start=0; stop=10; step=1; dtype=int."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas é mesmo preciso definir explicitamente todos esses argumentos? Como já deve imaginar, não. Temos por padrão: `start=0`, `step=1` e `dtype` ajustado coerentemente a estrutura de dados dos outros parâmetros. Ora, podemos então simplificar o comando e obter essa mesma saída fazendo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 2: [0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 2:\", np.arange(10)) # start=0; stop=10; step=1; dtype=type(10)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variando um pouco os argumentos, temos um terceiro exemplo para ilustrar melhor o comportamento da função. Confira:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 3: [12. 14. 16. 18. 20. 22.]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 3:\", np.arange(12.0, 24, 2)) # Note que o tipo float se sobressai sobre o tipo int para inferir o dtype."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.linspace( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A próxima função que abordaremos será a `np.linspace()`. Em relação à função anterior, temos algumas diferenças importantes para ressaltar, que vão além da questão da dimensionalidade. Para facilitar, vamos às divergências:\n",
    "\n",
    "* `start`: um `array_like` que demarca o início do intervalo — fechado (maior ou igual);\n",
    "* `stop`: um `array_like` que demarca o final do intervalo — por padrão, fechado (menor ou igual);\n",
    "* `num`: a quantidade de elementos no interior do intervalo;\n",
    "* `endpoint`: quando `True` (*default*) inclui o valor de `stop` no intervalo, quando `False`, não o inclui;\n",
    "* `retstep`: quando `True`, retorna também o passo dos valores do intervalo, quando `False` (*default*), não.\n",
    "\n",
    "Retomando os exemplos, vamos primeiro fazer uma construção passando inteiros para `start` e `stop`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 4: [ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 4:\", np.linspace(0, 10, 11)) # start=0; stop=10; num=11; endpoint=True; retstep=False; dtype=float."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se quisermos ndarrays com duas dimensões (matrizes), por exemplo, podemos então passar listas (sempre de tamanhos iguais) para `start` e `stop`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 5:\n",
      "[[ 1  2  3  4]\n",
      " [ 1  4 11 24]\n",
      " [ 1  6 19 44]\n",
      " [ 1  8 27 64]]\n"
     ]
    }
   ],
   "source": [
    "# start=[1, 2, 3, 4]; stop=[1, 8, 27, 64]; num=4; endpoint=True; retstep=False; dtype=int.\n",
    "print(\"Exemplo 5:\", np.linspace([1, 2, 3, 4], [1, 8, 27, 64], 4, dtype=int), sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por fim, ao usarmos `retstep=True` a função retornará uma tupla de dois elementos, tais que: o primeiro (de índice 0) é a ndarray desejada e o segundo (de índice 1) é o passo dos elementos da ndarray. Vejamos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 6: (array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]), 1.0)\n",
      "\n",
      "Ndarray: [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]\n",
      "Passo: 1.0\n"
     ]
    }
   ],
   "source": [
    "A = np.linspace(0, 10, 10, endpoint=False, retstep=True) # Cria A, uma tupla que contém a ndarray e o passo.\n",
    "\n",
    "print(\"Exemplo 6:\", A, end=\"\\n\\n\") # Imprime A e pula uma linha.\n",
    "\n",
    "print(\"Ndarray:\", A[0]) # Imprime a ndarray.\n",
    "print(\"Passo:\", A[1])   # Imprime o passo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.zeros( ), np.ones( ) e np.full( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para as próximas três funções: `np.zeros()`, `np.ones()` e `np.full()`, teremos um funcionamento semelhante. Na verdade, como somente um mesmo elemento irá compor cada uma das ndarrays, apenas precisaremos definir\n",
    "\n",
    "* `shape`: a dimensão da ndarray, para as três funções;\n",
    "* `fill_value`: o elemento que irá compor ndarray, para a `np.full()`.\n",
    "\n",
    "Quanto à dimensão, podemos passar como argumento para `shape` um inteiro e obter uma ndarray unidimensional, ou então uma tupla e teremos uma ndarray com mais dimensões. Vamos demonstrar tudo isso com mais alguns exemplos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 7: [0 0 0 0 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 7:\", np.zeros(7, int)) # shape=7 (unidimensional); dtype=int."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 8:\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 8:\", np.ones((3,3)), sep=\"\\n\") # shape=(3,3) (bidimensional); dtype=float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 9:\n",
      "[[6 6 6 6 6]\n",
      " [6 6 6 6 6]\n",
      " [6 6 6 6 6]\n",
      " [6 6 6 6 6]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 9:\", np.full((4,5), 6), sep=\"\\n\") # shape=(4,5) (bidimensional); fill_value=6; dtype=type(6)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.empty( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de continuarmos com a `np.empty()` talvez seja interessante entender melhor um conceito que abordamos há pouco, quando a função foi apresentada. Lá, citamos a expressão \"números arbitrários\" querendo nos referir a números que fossem de fato aleatórios, isto é, tomados ao acaso. Por outros termos, pretendiamos dizer que a `np.empty()` não gerou esses valores para compor a ndarray, a grosso modo, podemos pensar que \"já havia valores na memória do computador e a ndarray foi apenas ali alocada\".\n",
    "\n",
    "Uma diferença importante desse processo para aquele cujas as funções ditas randômicas (tais quais as da biblioteca `random` do Python) fazem, é o tempo de execução. A exemplo, ao aplicar uma função como `random.randrange()` estamos gerando **pseudo-random numbers**: números obtidos através de uma construção matemática que busca simular a aleatoriedade. Pois então, é evidente que esse processo deva consumir um maior tempo, haja vista a necessidade de se realizarem todos os cálculos.\n",
    "\n",
    "Assim, embora a ndarray criada com a `np.empty()` possua valores que, muito provavelmente, não serão do nosso interesse e, portanto, precisaremos substitui-los, temos a vantagem reduzir o tempo de sua criação — em especial, quando estamos trabalhando com grandes dimensões."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 10:\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "\n",
      "Exemplo 11:\n",
      "[[9. 8. 7.]\n",
      " [6. 5. 4.]\n",
      " [3. 2. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# Usando np.empty(), imprime uma matriz 3x3.\n",
    "print(\"Exemplo 10:\", np.empty((3,3)), sep=\"\\n\")\n",
    "\n",
    "# Define uma matriz 3x3 qualquer, sem imprimi-la ou atribui-la a uma variável.\n",
    "np.array([[9., 8., 7.], \n",
    "          [6., 5., 4.], \n",
    "          [3., 2., 1.]])\n",
    "\n",
    "# Usando np.empty(), imprime uma matriz 3x3.\n",
    "print(\"\\nExemplo 11:\", np.empty((3,3)), sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nos casos a cima, perceba que obtivemos saídas diferentes apenas definindo uma nova matriz quadrada de ordem 3, ainda que sem atribui-la a alguma variável. No **Exemplo 10** temos uma cópia do **Exemplo 8**; no **11**, uma outra matriz. Eis então uma demonstração da função `np.empty()` apenas \"utilizar o que já está pronto\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "**Aviso:** executar as células em uma ordem que não seja a esperada (da primeira para a última) poderá alterar as saídas dos dois exemplos.\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Atributos de uma ndarray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tal qual uma lista nativa do Python possui, por exemplo, um tamanho; as ndarrays também contam com atributos que as definem, a saber\n",
    "\n",
    "* `ndarray.ndim`: o número de dimensões (**eixos** ou ***axis***, no inglês) de uma ndarray.\n",
    "* `ndarray.shape`: o tamanho das dimensões, uma tupla de inteiros que indica o tamanho da ndarray em cada eixo.\n",
    "* `ndarray.size`: o número total de elementos de uma ndarray.\n",
    "* `ndarray.dtype`: o tipo (a estrutura de dados) dos elementos que compõem uma ndarray.\n",
    "* `ndarray.itemsize`: o tamanho dos elementos de uma ndarray em **bytes**.\n",
    "\n",
    "Para verificar cada um desses atributos, vamos antes definir uma matriz **B**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.array([[1, 2, 3],\n",
    "              [4, 5, 6],\n",
    "              [7, 8, 9]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora, em ordem, trabalharemos cada um deles e algumas de suas particularidades."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ndarray.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número de dimensões de B: 2\n"
     ]
    }
   ],
   "source": [
    "print(\"Número de dimensões de B:\", B.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ndarray.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tamanho das dimensões de B: (3, 3)\n"
     ]
    }
   ],
   "source": [
    "print(\"Tamanho das dimensões de B:\", B.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ora, quando utilizamos `B.shape` descobrimos que os tamanhos de **B** no **eixo 0** e no **eixo 1** é 3. Mas também estamos, implicitamente, inferindo que **B** possui duas dimensões (dois eixos), isso nos permite uma nova construção que torna o uso de `B.ndim` prescindível. Observe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número de dimensões de B: 2\n"
     ]
    }
   ],
   "source": [
    "print(\"Número de dimensões de B:\", len(B.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Em síntese:** a quantidade de inteiros na tupla é igual ao número de dimensões e os inteiros nela presentes, os tamanhos de cada dimensão."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ndarray.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total de elementos de B: 9\n"
     ]
    }
   ],
   "source": [
    "print(\"Total de elementos de B:\", B.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos notar aqui uma outra relação existente entre os atributos e que também envole `B.shape`. O número total de elementos em uma ndarray é, na verdade, o produto dos tamanhos das dimensões (ou como acabamos de dizer, o produto dos inteiros que compõem a tupla `B.shape`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total de elementos de B: 9\n"
     ]
    }
   ],
   "source": [
    "print(\"Total de elementos de B:\", B.shape[0] * B.shape[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ndarray.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tipo (estrutura de dados) dos elementos de B: int32\n"
     ]
    }
   ],
   "source": [
    "print(\"Tipo (estrutura de dados) dos elementos de B:\", B.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ndarray.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tamanho dos elemento de B: 4 bytes\n"
     ]
    }
   ],
   "source": [
    "print(\"Tamanho dos elemento de B:\", B.itemsize, \"bytes\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Duas observações pertinentes a respeito de `B.itemsize`:\n",
    "\n",
    "* é devolvido apenas o valor numérico (**4**, nesse caso) e\n",
    "* 1 byte é equivalente a 8 bits, ou seja, a estrutura `int32` possui 4 bytes (32 bits)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *Indexing* e *slicing*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que já foi abordado o conceito de dimensão, trabalharemos com mais um item imprescindível de qualquer *array*: os índices. Vamos nos centrar em algumas técnicas que permitem obter tanto um elemento específico de uma ndarray, quanto um segmento (uma \"fatia\") dessa por meio de índices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Basic Indexing*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com o uso do NumPy podemos fazer a indexação básica (mais à frente a diferenciaremos melhor) por meio de alguns modos, sendo do nosso interesse focar em dois mais usuais:\n",
    "\n",
    "* analogamente ao que já conhecemos do Python, quanto à indexação de listas e tuplas, por exemplo;\n",
    "* próprio do NumPy, no qual os índices a serem acessados devem todos estar dentro de um mesmo par de colchetes e serem, entre si, separados por vírgula.\n",
    "\n",
    "Para exemplificar, definiremos **D1** e **D2**, ndarrays de diferentes dimensões."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define D1: uma ndarray unidimensional.\n",
    "D1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "\n",
    "# Define D2: uma ndarray bidimensional.\n",
    "D2 = np.array([[1., 2., 3.],\n",
    "               [4., 5., 6.],\n",
    "               [7., 8., 9.]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Relembrando, temos abaixo uma guia que ilustra como é feita a leitura de índices no Python em ambos os sentidos: da esquerda para direita (convencional) ou da direita para esquerda. É importante perceber que, na leitura convencional, o primeiro elemento possui índice 0; o segundo, índice 1; o terceiro, índice 2 e assim sucessivamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float: left;\" src=https://i.ibb.co/Fbh4JSc/D1.png, width=340>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como **D1** é uma ndarray unidimensional, temos, no nosso caso, apenas uma alternativa para indexação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Primeiro elemento de D1: 1\n",
      "Último elemento de D1: 9\n"
     ]
    }
   ],
   "source": [
    "print(\"Primeiro elemento de D1:\", D1[0]) # Análogo ao Python\n",
    "print(\"Último elemento de D1:\", D1[-1])  # Análogo ao Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Contudo, para **D2** ambos os modos citados anteriormente são possíveis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Primeira linha e primeira coluna de D2: 1.0\n",
      "Primeira linha e terceira coluna de D2: 3.0\n"
     ]
    }
   ],
   "source": [
    "print(\"Primeira linha e primeira coluna de D2:\", D2[0][0]) # Análogo ao Python\n",
    "print(\"Primeira linha e terceira coluna de D2:\", D2[0,2])  # Próprio do NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ainda que os resultados sejam equivalentes, utilizar as vírgulas é preferível, pois torna a escrita mais econômica e a leitura mais clara, haja vista que para uma grande quantidade de dimensões o uso de colchetes pode se tornar excessivo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "**Importante:** tanto `D2[0,2]` quanto `D2[(0,2)]` possuem saídas iguais. Não consideramos esse último um terceiro método pois, na verdade, o NumPy cria uma tupla com as informações no interior dos colchetes sempre que necessário. Além disso, são **os tipos dos dados no interior dessa tupla** os responsáveis pela distinção entre *basic indexing* e *advanced indexing*. Se julgar necessário, é possível se [aprofundar](https://www.pythonlikeyoumeanit.com/Module3_IntroducingNumpy/BasicIndexing.html). \n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Advanced Indexing*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trataremos somente um caso (de grande relevância) da indexação avançada, trata-se do uso de **expressões booleanas**. Basicamente, enquanto na indexação básica usavamos, por exemplo, os inteiros dentro dos colchetes, agora estaremos utilizando uma comparação que nos retorna `True` ou `False`. A vantagem disso é que tal artifício nos permite, por exemplo, \"filtrar\" valores de uma ndarray: teremos como retorno somente os elementos que satisfaçam a condição imposta. Observe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elementos de D1 maiores do que 5: [6 7 8 9]\n",
      "Elementos de D1 menores do que 3: [1 2]\n"
     ]
    }
   ],
   "source": [
    "print(\"Elementos de D1 maiores do que 5:\", D1[D1 > 5])\n",
    "print(\"Elementos de D1 menores do que 3:\", D1[D1 < 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviamente, podemos utilizar nessas comparações quaisquer que sejam os operadores relacionais (`==`, `!=`, `>`, `>=`, `<` e `<=`), inclusive, com ndarrays de mais dimensões:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elementos de D2 maiores ou iguais a 6: [6. 7. 8. 9.]\n",
      "Elementos de D2 diferentes de 2: [1. 3. 4. 5. 6. 7. 8. 9.]\n"
     ]
    }
   ],
   "source": [
    "print(\"Elementos de D2 maiores ou iguais a 6:\", D2[D2 >= 6])\n",
    "print(\"Elementos de D2 diferentes de 2:\", D2[D2 != 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Slicing*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para realizar os cortes seguiremos o caminho análogo ao do Python: no interior de um par de colchetes teremos inteiros separados pelo sinal de dois pontos. Melhor explicando, podemos afirmar que a notação será da forma `[start:stop:step]`, na qual:\n",
    "\n",
    "* `start` é o índice que determina o início do corte, inclui-se o elemento de índice `start` no corte;\n",
    "* `stop` é o índice que determina o final do corte, exclui-se o elemento de índice `stop` no corte;\n",
    "* `step` é o passo dos índices.\n",
    "\n",
    "Aliás, é importante saber que o *default* para cada um dos parâmetros é:\n",
    "\n",
    "* `start=0`, o primeiro elemento da ndarray;\n",
    "* `stop=n`, sendo `n` o número de elementos na dimensão cortada da ndarray;\n",
    "* `step=1`, evitando \"pular\" algum elemento.\n",
    "\n",
    "Ainda, é interessante notar que se todos os três parâmetros possuem um valor pré-definido, podemos então omiti-los sem incorrer em um erro de sintaxe. Vejamos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D1: [1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "print(\"D1:\", D1[:]) # start=0; stop=9; step=1; a expressão D1[::] é válida e equivalente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos agora ver alguns outros casos para **D1** que, no geral, não se distanciam daquilo que já conhecemos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Do 2º ao 4º elemento de D1: [2 3 4]\n",
      "Do 1º ao 8º elemento de D1: [1 2 3 4 5 6 7 8]\n",
      "Do 3º ao 9º elemento de D1 com passo 2: [3 5 7 9]\n"
     ]
    }
   ],
   "source": [
    "print(\"Do 2º ao 4º elemento de D1:\", D1[1:4])              # start=1; stop=4; step=1\n",
    "print(\"Do 1º ao 8º elemento de D1:\", D1[:8])               # start=0; stop=8; step=1\n",
    "print(\"Do 3º ao 9º elemento de D1 com passo 2:\", D1[2::2]) # start=2; stop=9; step=2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como deve ter notado com os exemplos, quando utilizamos dentro dos colchetes somente um único sinal de `:` será feita a leitura de um valor para `start` e doutro para `stop`, sendo apenas possível alterar o valor de `step` se utilizarmos um segundo `:`. Por último, tome cuidado ao definir o passo quando estiver utilizando índices negativos, pois esse também deverá ser menor do que zero para se percorrer a ndarray no sentido não convencional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Do 8º ao 1º elemento: [8 7 6 5 4 3 2 1]\n"
     ]
    }
   ],
   "source": [
    "print(\"Do 8º ao 1º elemento:\", D1[-2:-10:-1]) # Equivalentemente: D1[-2::-1]."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trabalhando agora as ndarrays com mais eixos, teremos o *slicing* sem grandes novidades, basta apenas separar com uma vírgula o corte em cada uma das dimensões. Com o auxílio da guia abaixo, na qual temos **D2** e seus dois eixos (**0:** linhas; **1:** colunas), retomaremos os exemplos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float: left;\" src=https://i.ibb.co/QHB54S2/D2.png, width=300>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Segunda linha de D2: [[4. 5. 6.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Segunda linha de D2:\", D2[1:2,:]) # No eixo 0 (linhas): start=1; stop=2; step=1 # No eixo 1 (colunas): start=0; stop=3; step=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na construção a cima, indicamos o corte no **eixo 0** com `1:2` e, após a vírgula, o corte no **eixo 1** através de `:`. Mas, nesse caso, podemos ser ainda mais econômicos: basta apenas escrever `D2[1:2]`. Por outros termos, quando omitimos o corte em uma dimensão, pressupõe-se que queremos exibi-la por inteiro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dois últimos elementos da última coluna de D2:\n",
      "[[6.]\n",
      " [9.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Dois últimos elementos da última coluna de D2:\", D2[1:,2:], sep=\"\\n\") # Equivalentemente: D2[1:3:1,2:3:1]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Menor submatriz quadrada de ordem 2 em D2:\n",
      "[[1. 2.]\n",
      " [4. 5.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Menor submatriz quadrada de ordem 2 em D2:\", D2[:2,:2], sep=\"\\n\") # Equivalentemente: D2[0:2:1,0:2:1]."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modificando *arrays* do NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviamente não precisamos criar uma ndarray da forma como a usaremos, inclusive, podemos fazer algumas modificações por meio de *indexing* e *slicing*, como vimos. Mas agora vamos empregar algumas funções do NumPy destinadas, justamente, a realizar alterações em ndarrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Remodelando"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Começaremos por `np.reshape()`, para essa função passaremos dois argumentos: (1) uma ndarray e (2) as dimensões desejadas para ela. Ao final, teremos como retorno uma cópia da ndarray inicial após ser \"remodelada\". Para exemplificar, vamos recriar nossa matriz **B**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.arange(1, 10)     # Define b: uma ndarray unidimensional com inteiros do 1 ao 10 (não incluído) e passo 1\n",
    "B = np.reshape(b, (3,3)) # Define B: reorganização de b como uma matriz quadrada de ordem 3 (ndarray bidimensional)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Já trabalhamos isso com maior cautela, mas novamente: repare que através da tupla passamos duas informações, isto é\n",
    "\n",
    "* o número de dimensões (a quantidade de elementos na tupla — seu comprimento) e\n",
    "* o tamanho das dimensões (os inteiros que compõem a tupla).\n",
    "\n",
    "Apenas não se esqueça de tomar cuidado para garantir que o número de elementos permaneça igual antes e depois da transformação. Por último, lembre-se de que para eventuais dúvidas a [documentação](https://numpy.org/doc/1.17/reference/generated/numpy.reshape.html) pode ajudar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "print(B) # Visualização da matriz que acabamos de recriar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também querer fazer o procedimento inverso, isto é, se por algum acaso quisermos transformar uma ndarray qualquer em uma ndarray unidimensional utilizamos a `np.reshape()`, como vemos no exemplo abaixo, no qual imprimimos a matriz **B** \"planificada\" (equivalente à **b**)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "print(np.reshape(B, (9,))) # Impressão de B em uma forma unidimensional."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Felizmente, essa não é a nossa única alternativa. Tanto a função `np.ravel()`, quanto o método `ndarray.flatten()` podem ser utilizados para o que desejamos. Contudo, existem diferenças importantes que, para serem compreendidas, precisaremos antes ter uma noção básica sobre como são feitas as cópias de ndarrays. Para tal, vamos considerar a existência de dois caminhos possíveis:\n",
    "\n",
    "> **1.** A cópia gerada é, na verdade, uma visualização da versão original, ou seja, ambas estão \"interligadas\". Dessa forma, modificar uma **também** irá alterar a outra.\n",
    "\n",
    "> **2.** A cópia gerada e a versão original são independentes. Dessa forma, modificar uma **não** irá alterar a outra.\n",
    "\n",
    "Portanto, temos a `np.ravel()` e, sempre que possível, a `np.reshape()`, operando da primeira forma, enquanto `ndarray.flatten()` opera conforme a segunda. Vamos esclarecer essa diferença abaixo, tratando os dois casos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Caso 1:** utilizando a `np.ravel()` verificaremos que mudanças na cópia alteram **também** a ndarray original (e vice-versa)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "# Define uma matriz quadrada de ordem 2 com os inteiros 1, 2, 3 e 4\n",
    "matriz_1 = np.array([[1, 2],\n",
    "                     [3, 4]])\n",
    "\n",
    "# Define uma cópia unidimensional de matriz_1 através de np.ravel().\n",
    "copia_1 = np.ravel(matriz_1)\n",
    "# Altera o primeiro elemento de copia_1 para 7\n",
    "copia_1[0] = 7\n",
    "\n",
    "print(matriz_1) # Imprime matriz_1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como foi dito, embora a mudança tenha sido feita na variável `copia_1`, a variável `matriz_1` também foi modificada (de fato, temos dois ponteiros que indicam um mesmo lugar na memória). Vale ressaltar que substituindo `np.ravel(matriz_1)` por `np.reshape(matriz_1, (4,))` teríamos esse mesmo resultado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Caso 2:** utilizando `ndarray.flatten()` verificaremos que mudanças na cópia **não** alteram a ndarray original (e vice-versa)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "# Define uma matriz quadrada de ordem 2 com os inteiros 1, 2, 3 e 4\n",
    "matriz_2 = np.array([[1, 2],\n",
    "                     [3, 4]])\n",
    "\n",
    "# Define uma cópia unidimensional de matriz_2 através de ndarray.flatten().\n",
    "copia_2 = matriz_2.flatten()\n",
    "# Altera o primeiro elemento de copia_2 para 7\n",
    "copia_2[0] = 7\n",
    "\n",
    "print(matriz_2) # Imprime matriz_2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tal qual esperávamos, `matriz_2` permaneceu inalterada, enquanto `copia_2` sofreu de fato a alteração, verifique:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "print(copia_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "**Importante:** agora que já sabemos disso, é útil incluir mais algumas informações.\n",
    "\n",
    "* Comumente, diz-se que a primeira forma retorna uma *view* da ndarray de entrada, enquanto a segunda, uma *copy*.\n",
    "* `np.copy()` possui justamente a função de criar uma cópia (como da segunda forma) de uma ndarray.\n",
    "\n",
    "Quanto às técnicas de indexação e corte que vimos, acrescentamos:\n",
    "\n",
    "* *basic indexing* e *slicing* retornam uma *view* (como da primeira forma);\n",
    "* qualquer técnica de *advanced indexing* sempre retorna uma *copy* (como da segunda forma).\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Acrescentando e removendo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos agora ver três funções que nos permitem inserir e detelar elementos (números, se unidimensional; linhas ou colunas, se bidimensional) de uma ndarray.\n",
    "\n",
    "* `np.append()`: insere um elemento no final de uma ndarray;\n",
    "* `np.insert()`: insere um elemento numa determinada posição de uma ndarray;\n",
    "* `np.delete()`: remove um elemento de uma ndarray.\n",
    "\n",
    "Usaremos nos exemplos outras duas ndarrays, uma unidimensional (**N1**) e outra bidimensional (**N2**), ambas criadas abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ndarray unidimensional com cinco inteiros (do 0 ao 4).\n",
    "N1 = np.arange(5)\n",
    "\n",
    "# Ndarray bidimensional.\n",
    "N2 = np.array([[7, 2],\n",
    "               [1, 5]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pronto, vamos apenas visualizar as ndarrays criadas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "print(N1) # Visualização da matriz que acabamos de criar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 2]\n",
      " [1 5]]\n"
     ]
    }
   ],
   "source": [
    "print(N2) # Visualização da matriz que acabamos de criar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "**Observação:** as três funções citadas, na verdade, conseguem atuar sobre qualquer `array_like`, não somente sobre uma ndarray.\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.append( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para `np.append()` vamos primeiro trabalhar o caso unidimensional. Destarte, precisaremos (1) indicar em qual ndarray será feita a inserção e (2) passar os elementos que queremos acrescentar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 12: [0 1 2 3 4 5]\n",
      "Exemplo 13: [0 1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 12:\", np.append(N1, 5))      # Insere o inteiro 5 no final de N1.\n",
    "print(\"Exemplo 13:\", np.append(N1, [5, 6])) # Insere a lista [5, 6] no final de N1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora, considerando mais dimensões, a função opera com algumas diferenças. Basicamente, se não especificarmos o parâmetro `axis` a nossa saída será uma ndarray unidemsional, independentemente dos dados de entrada. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 14: [7 2 1 5 8]\n",
      "Exemplo 15: [7 2 1 5 7 2 1 5]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 14:\", np.append(N2, 8))  # \"Planifica\" a ndarray N2 e insere o inteiro 8 em seu final.\n",
    "print(\"Exemplo 15:\", np.append(N2, N2)) # \"Planifica\" a ndarray N2 e insere uma \"planificação\" de N2 no seu final."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por outros termos, podemos dizer que, ao omitir o parâmetro `axis`, todos os dados de entrada serão convertidos para ndarrays unidimensionais e só então concatenados. Como essa perda de informação geralmente não é o que procuramos, deve-se:\n",
    "\n",
    "* definir em qual eixo/dimensão (linhas ou colunas) deverá ser feita a inserção;\n",
    "* assegurar que, nessa dimensão, as filas possuam tamanhos iguais.\n",
    "\n",
    "**Exemplo:** a matriz **N2** possui duas linhas e duas colunas. Para acrescentar mais colunas a ela precisaremos definir `axis=1` (isto é, indicar que a inserção é para ser feita no eixo das colunas) e apenas inserir colunas com duas linhas, pois esse é o número de linhas de **N2**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 16:\n",
      "[[7 2 7 2]\n",
      " [1 5 1 5]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 16:\", np.append(N2, N2, axis=1), sep=\"\\n\") # Concatena N2 à direita de N2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 17:\n",
      "[[7 2]\n",
      " [1 5]\n",
      " [3 6]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 17:\", np.append(N2, [[3, 6]], axis=0), sep=\"\\n\") # Concatena [[3, 6]] (matriz linha) embaixo de N2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.insert( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com `np.insert()` teremos um procedimento parecido, inclusive quanto à especificação ou não do eixo. Todavia, temos agora a possibilidade de introduzir os elementos em um ponto qualquer da ndarray, não somente no final, como ocorria com `np.append()`. Novamente, vamos primeiro nos voltar ao caso unidimensional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 18: [0 1 2 5 3 4]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 18:\", np.insert(N1, 3, 5)) # Insere em N1, no índice 3, o número 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe então que a ordem dos argumentos deve ser a seguinte:\n",
    "\n",
    "* ndarray na qual será feita a inserção;\n",
    "* índice que deverá ser ocupado pelo elemento a ser inserido;\n",
    "* o elemento a ser inserido.\n",
    "\n",
    "Por último, para duas ou mais dimensões, indicamos o eixo com `axis`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 19:\n",
      "[[7 2]\n",
      " [9 4]\n",
      " [1 5]]\n"
     ]
    }
   ],
   "source": [
    "# Insere [[9, 4]] (matriz linha) em N2, como uma linha (axis=0) de índice 1.\n",
    "print(\"Exemplo 19:\", np.insert(N2, 1, [[9, 4]], axis=0), sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Vale relembrar:** omitr `axis` também implicará uma \"planificação\" dos elementos e ainda precisamos estar atentos às dimensões."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.delete( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como citamos, com a função `np.delete()` poderemos excluir elementos de ndarrays. Mas tomemos cuidado: para duas dimensões, estaremos removendo sempre uma linha ou uma coluna por completo. Além disso, a remoção ocorre por meio do uso de índices, veja os argumentos:\n",
    "\n",
    "* a ndarray que terá um elemento removido;\n",
    "* os índices dos elementos a serem removidos;\n",
    "* o eixo no qual deve ocorrer a remoção (se possuir mais de uma dimensão).\n",
    "\n",
    "Inicialmente, vamos ver o exemplo para **N1**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 20: [0 1 3 4]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 20:\", np.delete(N1, 2)) # Remove o terceiro elemento (índice 2) de N1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para **N2**, basta então que especifiquemos o eixo, para evitar a \"planificação\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 21:\n",
      "[[2]\n",
      " [5]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 21:\", np.delete(N2, 0, axis=1), sep=\"\\n\") # Remove a primeira (índice 0) coluna (axis=1) de N2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reordenando"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.sort( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último, `np.sort()` irá organizar os elementos no interior de uma ndarray em ordem crescente (por padrão). No nosso caso, os elementos de **N1** já se encontram dessa forma, podemos então colocá-los em ordem decrescente. Fazemos isso de uma forma pouco usual: insere-se um sinal de menos antes da função e outro dentro dos parêntesis, antes da ndarray. Isto é:\n",
    "\n",
    "* `np.sort(N1)` organiza **N1** em ordem crescente;\n",
    "* `-np.sort(-N1)` organiza **N1** em ordem decrescente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 22: [4 3 2 1 0]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 22:\", -np.sort(-N1)) # Organiza N1 em ordem decrescente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Já para **N2** precisaremos de maior cautela, a função `np.sort()` irá organizar em ordem crescente: as linhas, se `axis=0`; as colunas, se `axis=1`. Enquanto para `axis=None` teremos uma \"planificação\" da ndarray ordenada crescentemente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 23:\n",
      "[[1 2]\n",
      " [7 5]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 23:\", np.sort(N2, axis=0), sep=\"\\n\") # Organiza as linhas de N2 em ordem crescente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 24:\n",
      "[[2 7]\n",
      " [1 5]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 24:\", np.sort(N2, axis=1), sep=\"\\n\") # Organiza as colunas de N2 em ordem crescente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora, vamos verificar `axis=None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 25:\n",
      "[1 2 5 7]\n"
     ]
    }
   ],
   "source": [
    "print(\"Exemplo 25:\", np.sort(N2, axis=None), sep=\"\\n\") # Planifica N2 e organiza seus elementos em ordem crescente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diferentemente das outras funções que abordamos nessa seção, `np.sort()` possui como *default* `axis=-1` e **não** `axis=None`. Desse modo, escolhe-se sempre a última dimensão quando omitimos tal argumento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Métodos e operações com uma ndarray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inicialmente, continuaremos a coletar informações sobre as ndarrays, mas agora já com um maior apelo matemático para, finalmente, começarmos com algumas operações. Tudo isso será feito ainda nos atendo a uma única ndarray, nossa matriz **B**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Métodos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de começar, caso precise, fique com um lembrete da matriz **B**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "print(B) # Imprime B."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ndarray.max( ) e ndarray.min( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Análogos às funções `max()` e `min()` do Python, os métodos `ndarray.max()` e `ndarray.min()` retornam, respectivamente, o maior e o menor elemento em uma ndarray. Logo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maior elemento de B: 9\n",
      "Menor elemento de B: 1\n"
     ]
    }
   ],
   "source": [
    "print(\"Maior elemento de B:\", B.max())\n",
    "print(\"Menor elemento de B:\", B.min())     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas uma diferença interessante se encontra no argumento `axis`. Quando passado, a operação ocorrerá levando em conta somente aquela dimensão (eixo). Por exemplo, no caso de uma matriz, `ndarray.max(axis=0)` implicará uma busca pela linha cujos elementos quando somados resultem no maior valor possível, retornando justamente essa tal linha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maior linha de B: [7 8 9]\n",
      "Menor coluna de B: [1 4 7]\n"
     ]
    }
   ],
   "source": [
    "print(\"Maior linha de B:\", B.max(axis=0))  # axis=0 (linha).\n",
    "print(\"Menor coluna de B:\", B.min(axis=1)) # axis=1 (coluna)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "**Observação:** \"maior linha\" e \"menor coluna\" querem dizer \"linha com maior soma\" e \"coluna com menor soma\", respectivamente.\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ndarray.sum( ) e ndarray.cumsum( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como os nomes sugerem, `ndarray.sum()` e `ndarray.cumsum()` retornam, respectivamente, a soma e a soma cumulativa de uma ndarray. Caso não saiba, a soma cumulativa pode ser simplificadamente definida como uma sequência de somas parciais: o resultado da soma dos valores conforme se adiciona valor a valor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Soma dos elementos de B: 45\n",
      "Soma cumulativa de B: [ 1  3  6 10 15 21 28 36 45]\n"
     ]
    }
   ],
   "source": [
    "print(\"Soma dos elementos de B:\", B.sum())\n",
    "print(\"Soma cumulativa de B:\", B.cumsum()) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim como anteriormente, podemos definir o argumento `axis` e condicionaremos a operação a uma dimensão específica, isto é:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Soma dos elementos para cada linha de B: [ 6 15 24]\n"
     ]
    }
   ],
   "source": [
    "print(\"Soma dos elementos para cada linha de B:\", B.sum(axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aparentemente, poderiamos considerar a construção a cima adversa, afinal utilizamos `axis=1` para obter uma soma com referência nas linhas da matriz, ainda que o **eixo 1** designe colunas. Contudo, notemos que, fixada uma linha, somar seus elementos é, na verdade, somar as colunas (e vice-versa). Em síntese, trata-se apenas de uma construção gramaticalmente distinta, mas com igual valor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Soma cumulativa das colunas de B:\n",
      "[[ 1  3  6]\n",
      " [ 4  9 15]\n",
      " [ 7 15 24]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Soma cumulativa das colunas de B:\", B.cumsum(axis=1), sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ndarray.prod( ) e ndarray.cumprod( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ao invés de trabalharmos com a soma e a soma cumulativa, podemos desejar o produto e o produto cumulativo, respectivamente, `ndarray.prod()` e `ndarray.cumprod()`. A aplicação e o funcionamento são próximos do que já vimos. Observe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Produto das linhas de B: [ 28  80 162]\n",
      "Produto cumulativo de B: [     1      2      6     24    120    720   5040  40320 362880]\n"
     ]
    }
   ],
   "source": [
    "print(\"Produto das linhas de B:\", B.prod(axis=0))\n",
    "print(\"Produto cumulativo de B:\", B.cumprod())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operações"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalmente, vamos começar a trabalhar com operações entre números e ndarrays, o principal ponto é compreender que estamos falando de operações do tipo **elementwise**, ou seja, que serão aplicadas a cada um dos elementos da ndarray. A exemplo, somar 5 a uma ndarray é, essencialmente, somar 5 a cada um de seus elementos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores aritméticos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como já citamos no exemplo a cima, aplicar qualquer um deles (`+`, `-`, `*`, `**`, `/`, `//` e `%`) entre uma ndarray e um número irá resultar em uma nova ndarray, essa, contendo os resultados das contas para cada elemento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  7.  8.]\n",
      " [ 9. 10. 11.]\n",
      " [12. 13. 14.]]\n"
     ]
    }
   ],
   "source": [
    "print(B + 5.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-4 -3 -2]\n",
      " [-1  0  1]\n",
      " [ 2  3  4]]\n"
     ]
    }
   ],
   "source": [
    "print(B - 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 20 30]\n",
      " [40 50 60]\n",
      " [70 80 90]]\n"
     ]
    }
   ],
   "source": [
    "print(B * 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  4  9]\n",
      " [16 25 36]\n",
      " [49 64 81]]\n"
     ]
    }
   ],
   "source": [
    "print(B ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.1 0.2 0.3]\n",
      " [0.4 0.5 0.6]\n",
      " [0.7 0.8 0.9]]\n"
     ]
    }
   ],
   "source": [
    "print(B / 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 1]\n",
      " [2 2 3]\n",
      " [3 4 4]]\n"
     ]
    }
   ],
   "source": [
    "print(B // 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 1]\n",
      " [0 1 0]\n",
      " [1 0 1]]\n"
     ]
    }
   ],
   "source": [
    "print(B % 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores relacionais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para os relacionais (`==`, `!=`, `>`, `>=`, `<` e `<=`) teremos um princípio de funcionamento análogo. Contudo, como esperamos, na nossa ndarray resultante estarão presentes somente os valores `True` e `False`, onde esses forem cabíveis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False False]\n",
      " [False  True False]\n",
      " [False False False]]\n"
     ]
    }
   ],
   "source": [
    "print(B == 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True  True  True]\n",
      " [ True  True  True]\n",
      " [ True  True False]]\n"
     ]
    }
   ],
   "source": [
    "print(B != 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True  True  True]\n",
      " [ True  True  True]\n",
      " [ True  True  True]]\n"
     ]
    }
   ],
   "source": [
    "print(B > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False False]\n",
      " [ True  True  True]\n",
      " [ True  True  True]]\n"
     ]
    }
   ],
   "source": [
    "print(B >= 3.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False False]\n",
      " [False False False]\n",
      " [False False False]]\n"
     ]
    }
   ],
   "source": [
    "print(B < 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True  True  True]\n",
      " [ True  True  True]\n",
      " [ True False False]]\n"
     ]
    }
   ],
   "source": [
    "print(B <= 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Outras operações (matrizes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se quisermos nos especificar mais, é simples obter propriedades típicas das matrizes, nesse caso:\n",
    "\n",
    "* o **traço** (a soma de todos os elementos da diagonal principal), através de `np.trace()`;\n",
    "* a matriz **transposta**, através de `ndarray.T`;\n",
    "* o **determinante**, através de `np.linalg.det()`.\n",
    "\n",
    "Perceba que, para o determinante, precisamos utilizar um módulo específico do NumPy: `numpy.linalg`. Não nos aprofundaremos nele, mas trata-se de uma excelente alternativa para se trabalhar com tópicos de [álgebra linear](https://numpy.org/doc/1.17/reference/routines.linalg.html). De qualquer forma, vamos primeiro ao traço:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Soma dos elementos da diagonal principal de B (traço): 15\n"
     ]
    }
   ],
   "source": [
    "print(\"Soma dos elementos da diagonal principal de B (traço):\", np.trace(B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E depois, transpor **B**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B transposta:\n",
      "[[1 4 7]\n",
      " [2 5 8]\n",
      " [3 6 9]]\n"
     ]
    }
   ],
   "source": [
    "print(\"B transposta:\", B.T, sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para o determinante, vamos apenas arredondar o resultado para evitar o ruído, assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Determinante de B: 0.0\n"
     ]
    }
   ],
   "source": [
    "print(\"Determinante de B:\", round(np.linalg.det(B))) # round() arredonda np.linalg.det(B) para a primeira casa decimal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operações entre múltiplas ndarrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma das maiores vantagens do NumPy é, sem dúvida, a facilidade que possuímos para realizar contas com as ndarrays. Primeiro, vamos no ater aos operadores aritméticos, é importante saber que todas as operações pedidas (uma soma ou uma subtração, por exemplo) serão feitas com os elementos de iguais índices entre as ndarrays. Para que fique mais claro, trabalharemos com alguns exemplos logo após criarmos a nossa nova matriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "C = np.eye(3) # Define C: matriz identidade de ordem 3 (ndarray bidimensional)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função `np.eye()` não foi introduzida na seção de criação de ndarrays pois se trata de um caso bem específico: ela retorna a matriz identidade de ordem `N`, sendo `N` um inteiro não negativo (no nosso caso, `N=3`). A [documentação](https://numpy.org/doc/1.17/reference/generated/numpy.eye.html) sem dúvidas pode ajudar, tendo em vista que a função possui suas particularidades. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "print(C) # Visualização da matriz que acabamos de criar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores aritméticos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalmente, para os exemplos, vamos abordar todos os casos anteriores (`+`, `-`, `*`, `**`, `/`, `//` e `%`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2.  2.  3.]\n",
      " [ 4.  6.  6.]\n",
      " [ 7.  8. 10.]]\n"
     ]
    }
   ],
   "source": [
    "print(B + C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 2. 3.]\n",
      " [4. 4. 6.]\n",
      " [7. 8. 8.]]\n"
     ]
    }
   ],
   "source": [
    "print(B - C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 5. 0.]\n",
      " [0. 0. 9.]]\n"
     ]
    }
   ],
   "source": [
    "print(B * C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1.]\n",
      " [1. 5. 1.]\n",
      " [1. 1. 9.]]\n"
     ]
    }
   ],
   "source": [
    "print(B ** C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.        ]\n",
      " [0.         0.2        0.        ]\n",
      " [0.         0.         0.11111111]]\n"
     ]
    }
   ],
   "source": [
    "print(C / B) # Observe que (B / C) implicaria uma divisão por zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print(C // B) # Observe que (B // C) implicaria uma divisão por zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "print(C % B) # Observe que (B % C) implicaria uma divisão por zero."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como deve ter reparado, a expressão `B * C` seguiu o esperado: a ndarray resultante foi composta pelo produto dos elementos de índices comuns entre **B** e **C**. Mas já que estamos trabalhando com matrizes, poderiamos querer, justamente, o **produto matricial**, com esse objetivo é que utilizamos o operador `@`. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2. 3.]\n",
      " [4. 5. 6.]\n",
      " [7. 8. 9.]]\n"
     ]
    }
   ],
   "source": [
    "print(B @ C) # Uma forma equivalente (mas antiga) dessa expressão é B.dot(C)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores relacionais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para os operadores relacionais, teremos um funcionamento análogo: será feita a comparação desejada (`==`, `!=`, `>`, `>=`, `<` e `<=`) entre os elementos de iguais índidces das ndarrays e retornada uma terceira composta por `True` e `False`, onde quer que esses sejam aplicáveis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True False False]\n",
      " [False False False]\n",
      " [False False False]]\n"
     ]
    }
   ],
   "source": [
    "print(B == C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False  True  True]\n",
      " [ True  True  True]\n",
      " [ True  True  True]]\n"
     ]
    }
   ],
   "source": [
    "print(B != C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False  True  True]\n",
      " [ True  True  True]\n",
      " [ True  True  True]]\n"
     ]
    }
   ],
   "source": [
    "print(B > C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True  True  True]\n",
      " [ True  True  True]\n",
      " [ True  True  True]]\n"
     ]
    }
   ],
   "source": [
    "print(B >= C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False False]\n",
      " [False False False]\n",
      " [False False False]]\n"
     ]
    }
   ],
   "source": [
    "print(B < C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True False False]\n",
      " [False False False]\n",
      " [False False False]]\n"
     ]
    }
   ],
   "source": [
    "print(B <= C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operadores Lógicos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para cada operador lógico nativo do Python (`and`, `or`, `not` e `xor`) o NumPy introduz um equivalente, veja:\n",
    "\n",
    "* `np.logical_and()` retorna `True` se as duas afirmações forem verdadeiras;\n",
    "* `np.logical_or()` retorna `True` se pelo menos uma das afirmações for verdadeira;\n",
    "* `np.logical_not()` inverte valores, retorna `True` se a saída for falsa;\n",
    "* `np.logical_xor()` retorna `True` se exatamente uma das afirmações for verdadeira.\n",
    "\n",
    "Como é possível constatar, não temos diferenças nos valores de retorno entre os operadores lógicos nativos do Python e os do NumPy. Tanto que podemos utilizá-los sem discriminação para os casos habituais, isto é:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(10 > 1 and 5 < 12) # Retorna True, pois 10 é maior do que 1 (True) e 5 é menor do que 12 (True)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(np.logical_and(10 > 1, 5 < 12)) # Retorna True, pois 10 é maior do que 1 (True) e 5 é menor do que 12 (True)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Então qual seria o propósito de introduzir novos operadores com um funcionamento igual? Basicamente, abranger mais casos. Os operadores lógicos do NumPy são capazes de comparar, elemento por elemento, duas ndarrays de dimensões iguais (diferentemente dos nativos do Python). Vamos criar duas ndarrays com valores booleanos para demonstrar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define L1: primeira coluna com valores True; segunda, com valores False.\n",
    "L1 = np.array([[True, False], \n",
    "               [True, False]])\n",
    "\n",
    "# Define L2: primeira linha com valores False; segunda, com valores True.\n",
    "L2 = np.array([[False, False], \n",
    "               [True, True]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "**Observação:** como deve saber, não é necessário que os valores das ndarrays sejam booleanos, poderíamos, por exemplo, utilizar números (tendo em vista que, no Python, **0** é equivalente ao valor `False` e qualquer outro número, ao valor `True`).\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False]\n",
      " [ True False]]\n"
     ]
    }
   ],
   "source": [
    "print(np.logical_and(L1, L2)) # Retorna True onde L1 e L2 possuem True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True False]\n",
      " [ True  True]]\n"
     ]
    }
   ],
   "source": [
    "print(np.logical_or(L1, L2)) # Retorna True onde L1 ou L2 possuem True."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além disso, uma última função importante é `np.where()`. Simplificadamente, passamos para ela uma condição e dois valores de retorno (chamaremos eles de `x` e `y`). Ela retornará `x` se a condição for verdadeira e `y` se a condição for falsa. Na prática, teremos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['a' 'a' 'a']\n",
      " ['a' 'a' 'b']\n",
      " ['b' 'b' 'b']]\n"
     ]
    }
   ],
   "source": [
    "print(np.where(B <= 5, \"a\", \"b\")) # condição=(B <= 5); x=\"a\"; y=\"b\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como podemos ver, onde **B** é menor ou igual a 5 recebe `\"a\"`, onde não, recebe `\"b\"`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funções randômicas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Daremos aqui alguns exemplos das funções pseudorrandômicas que citamos no início, mas essas, introduzidas pelo NumPy. Elas são implementadas através do módulo `numpy.random` e são úteis, por exemplo, para a criação de ndarrays. A vantagem (e certas vezes a desvantagem) de trabalharmos com os *pseudo-random numbers* reside, justamente, no fato deles não serem completamente aleatórios, logo, embora não identifiquemos um padrão entre os números, poderemos sempre \"recriá-los\". Desde já, recomendaremos:\n",
    "\n",
    "* a [lista de funções randômicas](https://numpy.org/doc/1.14/reference/routines.random.html) do NumPy *(versão 1.14)*;\n",
    "* a [página da documentação](https://numpy.org/doc/1.17/reference/random/index.html) para um aprofundamento sobre a geração de números pseudorrandômicos, se tiver interesse.\n",
    "\n",
    "Antes da parte de exemplos, vamos explicar o uso de `np.ramdom.seed()`. Basicamente, ela que nos garante a reprodutibilidade dos resultados. Faremos abaixo uma comparação, começando sem o uso dessa função."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.44902267485791125"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand() # Retorna um float pseudoaleatório qualquer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9496339327345853"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand() # Retorna um float pseudoaleatório qualquer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A cada vez que as duas células a cima são executadas, a saída de cada uma é número qualquer. Contudo, se passarmos um inteiro (ou um `array_like` unidimensional) para `np.random.seed()` estaremos forçando sempre uma saída idêntica para as funções randômicas subsequentes. Podemos ver isso executando o código abaixo repetidas vezes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5488135039273248"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(0) # Torna os números pseudoaletórios previsíveis.\n",
    "np.random.rand()  # Retorna um float pseudoaleatório, agora, fixo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dessa forma, é possível garantir, por exemplo, que nosso código seja executado sempre de uma mesma forma, ainda que trabalhe com funções randômicas. Por fim, temos nas construções abaixo outros casos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-10  -7  -7  -3  -1]\n"
     ]
    }
   ],
   "source": [
    "# Retorna uma ndarray com 5 inteiros pertencentes ao intervalo [-10, 10).\n",
    "print(np.random.randint(-10, 10, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.6235637  0.38438171 0.29753461]\n"
     ]
    }
   ],
   "source": [
    "# Retorna uma ndarray unidimensional com 3 elementos.\n",
    "print(np.random.rand(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.05671298 0.27265629]\n",
      " [0.47766512 0.81216873]]\n"
     ]
    }
   ],
   "source": [
    "# Retorna uma matriz quadrada de ordem 2.\n",
    "print(np.random.rand(2, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matemática e estatística"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O NumPy introduz algumas dezenas de funções e expressões matemáticas além daquelas que já abordamos. Na verdade, a exemplo, temos casos em que podemos utilizar tanto `ndarray.sum()` para somar os elementos de uma ndarray (visto anteriormente), como também `np.sum()`. Como seria inviável (e desnecessário) apresentar cada uma delas, recomendamos fortemente consultar a [lista de funções matemáticas](https://numpy.org/doc/1.17/reference/routines.math.html) e de [estatística](https://numpy.org/doc/1.17/reference/routines.statistics.html) presentes na própria documentação da biblioteca. Nessas listas, além de separadas por categorias, as funções se encontram com uma breve explicação."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Mathematical functions*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A título de demonstração, trabalharemos alguns exemplos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.605170185988092"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(100) # Obtém o logarítimo natural de 100 (logarítimo de 100 na base e, sendo \"e\" o número de Euler)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log10(100) # Obtém o logarítimo decimal de 100 (logarítimo de 100 na base 10)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.61"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.round_(np.log(100), 2) # Arredonda o logarítimo natural de 100 para a segunda casa decimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(4) # Raiz quadrada de 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cbrt(27) # Raiz cúbica de 27"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constantes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outro ponto importante são as constantes que o NumPy introduz, na verdade, elas não são necessariamente matemáticas, como é possível verificar através da [relação de constantes](https://numpy.org/doc/1.17/reference/constants.html). Daremos atenção a três delas, começando por `np.pi`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "print(np.pi) # Constante matemática, razão entre o perímetro e o diâmetro de uma circunferência."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seguindo para `np.e`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.718281828459045\n"
     ]
    }
   ],
   "source": [
    "print(np.e) # Constante matemática, o número de Euler."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E finalmente, `np.nan`, *Not a Number* (NaN):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nan\n"
     ]
    }
   ],
   "source": [
    "print(np.nan) # Constante utilizada para indicar dados faltantes (missing data)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Statistics*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalizando, vamos novamente exemplificar algumas funções úteis, dessa vez, para a determinação de dados estatísticos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.5"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) # A média de um array_like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median([1, 2, 5, 9, 10]) # A mediana de um array_like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0694441847516605"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std([1, 1, 3, 4, 5, 7, 7, 8, 9, 9, 10]) # O desvio padrão de um array_like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.421487603305785"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.var([1, 1, 3, 4, 5, 7, 7, 8, 9, 9, 10]) # A variância de um array_like."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Alt text](https://gistcdn.githack.com/Gbecdox/178a8d0cd024d5e52d63e3c11a2cdfd7/raw/3f32b8a31509ec3b2b20ebb202113b2da0e9c751/FooterGM.svg)\n",
    "***"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}