docs/source/05Vetores.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e910c90e",
   "metadata": {},
   "source": [
    "# 5. Vetores \n",
    "\n",
    "## 5.1. Criação de vetores\n",
    "\n",
    "Em economia fazemos uso recorrente de matrizes e vetores. Em Python, precisamos de um pacote para isso. \n",
    "\n",
    "Pacotes são conjuntos ou bibliotecas de código utilizados para um fim específico. \n",
    "\n",
    "Para vetores, matrizes e suas operações, vamos utilizar o pacote **Numpy** *(Numerical Python)*. \n",
    "\n",
    "Na **Plataforma Anaconda** esse pacote já está previamente instalado (o mesmo vale para o **Google Colab**). Porém, se você estiver utilizando outra inferface, poderá instalar o **Numpy**, na janela de comando, utilizando: \n",
    "\n",
    "    pip install numpy\n",
    "\n",
    "Mesmo com **Numpy** instalado, você irá precisar sempre importar o pacote antes de usá-lo. \n",
    "\n",
    "É comum utilizar uma abreviação do nome  do pacote na importação, o que irá facilitar seu uso no restante do código. No caso do **Numpy**, vamos usar **np**, que é uma abreviação utilizada recorrentemente, por convenção (você pode escolher qualquer letra). Como é uma convenção muito utilizada, manter **np** permite que outras pessoas entendam melhor o seu código e facilita o uso de códigos prontos. \n",
    "\n",
    "Para importar o **Numpy** como **np** utilize: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b79b9cb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14b73995",
   "metadata": {},
   "source": [
    "Agora sim, você pode criar um vetor. \n",
    "\n",
    "Vamos criar o vetor **x** com os elementos [1, 5, 6] com auxílio da função **array**. Observe que **array** é uma função do pacote **Numpy**, sendo assim, sempre utilizaremos **np.array** para chamar essa função: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "39d0b60f",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([1, 5, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07dd618e",
   "metadata": {},
   "source": [
    "O vetor fica disponível apenas com o nome **x**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2d59d206",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 5, 6])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b491815",
   "metadata": {},
   "source": [
    "Ou, você pode utilizar a função `print()` para visualizar o conteúdo da variável: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ee95a04e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 5 6]\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d526ba7",
   "metadata": {},
   "source": [
    "Vale observar que os vetores não precisam ser numéricos! \n",
    "\n",
    "Por exemplo, podemos criar o vetor **y** apenas com texto: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4ba74f11",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['NEDUR' 'UFPR' 'Regional' 'Urbana']\n"
     ]
    }
   ],
   "source": [
    "y = np.array([\"NEDUR\", \"UFPR\", \"Regional\", \"Urbana\"])\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbefea7b",
   "metadata": {},
   "source": [
    "Observe que ao utilizar a função `type()` para verificar o tipo de variável, você terá como resposta *numpy.ndarray* (abreviação para *numpy N-dimensional array*) para ambos os vetores: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "aac71199",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(type(x))\n",
    "print(type(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bbf30bd",
   "metadata": {},
   "source": [
    "Para sabermos o tipo dentro de um objeto do **Numpy**, podemos utilizar o *atributo* **dtype** do vetor. \n",
    "\n",
    "<div class=\"alert alert-warning\"> \n",
    "    \n",
    "**Atributos** são informações ou características relacionadas à determinada função, *dtype* (abreviatura de *data type*) é um atributo de um **array**.        \n",
    "    \n",
    "</div>    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "efa6b0e7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n",
      "<U8\n"
     ]
    }
   ],
   "source": [
    "print(x.dtype)\n",
    "print(y.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b5621af",
   "metadata": {},
   "source": [
    "A saída nos indica que temos um vetor com inteiros (int) e 32 caracteres para a variável *x*, enquanto *y* é vetor de texto *Unicode String* (U), com 11 caracteres. Esses tamanhos podem ser diferentes se você estiver utilizando outro ambiente que não seja o *Jupyter Notebook*. \n",
    "\n",
    "<div class=\"alert alert-info\"> \n",
    "    \n",
    "**Observação:**\n",
    "    \n",
    "A informação &lt;U8', indica que o vetor está salvo no formato **Unicode** (*Universal Character Encoding*) com até 8 caracteres. O formato **Unicode** é um padrão de representação para texto universal. \n",
    "\n",
    "</div>  \n",
    "\n",
    "Não vamos detalhar todas as combinações possíveis aqui, elas estão disponíveis na documentação do [Numpy](https://numpy.org/doc/stable/reference/arrays.dtypes.html)\n",
    "\n",
    "Vetores lógicos (booleanos) também podem ser criados no **Numpy**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "54b59f48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True False  True]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dtype('bool')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.array([True, False, True])\n",
    "print(v)\n",
    "v.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af92a746",
   "metadata": {},
   "source": [
    "Diferente das listas, que podem conter qualquer tipo de dado ao mesmo tempo, um vetor pode ter apenas um tipo de dado. \n",
    "\n",
    "Se tentarmos colocar números e letras no mesmo vetor, todos os elementos serão convertidos para letras: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5e7872ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['NEDUR' 'UFPR' 'Regional' 'Urbana' '1']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dtype('<U11')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.array([\"NEDUR\", \"UFPR\", \"Regional\", \"Urbana\", 1])\n",
    "print(z)\n",
    "z.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "598444d7",
   "metadata": {},
   "source": [
    "Podemos criar uma vetor com uma sequência de números. \n",
    "\n",
    "Um vetor de 0 a 4, por exemplo, pode ser criado com auxílio da função *numpy arange*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d09160ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "r = np.arange(5)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a308c08",
   "metadata": {},
   "source": [
    "Observe que ao informar que queremos um *array* com uma sequência até 5, o vetor começa em zero e possui cinco elementos.\n",
    "\n",
    "No exemplo anterior usamos `np.arrange(5)`, em que o número `5` é chamado de argumento da função, e se refere ao valor final da sequência de números criada. A função *np.arange* possui vários argumentos, ou seja, vários outros parâmetros que podem ser alterados para formar sequências diferentes, como valor inicial, intervalos, entre outros. \n",
    "\n",
    "Para conhecer os argumentos da função, use a função `help()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e2462d78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function arange in module numpy:\n",
      "\n",
      "arange(...)\n",
      "    arange([start,] stop[, step,], dtype=None, *, like=None)\n",
      "    \n",
      "    Return evenly spaced values within a given interval.\n",
      "    \n",
      "    Values are generated within the half-open interval ``[start, stop)``\n",
      "    (in other words, the interval including `start` but excluding `stop`).\n",
      "    For integer arguments the function is equivalent to the Python built-in\n",
      "    `range` function, but returns an ndarray rather than a list.\n",
      "    \n",
      "    When using a non-integer step, such as 0.1, the results will often not\n",
      "    be consistent.  It is better to use `numpy.linspace` for these cases.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    start : integer or real, optional\n",
      "        Start of interval.  The interval includes this value.  The default\n",
      "        start value is 0.\n",
      "    stop : integer or real\n",
      "        End of interval.  The interval does not include this value, except\n",
      "        in some cases where `step` is not an integer and floating point\n",
      "        round-off affects the length of `out`.\n",
      "    step : integer or real, optional\n",
      "        Spacing between values.  For any output `out`, this is the distance\n",
      "        between two adjacent values, ``out[i+1] - out[i]``.  The default\n",
      "        step size is 1.  If `step` is specified as a position argument,\n",
      "        `start` must also be given.\n",
      "    dtype : dtype\n",
      "        The type of the output array.  If `dtype` is not given, infer the data\n",
      "        type from the other input arguments.\n",
      "    like : array_like\n",
      "        Reference object to allow the creation of arrays which are not\n",
      "        NumPy arrays. If an array-like passed in as ``like`` supports\n",
      "        the ``__array_function__`` protocol, the result will be defined\n",
      "        by it. In this case, it ensures the creation of an array object\n",
      "        compatible with that passed in via this argument.\n",
      "    \n",
      "        .. versionadded:: 1.20.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    arange : ndarray\n",
      "        Array of evenly spaced values.\n",
      "    \n",
      "        For floating point arguments, the length of the result is\n",
      "        ``ceil((stop - start)/step)``.  Because of floating point overflow,\n",
      "        this rule may result in the last element of `out` being greater\n",
      "        than `stop`.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    numpy.linspace : Evenly spaced numbers with careful handling of endpoints.\n",
      "    numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.\n",
      "    numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.arange(3)\n",
      "    array([0, 1, 2])\n",
      "    >>> np.arange(3.0)\n",
      "    array([ 0.,  1.,  2.])\n",
      "    >>> np.arange(3,7)\n",
      "    array([3, 4, 5, 6])\n",
      "    >>> np.arange(3,7,2)\n",
      "    array([3, 5])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.arange)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e99e25b5",
   "metadata": {},
   "source": [
    "Observe que os dois primeiros argumentos da função são início (*start*) e fim (*stop*). Assim, para criar um vetor começando em 1, e terminando em 5, podemos utilizar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8ca82527",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "r1 = np.arange(1, 6)\n",
    "print(r1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb66c6df",
   "metadata": {},
   "source": [
    "Observe que a sequência agora começa em 1 (incluso), e \"termina\" em 6 (não incluso)! O último número do intervalo não será incluído. \n",
    "\n",
    "Podemos ainda definir intervalos (argumento *step*). Por exemplo, criar uma sequência de 0.5 em 0.5, começando em 2 e terminando em 4. Para isso, podemos utilizar os três primeiros argumentos da função: número inicial (incluso), número final (não incluso) e intervalo.  \n",
    "\n",
    "Observe que, para incluir o valor 4 e não incluir 4.5, o segundo argumento *(stop)* deve estar entre 4 e 4.5. Optamos por deixar 4.5. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "165f4666",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.  2.5 3.  3.5 4. ]\n"
     ]
    }
   ],
   "source": [
    "q = np.arange(2,4.5,0.5)\n",
    "print(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83e44650",
   "metadata": {},
   "source": [
    "Você pode mudar os parâmetros dos argumentos dentro da função. Teste os três próximos exemplos e observe os resultados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5be2fae9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1, 10, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "52510519",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1, 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b0e4e1cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.      , 4.141593, 7.283186])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1, 9, 3.141593)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5adcc8c2",
   "metadata": {},
   "source": [
    "Além dos exemplos acima, podemos criar sequências regulares dentro de um intervalo. Nesse caso, precisamos usar a função *linspace*. \n",
    "\n",
    "Vamos usar os quadro primeiros argumentos da função: Início, Fim, Número de intervalos, e inclusão ou não do ponto final (*endpoint*). \n",
    "\n",
    "Teste as opções abaixo e observe os resultados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "fe3ddc1f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.5])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 1, num=2, endpoint=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "069ec2b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1.])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 1, num=2, endpoint=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4f55a9f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.5, 1. ])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 1, num=3, endpoint=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "4f945099",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.33333333, 0.66666667, 1.        ])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 1, num=4, endpoint=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "23a2c524",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.  , 0.25, 0.5 , 0.75, 1.  ])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 1, num=5, endpoint=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa0ced90",
   "metadata": {},
   "source": [
    "Alguns tipos de vetores são necessários em alguns cálculos. Você pode utilizar outras funções para criar um vetor de zeros (*np.zeros*), ou um vetor apenas com o número 1 (*np.ones*):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "66246c9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "60249653",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7535eb9",
   "metadata": {},
   "source": [
    "Podemos verificar todas as variáveis criadas com o comando %whos: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5d3058da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable   Type       Data/Info\n",
      "-------------------------------\n",
      "np         module     <module 'numpy' from 'C:\\<...>ges\\\\numpy\\\\__init__.py'>\n",
      "q          ndarray    5: 5 elems, type `float64`, 40 bytes\n",
      "r          ndarray    5: 5 elems, type `int32`, 20 bytes\n",
      "r1         ndarray    5: 5 elems, type `int32`, 20 bytes\n",
      "v          ndarray    3: 3 elems, type `bool`, 3 bytes\n",
      "x          ndarray    3: 3 elems, type `int32`, 12 bytes\n",
      "y          ndarray    4: 4 elems, type `<U8`, 128 bytes\n",
      "z          ndarray    5: 5 elems, type `<U11`, 220 bytes\n"
     ]
    }
   ],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "985d9d44",
   "metadata": {},
   "source": [
    "Observe que para as funções `linespace()`, `zeros()`, e `ones()` não salvamos variáveis, e, por isso, elas não estão disponíveis no ambiente. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6798f9f4",
   "metadata": {},
   "source": [
    "## 5.2. Indexação e subconjuntos de vetores\n",
    "\n",
    "Após a criação de vetores, é possível selecionar um elemento específico (ou elementos) considerando a posição ou valor.\n",
    "\n",
    "Crie um vetor **g** com os elementos [\"Curso\", \"Python\", \"NEDUR\", 2022]:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3c9e415e",
   "metadata": {},
   "outputs": [],
   "source": [
    "g = np.array([\"Curso\", \"Python\", \"NEDUR\", 2022, \"Agosto\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4873b6c8",
   "metadata": {},
   "source": [
    "Observe que, nesse caso, todos os elementos do vetor serão salvos como *strings* (texto). \n",
    "\n",
    "Em **Python**, a primeira posição, de uma lista, ou de um vetor, é a posição zero. Sendo assim, considerando o vetor **g**, podemos verificar o terceiro elemento (localizado na posição 2) com a seguinte notação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "4aa449c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NEDUR'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb54d49d",
   "metadata": {},
   "source": [
    "Podemos também utilizar os índices começando do final do vetor. Por exemplo, \"NEDUR\" está na posição 2, ou -2: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "dbdc2bd2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2022'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b31fe13",
   "metadata": {},
   "source": [
    "Similarmente, podemos verificar os elementos contidos entre as posições 1 e 3, ou, dito de outro forma, selecionar o subconjunto de elementos entre as posições 1 e 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "af519f0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Python', 'NEDUR', '2022'], dtype='<U11')"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g[1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c40db50e",
   "metadata": {},
   "source": [
    "Novamente, repare que o último elemento (posição 4), não foi incluído, assim como, não foi incluído o elemento de índice zero. \n",
    "    \n",
    "Podemos também, criar um novo vetor com uma seleção do anterior, atribuindo um novo nome para a variável, nesse caso *n*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "3e572cd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Python', 'NEDUR', '2022'], dtype='<U11')"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = g[1:4]\n",
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95495cfc",
   "metadata": {},
   "source": [
    "No caso de vetores numéricos, podemos selecionar utilizando operadores. \n",
    "\n",
    "Por exemplo, vamos recuperar o vetor de 0 a 100, com múltiplos de 9:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "21b96a1f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = np.arange(0, 100, 9)\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56103272",
   "metadata": {},
   "source": [
    "Se quisermos selecionar apenas os elementos maiores do que 20 poderíamos tentar o código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "891bd602",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m > 20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b36cf55",
   "metadata": {},
   "source": [
    "No entando, o resultado mostra que os primeiros três números não são menores do que 20, mas não seleciona o que queremos. \n",
    "\n",
    "Para que o comando seja compreendido, precisamos informar que queremos *m > 20* dentro do vetor *m*. Ou seja: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "3d02af9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([27, 36, 45, 54, 63, 72, 81, 90, 99])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[m > 20]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd619922",
   "metadata": {},
   "source": [
    "## 5.3. Operações com vetores\n",
    "\n",
    "Assim como foi feito com as variáveis, é possível realizar operações aritméticas e lógicas com os vetores. Para tal, defina um vetor **k** com os seguintes elementos [2, 4, 6, 8, 10]: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "8124b34c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k = np.arange(2, 11, 2)\n",
    "k"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66752ec2",
   "metadata": {},
   "source": [
    "Multiplicar o vetor **k** por 2 significa multiplicar cada um dos seus elementos por 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "f21f3f25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4,  8, 12, 16, 20])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7df6db58",
   "metadata": {},
   "source": [
    "Similarmente, dividir o vetor **k** por 2 significa dividir cada um dos seus elementos por 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "4c945876",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4., 5.])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "325a952f",
   "metadata": {},
   "source": [
    "Faça o teste com `K + 1` e `K - 1`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2d1fdc9e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  5,  7,  9, 11])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "16f3e607",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d32f05ce",
   "metadata": {},
   "source": [
    "Além das operações acima, podemos realizar operações com mais de um vetor, como somar dois vetores. Para tal, defina um vetor **s** conforme abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "b85793c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = np.array([1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9caebcf",
   "metadata": {},
   "source": [
    "Em seguida, crie um novo vetor **b** que seja dado pela soma de **k** e **s**. Observe que o resultado será a soma elemento a elemento dos dois vetores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "cb9a1114",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  6,  9, 12, 15])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = k + s\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46936617",
   "metadata": {},
   "source": [
    "Além das operações aritméticas, **operações lógicas** também podem ser realizadas com os vetores. Considerando o vetor **b** criado acima, podemos verificar quais elementos são maiores ou iguais a 9 com:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "d484ac4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True,  True,  True])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b >= 9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1591e892",
   "metadata": {},
   "source": [
    "Repare que o resultado encontrado foi True (verdadeiro) para os elementos maiores ou iguais a 9 e False (falso) caso contrário. Ou seja, a operação reporta um resultado lógico.\n",
    "\n",
    "Como anteriormente, se o interesse for reportar os valores maiores ou iguais a 9, podemos utilizar a operação abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "690627fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9, 12, 15])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[b >= 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2784d451",
   "metadata": {},
   "source": [
    "Se o interesse for encontrar a posição desses valores maiores ou iguais a 9, você pode utilizar a função `np.where()`. Nesse caso, o resultado será \"3 4 5\", ou seja, os elementos maiores ou iguais a 9 são aqueles nas posições 3, 4 e 5. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "be006d7d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([2, 3, 4], dtype=int64),)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(b >= 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "762f8079",
   "metadata": {},
   "source": [
    "## 5.4. Funções com vetores  \n",
    "\n",
    "Diversas funções matemáticas e estatísticas podem ser aplicadas aos vetores numéricos, como soma, média, valor máximo, mínimo, quantis, entre outras.\n",
    "\n",
    "A tabela abaixo apresenta algumas dessas funções:\n",
    "\n",
    "Função             | Descrição\n",
    ":------------------|:------------\n",
    "`np.sum()` \t       | Retorna a soma do vetor\n",
    "`np.min()`\t       | Retorna o valor mínimo do vetor\n",
    "`np.max()`   \t   | Retorna o valor máximo do vetor\n",
    "`np.mean()`        | Retorna a média do vetor\n",
    "`np.median()`      | Retorna a mediana do vetor\n",
    "`np.var()` \t       | Retorna a variância do vetor\n",
    "`np.std()`         | Retorna o desvio padrão do vetor\n",
    "\n",
    "Para praticar alguns desses operadores vamos utilizar o vetor **k** definido anteriomente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "bf85e5dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "081ca320",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "0f17f57d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "5e35985a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "daf17a49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "b935aa73",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "451563a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.var(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "6c9f3d23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.8284271247461903"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db8a1bcc",
   "metadata": {},
   "source": [
    "Essas mesmas funções e outras podem ser utilizadas tanto para vetores quanto para matrizes, que serão o tema do próximo tópico. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}