{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tvXxLwaZNamx"
   },
   "source": [
    "# Ligeira Introdução à Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PLVu2oAXNam0"
   },
   "source": [
    "Olá! Esta é uma rápida introdução à programação em Python, que lhe servirá de base enquanto percorre os _12 Passos para Navier-Stokes_.  \n",
    "\n",
    "Existem duas maneiras para você aproveitar estas lições com Python:\n",
    "\n",
    "1. Você pode baixar e instalar a distribuição de Python no seu computador. Existe uma distribuição grátis [Anaconda Scientific Python](https://store.continuum.io/cshop/anaconda/). E outra [Canopy](https://www.enthought.com/products/canopy/academic/), que é grátis para fins acadêmicos. Nossa recomendação é Anaconda.\n",
    "\n",
    "2. Você pode executar Python na nuvem (nenhum software precisa ser instalado) usando [Binder](https://mybinder.org/) ou [Research Colab](https://colab.research.google.com/), o último requer um conta Google.\n",
    "\n",
    "Em qualquer caso, você provavelmente queira baixar uma cópia desse notebook, ou de toda a coleção _12 Passos para Navier-Stokes_. Recomendamos que você siga cada lição experimentando o código no notebook, ou digitando o código em uma seção interativa Python separada.\n",
    "\n",
    "Se você decidir trabalhar em uma instalação Python local, use o terminal para navegar até o diretório que contenha os arquivos `.ipynb`. Então lance o servidor notebook digitando:\n",
    "```\n",
    "python notebook\n",
    "```\n",
    "\n",
    "Uma nova janela ou aba será aberta em seu navegador, com a lista de notebooks disponíveis no diretório. Clique em uma e começa a trabalhar!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l3SNfPoSNam1"
   },
   "source": [
    "## Bibliotecas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GZ-LLl3NNam2"
   },
   "source": [
    "Python é uma linguagem de programação de código aberto e de alto nível. Além disso, o _mundo Python_ é habitado por diversos pacotes, ou bibliotecas, que nos fornecem ferramentas úteis, tais como operações com arranjos, ferramentas gráficas, e muito mais. Nós podemos importar estas bibliotecas de funções para expandir a capacidade do Python em nossas aplicações.  \n",
    "\n",
    "Muito bem! Vamos começar importando algumas bibliotecas que irão nos ajudar. Primeiramente: nossa biblioteca preferida é **NumPy**, que fornece uma série utilidades para manipulação de arranjos multidimensionais (similar ao MATLAB). Nós vamos a utilizar constantemente! A segunda biblioteca que precisamos é **Matplotlib**, uma biblioteca para produção de gráficos, que usaremos para apresentar nossos resultados.\n",
    "O seguinte bloco de código estará no cabeçalho da maioria dos nossos programas, então, execute esta célular primeiro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "StPqGFQ3Nam3"
   },
   "outputs": [],
   "source": [
    "# <-- comentários em Python são indicados pelo jogo da velha, igual a esse\n",
    "\n",
    "import numpy                   # importamos a biblioteca de arranjos\n",
    "from matplotlib import pyplot  # importamos a biblioteca gráfica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FgBSs_eVNam9"
   },
   "source": [
    "Nós importamos uma biblioteca denominada `numpy` e o módulo `pyplot` de uma grande biblioteca denominada `matplotlib`.\n",
    "Para usar uma função pertencente a uma destas bibliotecas, nós temos que informar ao Python onde procurar por ela. Para isso, o nome de cada função é escrito seguindo o nome da biblioteca que a contem, com um ponto entre eles.\n",
    "Então, se queremos usar a função Numpy [linspace()](http://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html), que cria um arranjo com números de espaçamento constante entre `start` e `end`, nós a invocamos escrevendo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 53
    },
    "colab_type": "code",
    "id": "QRwkoXX0Nam-",
    "outputId": "ca0c53c3-0f20-444b-f909-d9c8bbaa930d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.55555556, 1.11111111, 1.66666667, 2.22222222,\n",
       "       2.77777778, 3.33333333, 3.88888889, 4.44444444, 5.        ])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray = numpy.linspace(0, 5, 10)\n",
    "myarray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vjVa4M1fNanC"
   },
   "source": [
    "Se não precedermos a função `linspace()` com `numpy`, Python irá exibir uma mensagem de erro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 172
    },
    "colab_type": "code",
    "id": "OEaUdwGENanE",
    "outputId": "a039c6c9-01fd-4953-c08c-b0742d71384f"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'linspace' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-14f926e9cd07>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmyarray\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlinspace\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'linspace' is not defined"
     ]
    }
   ],
   "source": [
    "myarray = linspace(0, 5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3LdzUbXiNanI"
   },
   "source": [
    "A função `linspace()` é muito útil. Tente mudar os parâmetros de entrada da função!\n",
    "\n",
    "**Estilos de importação:**\n",
    "\n",
    "Você verá frequentemente trechos de código com as seguintes linhas\n",
    "```python\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "```\n",
    "Mas qual a ideia envolvida com `import as`? Esta é uma maneira de criar um _atalho_ para a biblioteca Numpy e para o módulo pyplot. Você verá isso frequentemente como prática comum, mas nós preferimos manter as importações explícitas. Acreditamos que isso ajuda na legibilidade do código.\n",
    "\n",
    "**Dica de especialista:**\n",
    "\n",
    "Algumas vezes você verá pessoas importanto uma biblioteca completa sem designar nenhum atalho para ela  (`from numpy import *`, por exemplo). Isso é uma economia em digitação, entretanto, isso pode ser traiçoeiro e lhe colocar em problemas. O melhor é desenvolver bons habitos desde o início.\n",
    "\n",
    "\n",
    "Para aprender novas funções disponíveis para você, visite a página [NumPy Reference](http://docs.scipy.org/doc/numpy/reference/). Se você é um usuário com experiência em `Matlab`, existe uma página wiki que pode ser muito útil para você: [NumPy for Matlab Users](http://wiki.scipy.org/NumPy_for_Matlab_Users)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6j8V2qwqNanJ"
   },
   "source": [
    "## Variáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "e5XFE8sRNanK"
   },
   "source": [
    "Python não demanda que as variáveis sejam explicitamente declaradas, como acontece em C, Fortran e outras linguagens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6aj9sj2pNanL"
   },
   "outputs": [],
   "source": [
    "a = 5        #a é um inteiro 5\n",
    "b = 'cinco'  #b armazena os carcteres da palavra 'cinco'\n",
    "c = 5.0      #c é um número em ponto flutuante 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "iUkJaOZbNanP",
    "outputId": "f1727f60-9113-4bdd-e7b8-f594ebaf71fb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "Pqi0zK8kNanT",
    "outputId": "9b0e5142-d357-4421-a5bc-df009e916ab8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "KMBkGjBINanW",
    "outputId": "799186cf-d382-4d9e-bf6a-84052e9d444a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KmPWCQtnNanZ"
   },
   "source": [
    "Note que se você dividir um inteiro por outro e a operação apresentar um resto, o resultado será convertido para _float_ (isso é *diferente* do comportamento no Python 2.7, fique atento)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HhfHq7rbNana"
   },
   "source": [
    "## Espaços em branco em Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gnINGJoqNanb"
   },
   "source": [
    "Python utiliza indentação e espaços em branco para delimitar regiões compreendidas em um bloco de código. Para escrever um laço em C, você usaria:\n",
    "```c\n",
    "for (i = 0, i < 5, i++){\n",
    "    printf(\"Hi! \\n\");\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pUVV-NLrNanc"
   },
   "source": [
    "Python não precisa de delimitações por colchetes, de modo que o mesmo procedimento em Python é escrito como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 197
    },
    "colab_type": "code",
    "id": "O5XLz00WNand",
    "outputId": "65e82c90-1811-49fb-a5d5-a9c8c6e96b59"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi \n",
      "\n",
      "Hi \n",
      "\n",
      "Hi \n",
      "\n",
      "Hi \n",
      "\n",
      "Hi \n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(\"Hi \\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nfLy_c8GNanh"
   },
   "source": [
    "Para o caso de laços aninhados, basta acrescentar uma indentação extra para o laço interno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 233
    },
    "colab_type": "code",
    "id": "7oEU7wcWNani",
    "outputId": "c36410a5-f445-45f6-ceef-25466d6fb4ee"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n",
      "0 1\n",
      "0 2\n",
      "Esta frase está no laço i, mas não no laço j\n",
      "1 0\n",
      "1 1\n",
      "1 2\n",
      "Esta frase está no laço i, mas não no laço j\n",
      "2 0\n",
      "2 1\n",
      "2 2\n",
      "Esta frase está no laço i, mas não no laço j\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    for j in range(3):\n",
    "        print(i, j)\n",
    "    \n",
    "    print(\"Esta frase está no laço i, mas não no laço j\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z7isB_9YNanl"
   },
   "source": [
    "## Manipulação de arranjos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zT5oR-QqNann"
   },
   "source": [
    "Com NumPy, você pode olhar para porções individuais de um arranjo de maneira análoga ao efetuado com `Matlab`, mas com alguns truques extras disponíveis. Vamos partir de um arranjo com valores de 1 a 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "dk6mwo-XNano",
    "outputId": "61d79b8a-6107-444c-f883-daef9a49d748"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myvals = numpy.array([1, 2, 3, 4, 5])\n",
    "myvals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "J0UZiFNENans"
   },
   "source": [
    "Python emprega **indexação baseada em zero**, então vamos observar o primeiro e último elemento no arranjo `myvals`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "VBkooyOmNant",
    "outputId": "fc78f24d-d734-46ec-fff1-03e3d33f33f6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myvals[0], myvals[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3EkO_KB0Nanw"
   },
   "source": [
    "Existem 5 elementos no arranjo `myvals`, mas se tentarmos acessar `myvals[5]`, teremos um erro, uma vez que `myvals[5]` está de fato tentando acessar o sexto elemento do arranjo, que nem sequer existe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 172
    },
    "colab_type": "code",
    "id": "0AMRIYgZNanx",
    "outputId": "4616106d-6a3b-4300-a7bb-23e598c52994"
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "index 5 is out of bounds for axis 0 with size 5",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-ec3139020744>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmyvals\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: index 5 is out of bounds for axis 0 with size 5"
     ]
    }
   ],
   "source": [
    "myvals[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GZPP7TMWNan1"
   },
   "source": [
    "Arranjos também podem ser _fatiados_ para um intervalo de valores. Vamos ver os primeiros três elementos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "8lhPEBpTNan3",
    "outputId": "7d8dffdd-1667-4f46-d890-61c70d8ca00b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myvals[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "s5FVJK6zNan6"
   },
   "source": [
    "Perceba que a fatia inclui a marcação inicial, mas exclui a final, de modo que o comando acima retorno os valores para `myvals[0]`, `myvals[1]` e `myvals[2]`, mas não inclui `myvals[3]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4YAVNuyvNan7"
   },
   "source": [
    "## Atribuições para variáveis em arranjo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EipaootSNan8"
   },
   "source": [
    "A atribução e comparação de valores em arranjos são capacidades do Python que podem confundir usuarios iniciantes. Temos que um exemplo, considerando um arranjo 1D denominado $a$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kEXz18BONan9"
   },
   "outputs": [],
   "source": [
    "a = numpy.linspace(1,5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "N2pwwHIxNaoB",
    "outputId": "1baa37f1-b9f5-4c44-ec7b-3bc266499e2e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4., 5.])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HT5rsBjGNaoJ"
   },
   "source": [
    "Certo, então temos um arranjo $a$, com valores de 1 ao 5. Eu quero fazer uma cópia desse arranjo, denominando $b$, então vou tentar o seguinte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KOJpjL4zNaoK"
   },
   "outputs": [],
   "source": [
    "b = a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "nGZLkqNyNaoN",
    "outputId": "54199b8f-26a8-4bf3-db76-d273dcb21391"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4., 5.])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0vdXbW78NaoQ"
   },
   "source": [
    "Ótimo. Então $a$ possui os valores de 1 ao 5, assim como $b$. Agora que temos uma cópia de $a$, podemos alterar seus valores sem preocupação de perder os dados (ou foi o que pensei!)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "j4MgG3kjNaoR"
   },
   "outputs": [],
   "source": [
    "a[2] = 17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "_MEoLY89NaoU",
    "outputId": "2565d17c-6d2b-401e-a779-b0acafcdec37"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2., 17.,  4.,  5.])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ng_wmYDzNaoX"
   },
   "source": [
    "Aqui, o terceiro elemento de $a$ foi alterado para 17. Agora vamos conferir $b$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "ePi5isbKNaoY",
    "outputId": "f319daeb-0f2a-4739-e4ac-05e6a9052eb0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2., 17.,  4.,  5.])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IMn7YXpfNaob"
   },
   "source": [
    "E é aqui que as coisas deram errado! Quando usamos uma definição como $a = b$, ao invés de copiar todos os valores de $a$ para $b$, Python criou apenas um pseudônimo (_alias_, ou apontador) chamado $b$ e indicou para ele ser uma rota para $a$. Então, ao mudarmos um valor em $a$, a mudança será prontamente refletida em $b$ (isso é chamado tecnicamente de *designação por referência*). Para efetivamente criar uma cópia de um arranjo, você precisa informar ao Python para copiar todos os elementos de $a$ para um novo arranjo. Vamos chama-lo de $c$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KV5SYYdmNaoc"
   },
   "outputs": [],
   "source": [
    "c = a.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dAFZeWh3Naof"
   },
   "source": [
    "Agora, podemos alterar novamente um valor em $a$ e ver se isso também se reflete em $c$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XGjXFqPMNaog"
   },
   "outputs": [],
   "source": [
    "a[2] = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "e3PYbbkdNaom",
    "outputId": "96327650-197a-4102-e6df-43645def7c54"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4., 5.])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "Ujfx6iYmNaoq",
    "outputId": "dd1e3e9d-02ce-40d8-9d4d-c18de894f94d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2., 17.,  4.,  5.])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SWosOFgxNaot"
   },
   "source": [
    "Certo, funcionou! Se a diferença entre `a = b` e `a = b.copy()` não ficou clara para você, recomendamos que leia esta etapa novamente. Caso contrário esse problema pode voltar para atormentá-lo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UzeV5zl5Naot"
   },
   "source": [
    "## Material Complementar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jje9R0J5Naou"
   },
   "source": [
    "Existem muitos recursos disponíveis online para você aprender mais sobre Numpy e outras bibliotecas. Para leitura complementar em português, recomendamos que você acesse [Aprenda.py](https://fschuch.github.io/aprenda.py/). Ou proceda para o [Passo 1](./01_Passo_1.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 334
    },
    "colab_type": "code",
    "id": "PRBIKuf6Naoy",
    "outputId": "684edaf2-fedd-443b-9e2e-ae26091b5f56"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n",
       "<style>\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "    }\n",
       "    div.cell{\n",
       "        width:800px;\n",
       "        margin-left:16% !important;\n",
       "        margin-right:auto;\n",
       "    }\n",
       "    h1 {\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "    }\n",
       "    h2 {\n",
       "        font-family: 'Fenix', serif;\n",
       "    }\n",
       "    h3{\n",
       "\t\tfont-family: 'Fenix', serif;\n",
       "        margin-top:12px;\n",
       "        margin-bottom: 3px;\n",
       "       }\n",
       "\th4{\n",
       "\t\tfont-family: 'Fenix', serif;\n",
       "       }\n",
       "    h5 {\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "    }\t   \n",
       "    div.text_cell_render{\n",
       "        font-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n",
       "        line-height: 135%;\n",
       "        font-size: 120%;\n",
       "        width:600px;\n",
       "        margin-left:auto;\n",
       "        margin-right:auto;\n",
       "    }\n",
       "    .CodeMirror{\n",
       "            font-family: \"Source Code Pro\";\n",
       "\t\t\tfont-size: 90%;\n",
       "    }\n",
       "/*    .prompt{\n",
       "        display: None;\n",
       "    }*/\n",
       "    .text_cell_render h1 {\n",
       "        font-weight: 200;\n",
       "        font-size: 50pt;\n",
       "\t\tline-height: 100%;\n",
       "        color:#CD2305;\n",
       "        margin-bottom: 0.5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\t\n",
       "    .text_cell_render h5 {\n",
       "        font-weight: 300;\n",
       "        font-size: 16pt;\n",
       "        color: #CD2305;\n",
       "        font-style: italic;\n",
       "        margin-bottom: .5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\n",
       "    \n",
       "    .warning{\n",
       "        color: rgb( 240, 20, 20 )\n",
       "        }  \n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"]\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "def css_styling():\n",
    "    styles = open(\"../styles/custom.css\", \"r\").read()\n",
    "    return HTML(styles)\n",
    "css_styling()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> A célula acima executa o estilo para esse notebook. Nós modificamos o estilo encontrado no GitHub de [CamDavidsonPilon](https://github.com/CamDavidsonPilon), [@Cmrn_DP](https://twitter.com/cmrn_dp)."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "00_Quick_Python_Intro.ipynb",
   "provenance": []
  },
  "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}