PL_Python_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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"
    },
    "latex_metadata": {
      "author": "Andreas C. M\\\"ller",
      "title": "Machine Learning with Python"
    },
    "colab": {
      "name": "PL_Python_1.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Rogerio-mack/Ling-de-Prog-para-Ciencia-de-Dados/blob/main/PL_Python_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pqEhMdFQO3A-"
      },
      "source": [
        "<head>\n",
        "  <meta name=\"author\" content=\"Rogério de Oliveira\">\n",
        "  <meta institution=\"author\" content=\"Universidade Presbiteriana Mackenzie\">\n",
        "</head>\n",
        "\n",
        "<img src=\"http://meusite.mackenzie.br/rogerio/mackenzie_logo/UPM.2_horizontal_vermelho.jpg\" width=300, align=\"right\"> \n",
        "\n",
        "<h1 align=left><font size = 8, style=\"color:rgb(200,0,0)\"><b>Ciência de Dados </b></font></h1> \n",
        "<h1 align=left><font size = 5, style=\"color:rgb(0,0,0)\"><b>Paradigmas de Linguagens de\n",
        "Programação para Ciência de Dados</b></font></h1> \n",
        "\n",
        "# 1 Introdução à Programação Python\n",
        "Professores: *Diego Nogare* & *Rogério de Oliveira* \n",
        "\n",
        "<br>\n",
        "<br>\n",
        "\n",
        "---\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lc3bFUWy-iRu"
      },
      "source": [
        "# Apresentação da Componente Curricular\n",
        "\n",
        "Esta componente visa fornecer a você uma introdução às linguagens e ambientes de programação mais empregados para Ciência de Dados.\n",
        "\n",
        "Ao longo de texto apresentamos e exploramos os conceitos com várias implementações em Python, R e seu pacotes. Mas este **não é um curso de programação**. O uso dessas implementações é útil para explorarmos e aprofundarmos os conceitos aprendidos e habilitarão você mais adiante a fazer análises de dados e criar modelos simples aprendizado de máquina. Você poderá apreciar e compreender vários dos conceitos apresentados aqui com uma apenas uma leitura diagonal dos códigos e **os exercícios e atividades propostos requerem basicamente apenas o reuso de modelos de códigos e soluções prontas, com pequenas adaptações a cada problema**. Algo que não exige nada além de atenção e alguma dedicação. Isso não é a codificação e implementação de soluções, mas não é esperado que você seja ou se torne um programador ou desenvolvedor. Mas esses exercícios irão fornecer para você uma experiência com o uso de soluções de análise e aprendizado máquina em Python e R, uma porta de entrada para essas ferramentas. Assim, **tenha em mente que há uma grande quantidade de material aqui, e você pode se ater somente aos objetivos da trilha (nossa porta de entrada!)** e deixar para explorar todo o material mais adiante, na medida do seu interesse, disponibilidade e conhecimentos prévios.\n",
        "\n",
        "Como outros textos que incluem programação, o código é parte integrante do texto e é importante que você acompanhe a leitura dos códigos fornecidos com execuções, experimentações e se tiver interesse, consultando a documentação das api's e pacotes empregados. O texto discute o que é essencial nos códigos mas não discute cada comando e detalhe da codificação. Isso pode ser lido diretamente no código dos programas, e opções menos importantes podem ser exploradas pelo leitor na documentação dos pacotes.\n",
        "\n",
        "A componente está dividida em duas partes. A primeira parte é dedicada à linguagem Python e seus ambientes. Na segunda você aprenderá a linguagem R. \n",
        "\n",
        "Ambas são linguagens bastante empregadas em Ciência de Dados e, em geral, a opção de uma ou outra depende mais do contexto de uso. Embora pareça haver uma uma predominância do Python nos últimos anos isso pode depender da área de domínio em que estamos interessados. O R ainda parece dominar a aplicação em áreas como bioinformática e ciências sociais, onde há muito tempo são aplicados modelos estatísticos com R. Já aplicações de comércio eletrônico e marketing, assim como modelos que tratam imagens ou linguagem natural o Python em geral parece ser uma melhor solução.\n",
        "\n",
        "Por que essas linguagens e não linguagens como Java ou C? A Ciência de Dados tem algumas características que a diferem do desenvolvimento tradicional de aplicações. A integração com recursos para Web ou para aplicações Mobile, por exemplo, é essencial para o desenvolvimento aplicações, mas tem um papel bastante secundário em Ciência de Dados. Além disso aplicações tradicionais são voltadas em muitos casos para o processamento transacional, empregando quantidades relativamente pequenas de dados. Por outro lado, *script languages* e tipos de dados fracos, são vantajosos quando queremos experimentar diferentes execuções para exploração de dados que não temos clareza ainda de tipos e valores. Isso também norteará o nosso curso pois estaremos focados nos recursos das linguagens Python e R para desenvolver análises e ciência de dados, havendo muitos outros recursos que não exploraremos aqui.\n",
        "\n",
        "Existem também muitas ferramentas para Ciência de Dados (soluções de *spreadsheet view of data*, *drag-and-drop tools* com funções pré-definidas,  dentre outras) e talvez você esteja familiarizado com alguns nomes como SAS, PowerBI, Tableau, Qlik, SPSS etc. e, não obstante o uso bastante comum dessas soluções elas são bastante proprietárias e o uso de linguagens de programação oferece, em geral, mais flexibilidade, independência e possibilidade de reuso. De qualquer modo essas ferramentas permitem proporcionar muitos primeiros resultados de forma muito rápida e não devem ser descartadas se estiverem disponíveis. \n",
        "\n",
        "Por último há também outras linguagens como Scala, Julia e o próprio Java que apresentam uso em Ciência de Dados em alguns contextos mais específicos e, ao final, o uso de uma solução ou outra deve ser analisada caso a caso sem, necessariamente, assumirmos uma ou outra como melhor e, na maior parte dos casos empregaremos muitas soluções conjuntas.\n",
        "\n",
        "Vamos lá? ;-)\n",
        "\n",
        "## Programa \n",
        "\n",
        "Para que tenha uma ideia geral dos conteúdos desta componente, segue abaixo os pontos que serão vistos em cada trilha.\n",
        "\n",
        "1. **Introdução à Programação Python**. *Básico da Linguagem, IPython e Jupyter Notebooks, Estruturas de Dados (listas, dicionários), funções e arquivos*\n",
        "2. **Seleção e Organização de Dados com Pandas**. *Aquisição dos Dados, Tipos de Dados, Seleção e Manipulação, Merges e Joins*\n",
        "3. **Visualização dos Dados com Matplotlib e Seaborn**. *Gráficos de Linha, de Distribuição (Histograma, Densidade, Boxplot), Linhas de Tendências, Gráficos de barras e mapas de calor*\n",
        "4. **Estudos de Caso de Análise de Dados I**. *Apresentação e Discussão de casos de análise de dados com Python.*\n",
        "5. **Introdução à Programação R**. *Básico da Linguagem, ambientes RStudio e Rstudio.cloud, Dataframes em R, seleção e manipulação de dados*\n",
        "6. **Seleção e Organização de Dados com Tidyr e Dplyr**. *Seleção e manipulação de dados, reshape de dados, implementação de pipelines*\n",
        "7. **Visualização de Dados com ggplot2**. *Introdução a gramática do ggplot2, principais gráficos: Gráficos de Linha, de Distribuição, Linhas de Tendências, barras e mapas de calor*\n",
        "8. **Estudos de Caso de Análise de Dados II**. *Apresentação e Discussão de casos de análise de dados com R.*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4pJask4BvIUL"
      },
      "source": [
        "# Introdução \n",
        "\n",
        "\n",
        "Nesta trilha você irá aprender a empregar um ambiente de Programação Python interativo e que iremos utilizar ao longo desta componente. Você vai conhecer também outras alternativas de ambiente que você poderá usar.\n",
        "\n",
        "A familiaridade com alguma linguagem de programação Java, Java Script, C não é necessariamente obrigatória, mas ajuda bastante e você pode fazer um paralelo dessa linguagem com o Python. Python é uma linguagem simples, fácil de usar e com uma curva de aprendizado muito rápida. Ela implementa todos conceitos comuns de programação como variável, atribuição, tipos de dados básicos como numéricos e cadeias de caracteres, laços e condicionais de programa, e entrada e saída de dados básicas. \n",
        "\n",
        "Vamos então percorrer os principais conceitos da linguagem Python: variáveis e tipos, atribuições, operações numéricas, entradas e saídas de dados básicas pelo terminal, instruções de controle de fluxo, uso de funções, acesso básico a arquivos e as coleções de dados do Python, listas, sets, tuplas e dicionários.  Ao final vamos também ver algumas funções da biblioteca Numpy que implementa uma série de funções sobre arrays numéricos que são muito úteis no uso de Python para processamento científico de análise de dados.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NMA0_zHO_qh0"
      },
      "source": [
        "# Ambientes Python de Programação "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rewsejvwt-BO"
      },
      "source": [
        "## Ambiente Google Colaboratory ou `Colab`\n",
        "\n",
        "O Google Colaboratory ou simplesmente *Colab* é um ambiente que permite você  escrever código Python diretamente em seu navegador, sem nenhuma configuração ou instalação de softwares necessária, e que ainda fornece acesso a recursos de GPU para o processamento e compartilhamento fácil de código (GitHub, Google Drive etc.). Para acessar, basta digitar no seu navegador https://colab.research.google.com/. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nDvkveEM83mf"
      },
      "source": [
        "<img src=\"http://meusite.mackenzie.br/rogerio/LP/LP.png\" width=900, align=\"center\"> "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5fCEDCU_qrC0"
      },
      "source": [
        "Esse será nosso ambiente preferencial de programação Python e, mais adiante, ao estudar a linguagem R você encontrará um ambiente semelhante para o desenvolvimento em R. \n",
        "\n",
        "O Colaboratory ou \"Colab\" permite escrever código Python no seu navegador, com: \n",
        "- Nenhuma configuração necessária\n",
        "- Acesso gratuito a GPUs\n",
        "- Compartilhamento fácil\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GJBs_flRovLc"
      },
      "source": [
        "## Notebooks Python\n",
        "\n",
        "Os notebooks Python (**Jupyter** notebooks) permitem combinar <strong>código executável</strong> e <strong>rich text</strong> e as saídas do seu código em um só documento, além de <strong>imagens</strong>, <strong>HTML</strong>, <strong>LaTeX</strong> e muito mais. O documento dos notebooks Python são dividos em\n",
        "\n",
        "- **Celulas de Código** \n",
        "- **Celulas de Texto**\n",
        "- a as saídas dos Programas\n",
        "\n",
        "O documento que você está lendo não é uma página da Web estática, mas sim um ambiente interativo chamado <strong>notebook Colab</strong> que permite escrever e executar código.\n",
        "\n",
        "Por exemplo, aqui está uma <strong>célula de código</strong> com um breve script Python que calcula um valor, armazena-o em uma variável e imprime o resultado:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "id": "gJr_9dXGpJ05",
        "outputId": "9f556d03-ec67-4950-a485-cfdba9ddd14d"
      },
      "source": [
        "seconds_in_a_day = 24 * 60 * 60\n",
        "seconds_in_a_day"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "86400"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 0
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pPZLdhy5Q6TZ"
      },
      "source": [
        "## Células de Código\n",
        "\n",
        "As células de código podem conter qualquer script Python."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fXmiIc01RHWR",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        },
        "outputId": "709f487c-b722-459d-c32c-09fb198e80eb"
      },
      "source": [
        "# imports\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "cores = 'rgbcmyk'\n",
        "label = ['red','green','blue','cyan','magenta','yellow','black']\n",
        "\n",
        "n = int( input('Entre com um número inteiro: ') )\n",
        "\n",
        "cor = n % len(cores)\n",
        "\n",
        "x = 200 + np.random.randn(100)\n",
        "plt.plot(x,color=cores[cor])\n",
        "\n",
        "plt.title(label[cor].upper(),fontsize=14)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Entre com um número inteiro: 5\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZfGZ_TasuViM"
      },
      "source": [
        "### Alerta importante: Espaço de Trabalho\n",
        "\n",
        "Todas as células compartilham o mesmo espaço de execução. Assim as variáveis de criadas e alteradas em uma célula são imediatamente acessíveis a todas as demais células. Independente da ordem em que aparecem. \n",
        "\n",
        "- As células de código não são programas independentes\n",
        "- Seus resultados persistem após cada execução\n",
        "\n",
        "Como você pode executar qualquer célula a qualquer momento a ideia execução *sequencial* do programa é aqui um pouco modificada."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cGoSdW2PuViU"
      },
      "source": [
        "x = np.random.randint(10) # gera um valor aleatório entre 0 e 100"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4m0kakCsuViU",
        "outputId": "00c90e01-4f27-488b-f110-23d9b001be02"
      },
      "source": [
        "# Você pode executar essa célula uma vez, mas ganhará um erro ao executá-la novamente\n",
        "print(x) \n",
        "del x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HeFMabhHUFax"
      },
      "source": [
        "## Células de Texto\n",
        "\n",
        "As células de texto são criadas no formato **Markdown**. Clique duas vezes no texto para editar uma célula e você pode querer empregar barra de ferramentas para formata-lo ou, quando estiver mais familiarizado com a notação **Markdown**, escrever diretamente a formatação. Experimente abaixo.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2fhs6GZ4qFMx"
      },
      "source": [
        "---\n",
        "> ### **Títulos**\n",
        "--- \n",
        "```\n",
        "# Título 1\n",
        "\n",
        "## Título 2\n",
        "\n",
        "### Título 3\n",
        "```\n",
        "> Produz...\n",
        "\n",
        "# Título 1\n",
        "\n",
        "## Título 2\n",
        "\n",
        "### Título 3\n",
        "\n",
        "---\n",
        "> ### Textos \n",
        "--- \n",
        "```\n",
        "**bold**\n",
        "\n",
        "*italic*\n",
        "```\n",
        "> Produz...\n",
        "\n",
        "**bold**\n",
        "\n",
        "*italic*\n",
        "\n",
        "---\n",
        "> ### Identação\n",
        "---\n",
        "```\n",
        "> indent 1\n",
        "\n",
        ">> indent 2\n",
        "```\n",
        "> Produz... \n",
        "\n",
        "> indent 1\n",
        "\n",
        ">> indent 2\n",
        "\n",
        "--- \n",
        "### Listas\n",
        "---\n",
        "```\n",
        "* item  \n",
        "* item\n",
        "* item\n",
        "```\n",
        "> Produz...\n",
        "\n",
        "* item  \n",
        "* item\n",
        "* item\n",
        "\n",
        "> ou\n",
        "\n",
        "```\n",
        "1. item 1\n",
        "2. item 2\n",
        "3. item 3\n",
        "```\n",
        "> Produz...\n",
        "\n",
        "1. item 1\n",
        "2. item 2\n",
        "3. item 3\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aIBwXwOCYSXp"
      },
      "source": [
        "## Salvando e abrindo um Colab notebook\n",
        "\n",
        "Seus notebooks Pythons são **salvos no seu Google Drive**. Mas **CUIDADO!** suas alterações são salvas **automaticamente**! **RECOMENDO** você empregar a opção `Arquivo >` na barra de ferramentas para carregar ou salvar seu notebook Python em um arquivo `.ipynb`. \n",
        "\n",
        "* `Arquivo > Fazer download > Fazer download do .ipynb`\n",
        "* `Arquivo > Faze upload de um notebook`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eGCYLQKCcWEq"
      },
      "source": [
        "## Python notebook $\\times$ IDE's\n",
        "\n",
        "O uso de notebooks Python tem a vantagem de ser de fácil acesso, compartilhar em um mesmo documento código, texto e suas saídas e facilitar o trabalho colaborativo. Tem sido uma opção bastante aplicada em soluções de **Ciência de Dados** e a preferencial para o ensino.\n",
        "\n",
        "Projetos mais complexos que envolvem programas longos e em grande número podem se beneficiar do uso de ambientes integrados de desenvolvimento (IDE's) como o PyCharm, Visual Code ou o Spyder para maior produtividade. \n",
        "\n",
        "- notebooks Python, extensão `.ipynb`\n",
        "- scripts Python, extensão `.py`\n",
        "\n",
        "Para uso de um ambiente Python local recomendamos a instalação do ambiente [Anaconda](https://www.anaconda.com/products/individual). Ele irá incluir a instalação do Python, do ambiente [Jupyter](https://jupyter.org/) notebook local e do IDE [Spyder](https://www.spyder-ide.org/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8XowDN9Etvef"
      },
      "source": [
        "# Python\n",
        "\n",
        "Python é uma linguagem bastante poderosa e com muitos recursos. Nessa introdução de Python vamos apenas apresentar um conjunto de recursos mínimo de recursos havendo diversas boas fontes online e livros de introdução ao Python."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kuSOumUSw142"
      },
      "source": [
        "## Imports básicos \n",
        "\n",
        "Empregue para importar bibliotecas que adicionam funcionalidades ao Python. Em geral, para nós, os seguintes imports serão suficientes:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qRTKp_OVwxEq"
      },
      "source": [
        "import pandas as pd                  # Pandas para acesso e manipulação de dados\n",
        "import numpy as np                   # Numpy para operações de vetores e matrizes numéricas (arrays)\n",
        "import matplotlib.pyplot as plt      # Bibliotecas de gráficos e visuallização de dados\n",
        "import matplotlib as mpl\n",
        "# import seaborn as sns\n",
        "%matplotlib inline\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oTM8Qhy2tqPj"
      },
      "source": [
        "## Variáveis e Atribuições\n",
        "\n",
        "O `Python` implementa tipos fracos, isto é, você não precisa declarar uma variável antes de empregá-la, ela e seu tipo de dado serão automaticamente definidos na primeira atribuição a um rótulo (nome da variável)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RyTJOsK5qdtB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bb8f32db-2892-4327-b4c3-4aaf3f86e08d"
      },
      "source": [
        "inteiro = 123\n",
        "real = np.pi\n",
        "texto1 = '123'\n",
        "texto2 = 'Led Zeppelin'\n",
        "print(type(inteiro), type(real), type(texto1), type(texto2))\n",
        "print(inteiro, real, texto1, texto2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'> <class 'float'> <class 'str'> <class 'str'>\n",
            "123 3.141592653589793 123 Led Zeppelin\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4JP3gsGP0ZdZ"
      },
      "source": [
        "## Caracteres e Valores Numéricos\n",
        "\n",
        "O `Python` implementa valores numéricos inteiros e de ponto flutuante com as operações básicas, e cadeias de caracteres (`strings`)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5waHa86uur4C",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0a4ce85c-2bed-4378-cb14-e50c31f9bcfa"
      },
      "source": [
        "inteiro = inteiro + 1\n",
        "real = real + 1\n",
        "exto1 = texto1 + '4'\n",
        "texto2 = texto2 + ': Stairway to Heaven'\n",
        "print(inteiro, real, texto1, texto2)\n",
        "print(inteiro, '\\n', real, '\\n', texto1, '\\n', '\\t'*4 , texto2)\n",
        "print('Valor real {:0.2f}'.format(real))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "124 4.141592653589793 123 Led Zeppelin: Stairway to Heaven\n",
            "124 \n",
            " 4.141592653589793 \n",
            " 123 \n",
            " \t\t\t\t Led Zeppelin: Stairway to Heaven\n",
            "Valor real 4.14\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bBO8cKayouUr"
      },
      "source": [
        "### Integer, Float-point, Boolean "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PwIVdvKBouUt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "40e31057-d8de-4c17-e7f4-ac38ee58663c"
      },
      "source": [
        "print(3 * 4, 3 + 4, 3 - 4, 3 / 4, 3.14, 4.2e-4 ) \n",
        "print(type(3 * 4), type(3.14), type(4.2e-4) ) \n",
        "print(3 ** 2, 3 // 4, 3 % 4 )                       # potência, divisão inteira e resto da divisão (mod)\n",
        "print(4 > 3, 4 >= 3, 3 == 3.0, 3 != 4, 3 <= 4 )\n",
        "print(1 < 2 < 9)                                    # boolean\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12 7 -1 0.75 3.14 0.00042\n",
            "<class 'int'> <class 'float'> <class 'float'>\n",
            "9 0 3\n",
            "True True True True True\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MwYZaE9rd2Pm"
      },
      "source": [
        "### Numpy functions\n",
        "\n",
        "As funções básicas estão disponíveis nativamente, mas para muitas funções matemáticas como funções trigonométricas, randomização de valores e constantes como o $\\pi$ e $e$ é necessário recorrer a bibliotecas numéricas como o `numpy` e `math` e, em geral, empregaremos o `numpy` e vermos mais sobre essa biblioteca adiante. \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ud0GcfPXouUy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bceb1e58-158d-4e1b-df46-859ca620d4a1"
      },
      "source": [
        "import numpy as np\n",
        "              \n",
        "print(np.pi)            # pi \n",
        "print(np.exp(1))        # e\n",
        "\n",
        "print(5 % 2)\n",
        "# o mesmo que\n",
        "print(np.mod(5,2))\n",
        "\n",
        "print(np.random.rand(1))\n",
        "print(np.random.sample(10))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.141592653589793\n",
            "2.718281828459045\n",
            "1\n",
            "1\n",
            "[0.10284181]\n",
            "[0.90906841 0.80500469 0.08408398 0.08634413 0.85411987 0.76337207\n",
            " 0.55200052 0.7204412  0.68073271 0.43283886]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RDwLsBxk1JYj"
      },
      "source": [
        "## Strings  \n",
        "\n",
        "As strings em `Python` são como arrays de caracteres e são estruturas **imutáveis**. Isso significa que você não pode em `Python` atribuir um valor a uma posição específica de um array de string. \n",
        "\n",
        "Além disso note a indexação dos *slices* de strings:\n",
        "\n",
        "`str[ inicio : tamanho ]` \n",
        "ou\n",
        "`str[ inicio : fim+1 ]` \n",
        "\n",
        "Elas iniciam por 0 mas, em `Python`, o limite superior indicará um valor $<$ do caracter que será exibido e não $\\le$ como em outras linguagens como C ou Java.\n",
        "\n",
        "```{note}\n",
        "em `Python`, o limite superior indicará um valor $<$ do caracter que será exibido e não $\\le$ como em outras linguagens como C ou Java.\n",
        "\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YfIiwfR71MaH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e72eaeac-c71d-4da1-a008-59f3f72dbce3"
      },
      "source": [
        "print(texto2[0:12])\n",
        "print('0123456789012'[0:12])\n",
        "\n",
        "# e, \n",
        "# texto2[1] = 'x'\n",
        "# não funciona uma vez que uma string é imutável em Python"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Led Zeppelin\n",
            "012345678901\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LbKjbRuaouVL"
      },
      "source": [
        "### Operações com Strings  \n",
        "\n",
        "As operações com strings são implementadas como métodos da classe `string` e algumas dessas operações encontram-se abaixo."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "Pugx1dQpouVM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "71ecfb71-a874-4a50-82a5-f9bbdc987108"
      },
      "source": [
        "str1 ='A arte existe porque a vida não basta. – Ferreira Gullar'\n",
        "\n",
        "print(str1.find('arte'))\n",
        "print(str1.lower())\n",
        "str2 = str1.replace('arte','life')\n",
        "print(str2)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "a arte existe porque a vida não basta. – ferreira gullar\n",
            "A life existe porque a vida não basta. – Ferreira Gullar\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_MYS4zjb17uE"
      },
      "source": [
        "Em geral, em cursos básicos de programação, muita atenção é dada para manipulação Strings e obtenção de *slices*, subconjuntos indexados Strings. Essas operações não são tão importantes aqui para o que desenvolveremos em análise de dados e é então suficiente conhercemos as operações acima. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j3S7qoJTouUb"
      },
      "source": [
        "## Print & Input\n",
        "\n",
        "A operação `input` permite a entrada de dados pelo terminal e mesmo na execução de notebooks `Python`. O `print` exibe a saída de caracteres no terminal e permite o uso de caracteres de controle como `\\n` para salto de linha, `\\t` para *tab* e formatação de números ao estilo de C.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AajnwWcebwRB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e3bf50d4-0e09-43a9-84b1-fd42c21b2c63"
      },
      "source": [
        "# Print & Input...\n",
        "\n",
        "# 'input' não suportado para edição de JupyterBooks, comente e tire os comentários conforme indicado para execução no Colab\n",
        "\n",
        "# text = input('Entre com um texto: ')  # Tire o comentário aqui\n",
        "text = 'Texto'                          # Comente aqui\n",
        "\n",
        "print(type(text))\n",
        "\n",
        "# numero = float(input('Entre com um número: '))  # Tire o comentário aqui\n",
        "numero = 2.25                                     # Comente aqui\n",
        "\n",
        "print('Seu texto: ', text, '\\n', 'Seu número: ', '%0.2f'%numero)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Entre com um texto: Texto\n",
            "<class 'str'>\n",
            "Entre com um número: 2.25\n",
            "Seu texto:  Texto \n",
            " Seu número:  2.25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZAvDpRw6N2lT"
      },
      "source": [
        "## Controle de Fluxo nos Programa"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pFNaHFSEtNow"
      },
      "source": [
        "## If-Then-Else \n",
        "\n",
        "Em  `Python` as instruções **aninhadas** são **identadas** (*tab*), o que corresponde ao `{}` de linguagens como Java e C. Assim os comandos *aninhados* à condição ou laço do programa devem estar à direita do comando inicial da condição ou laço.\n",
        "\n",
        "```\n",
        "Condição 1...\n",
        " Comando A...\n",
        " Comando B...\n",
        " Condição 2...\n",
        "   Comando C...\n",
        "\n",
        " Comando D...\n",
        "\n",
        "Comando E \n",
        "```\n",
        "\n",
        "Comando D executa dentro da condição 1, mas fora da condição 2.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "10t2mTyQouWI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "983f18dc-e4ec-425b-ced5-f8314995ca2b"
      },
      "source": [
        "a = 1964\n",
        "b = 1984\n",
        "if b > a:\n",
        "  print(\"b is greater than a\")\n",
        "else:\n",
        "  print(\"a is greater than b\")  \n",
        "\n",
        "if b > a:\n",
        "  print(\"b is greater than a\")\n",
        "elif a == b:\n",
        "  print(\"a and b are equal\")\n",
        "else:\n",
        "  print(\"a is greater than b\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "b is greater than a\n",
            "b is greater than a\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fDIvl1BCouWM"
      },
      "source": [
        "## For & While \n",
        "\n",
        "Em geral, neste livro vamos dar preferência ao uso do `for` para criar laços de programa. O comando `range(inicio, fim, incremento)` pode ser empregado para definir os limites e o incremento de uma variável em um laço do tipo `for`, mas lembre que o limite indicado, do mesmo modo que a indexação  de uma string, é um limite superior ($<$ e não $\\le$) que nunca é atingido.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f4JG3Y2AouWO"
      },
      "source": [
        "for i in range(5): \n",
        "  print(i)\n",
        "  if i == 3:\n",
        "    break\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4SBHpLUiPC-D"
      },
      "source": [
        "i = 1\n",
        "while i < 6:\n",
        "  print(i)\n",
        "  if i == 3:\n",
        "    break\n",
        "  i += 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kxhHxbpycwXi"
      },
      "source": [
        "As iterações também podem ser feitas sobre listas de valores, numéricos ou não."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SPsO7IpDculz",
        "outputId": "36d4abf8-54fc-4f87-c990-14e0d9b7232e"
      },
      "source": [
        "for i in [12,18,84]:\n",
        "  print(i)\n",
        "\n",
        "for nome in ['Adriana','Daniel','Henrique']:\n",
        "  print(nome)    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12\n",
            "18\n",
            "84\n",
            "Adriana\n",
            "Daniel\n",
            "Henrique\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5incAwfJouWS"
      },
      "source": [
        "## Funções\n",
        "\n",
        "As funções são declaradas com o comando `def`. As variáveis de uma função tem escopo local, mas elas podem também acessar variáveis globais do seu programa.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "43Mk7FeNouWU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7a295374-02c4-4bf7-ca1a-237e23dc5a76"
      },
      "source": [
        "\n",
        "def mymax(a,b):\n",
        "  if a > b:\n",
        "    return a\n",
        "  else:\n",
        "    return b\n",
        "\n",
        "mymax(1984,1964)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1984"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rSR3gzKFPRcH"
      },
      "source": [
        "## Coleções de Dados Básicas\n",
        "\n",
        "Coleções de dados como `Lists`, `Sets`, `Tuples` e `Dictionary` desempenham um papel fundamental tanto para programação em geral como para aplicações gerais como análise de dados. \n",
        "\n",
        "Existem quatro tipos básicos de coleções em Python:\n",
        "\n",
        "- Lista (**list**) é uma coleção que é ordenada e mutável. Permite membros duplicados.\n",
        "- Tupla (**tuple**) é uma coleção que é ordenada e imutável. Permite membros duplicados.\n",
        "- Conjunto (**set**) é uma coleção não ordenada e não indexada. Nenhum membro duplicado.\n",
        "- Dicionário (**dictionary**) é uma coleção desordenada, mutável e indexada. Nenhum membro duplicado.\n",
        "\n",
        "Vamos nos deter aqui apenas nas estruturas de listas e dicionários que terão mais utilidade para os nossos propósitos."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tECT16U2ouVX"
      },
      "source": [
        "### List\n",
        "\n",
        "Lista (**list**) é uma coleção que é **ordenada** e **mutável**. Permite membros **duplicados**. Associada a lista você encontra uma série métodos que implementam funções úteis para esses objetos. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ee3FM2LxR5Ot"
      },
      "source": [
        "mylist = ['A', 'B', 'C', 'A', 'B']\n",
        "\n",
        "# Empregue...\n",
        "# > help(mylist) \n",
        "# para ver todos os métodos associados a listas\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EkLCApTBouVe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c1e25fb0-b535-46ee-f010-5dc60486b3f2"
      },
      "source": [
        "# Métodos comuns associados a listas\n",
        "len(mylist)\n",
        "print(mylist.count('B'))\n",
        "print(mylist.index('B'))\n",
        "print(mylist.index('B', 2))\n",
        "mylist.append('D')\n",
        "print(mylist, 'depois de inserir D')\n",
        "mylist.sort() \n",
        "print(mylist, 'depois de ordenar a lista')\n",
        "mylist[1] = 'ZZ'\n",
        "print(mylist, 'depois de alterar o elementos de índice 1')\n",
        "\n",
        "print('A' in mylist)\n",
        "if 'A' in mylist:\n",
        "  print('Sim, A está na lista')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "2\n",
            "2\n",
            "['A', 'ZZ', 'B', 'B', 'C', 'D', 'D'] depois de inserir D\n",
            "['A', 'B', 'B', 'C', 'D', 'D', 'ZZ'] depois de ordenar a lista\n",
            "['A', 'ZZ', 'B', 'C', 'D', 'D', 'ZZ'] depois de alterar o elementos de índice 1\n",
            "True\n",
            "Sim, A está na lista\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DZHZn1Opfaj8"
      },
      "source": [
        "Listas podem conter quaisquer tipos de elementos, incluindo outras listas, e podem ser empregadas para implementar arrays numéricos embora, para operações eficientes sobre arrays numéricos, seja preferível empregar arrays do pacote `numpy`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XUgfLp0heou7",
        "outputId": "b2458ff8-f49b-418f-d1b6-79161ba12c2e"
      },
      "source": [
        "# Arrays numéricos\n",
        "mylist = [[1,2,3], [11,22,33], [9,9,9]]\n",
        "print(mylist[1])  # [11,22,33]\n",
        "print(mylist[1][0])  # 11\n",
        "\n",
        "# Arrays de quaisquer tipos de dados\n",
        "print([ [1,2,3], ['Adriana','Daniel','Henrique'], 3, 'Anna', 2.5 ])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[11, 22, 33]\n",
            "11\n",
            "[[1, 2, 3], ['Adriana', 'Daniel', 'Henrique'], 3, 'Anna', 2.5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zn4bWeeuouVp"
      },
      "source": [
        "### Percorrendo listas\n",
        "\n",
        "Essa é uma operação que empregaremos bastante. Existem basicamente duas forma de percorrer uma lista.\n",
        "\n",
        "* **Por índice**, empregue quando precisar do índice (posição) ou alterar os elementos da lista\n",
        "\n",
        "* **Por iterador**, empregue apenas para recuperar (ler) os elementos (não permite alteração dos elementos ao percorrer a lista)\n",
        "\n",
        "A segunda forma não está disponível em linguagens como C ou Java, mas ela é a forma mais elegante e, se não for necessário alterar os elementos ou obter o índice ao percorrer a lista é o melhor modo a ser empregado.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L2nN1HjGouVq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b294a07c-827e-4aff-cd53-4aa117ed26cc"
      },
      "source": [
        "mylist = ['A', 'B', 'C', 'A', 'B']\n",
        " \n",
        "for i in range(len(mylist)):    # empregue esse modo para obter o índice ou alterar elementos ao percorrer a lista\n",
        "    print(i, mylist[i])\n",
        "\n",
        "for item in mylist:             # prefida esse modo se não precisar do índice ou de alterar os elementos ao percorrer a lista\n",
        "    print(item) \n",
        "    \n",
        "   "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 A\n",
            "1 B\n",
            "2 C\n",
            "3 A\n",
            "4 B\n",
            "A\n",
            "B\n",
            "C\n",
            "A\n",
            "B\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sC5hqb0fZ3M1"
      },
      "source": [
        "E podemos empregar em conjunto com o método `append` visto antes para popular uma lista."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wkk_jCtGZ3M5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "39b2ed13-a6a6-45eb-f561-9f0cfc5be7df"
      },
      "source": [
        "mylist = []\n",
        " \n",
        "for elem in ['Beatriz', 'Henrique', 'Adriana', 'Daniel']:\n",
        "    mylist.append(elem)\n",
        "\n",
        "print(mylist)\n",
        "\n",
        "  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Beatriz', 'Henrique', 'Adriana', 'Daniel']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1fJXhUmiouV8"
      },
      "source": [
        "### Dictionary\n",
        "\n",
        "Dicionários (**dictionary**) são uma coleção desordenada, mutável e indexada em formato de `chave: valor`. Elas não tem nenhum membro duplicado, e se você já teve algum contato com uma estrutura de dados `JSON` essa é uma estrutura bastante semelhante em `Python`. O principal vantagem dos dicionário é permitir recuperar os valores diretamente a partir do valor de chave. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_k8p8tFDouV9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a584c927-d2fb-42ca-9983-cd0251714bb2"
      },
      "source": [
        "aniversarios = {'Beatriz':1978, 'Henrique':2004, 'Adriana':1984, 'Daniel':1996} \n",
        "  \n",
        "print(aniversarios.keys())\n",
        "print(aniversarios['Adriana'])   \n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dict_keys(['Beatriz', 'Henrique', 'Adriana', 'Daniel'])\n",
            "1984\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-SBVkxZriuSS"
      },
      "source": [
        "Assim como nas listas, os dicionários suportam quaiquer tipos de dados como valores."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H9kUs8PXjHkz",
        "outputId": "1a0e286b-7f4f-4c4a-adb1-17ac4920c102"
      },
      "source": [
        "contatos = { 'Adriana': { 'aniversario': 1984, 'telefone': '6767-6868' , 'amigos': {'Henrique':2004, 'Anna':1988} } }\n",
        "\n",
        "print(contatos.keys())\n",
        "print(contatos['Adriana'])             \n",
        "print(contatos['Adriana']['amigos'])   \n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dict_keys(['Adriana'])\n",
            "{'aniversario': 1984, 'telefone': '6767-6868', 'amigos': {'Henrique': 2004, 'Anna': 1988}}\n",
            "{'Henrique': 2004, 'Anna': 1988}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XmJSMfvmbQac"
      },
      "source": [
        "### Percorrendo um Dicionário  \n",
        "\n",
        "Do mesmo modo que listas é importante sabermos percorrer os elementos de um dicionário. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ytthr2VQbZ3V",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ea22202d-726d-4c75-cbff-c3304738c50c"
      },
      "source": [
        "for key, item in aniversarios.items():\n",
        "    print(key, item)\n",
        "# ou\n",
        "for item in aniversarios:\n",
        "    print(item, aniversarios[item])    \n",
        "# ou      \n",
        "for key in aniversarios.keys():\n",
        "    print(key)   \n",
        "# ou      \n",
        "for item in aniversarios.values():\n",
        "    print(item)   \n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Beatriz 1978\n",
            "Henrique 2004\n",
            "Adriana 1984\n",
            "Daniel 1996\n",
            "Beatriz 1978\n",
            "Henrique 2004\n",
            "Adriana 1984\n",
            "Daniel 1996\n",
            "Beatriz\n",
            "Henrique\n",
            "Adriana\n",
            "Daniel\n",
            "1978\n",
            "2004\n",
            "1984\n",
            "1996\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iAnghYWGbsP2"
      },
      "source": [
        "### Populando um Dicionário "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "on7R1B5Xb6IQ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "2c85b4c5-99e5-457b-f6a6-9f5f69a16c59"
      },
      "source": [
        "lista_nomes = [ 'Carolina', 'Henrique' ]\n",
        "lista_niver = [ 2001, 2005 ]\n",
        "\n",
        "mydict = {}\n",
        "\n",
        "for i in range(len(lista_nomes)): \n",
        "  if lista_nomes[i] not in mydict.keys(): # Se não está no dicionário acrescenta\n",
        "    mydict[lista_nomes[i]] = lista_niver[i]\n",
        "\n",
        "if 'Kate' not in mydict.keys():           # Se não está no dicionário acrescenta\n",
        "  mydict['kate'] = 2002\n",
        "\n",
        "print(mydict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'Carolina': 2001, 'Henrique': 2005, 'kate': 2002}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hlt2vO94ouWa"
      },
      "source": [
        "## File Handling\n",
        "\n",
        "Operações com arquivos tipo texto serão pouco comuns no nosso caso pois, na maior parte dos casos obteremos dados de tabelas e bases de dados em formato de `DataFrames` `Pandas`. De qualquer modo isso pode ser útil para você em algum caso. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DEet1o7iouWc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0c4a3108-56a2-460f-a20f-b3056570b6ac"
      },
      "source": [
        "note = ['This is a note'] \n",
        "\n",
        "f = open(\"note.txt\", \"w\") \n",
        "for line in note:\n",
        "    f.write(line)\n",
        "f.close()\n",
        "\n",
        "f = open(\"note.txt\", \"r\")\n",
        "for line in f:\n",
        "    print(line)\n",
        "    \n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This is a note\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JKDJ6cQwouWg"
      },
      "source": [
        "Para acesso a arquivos desse tipo via internet (não locais) é necessário empregar a classe `urllib.request` e você, se tiver familiaridade com comando `Linux` ainda pode empregar o comando `!wget` em um notebook `Python` para fazer o download do arquivo e empregá-lo local como fizemos acima.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eQhcsWvHouWj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "347df800-a61c-4c1d-d2e8-ec5958f2eb71"
      },
      "source": [
        "import urllib.request  \n",
        "\n",
        "data = urllib.request.urlopen('http://meusite.mackenzie.br/rogerio/TIC/PlayBallcsv.csv')\n",
        "\n",
        "for line in data:\n",
        "    print(line.decode('utf-8'))\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Day,Outlook,Temperature,Humidity,Wind,Play ball\r\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_MR9xbCr2fR9"
      },
      "source": [
        "Este é um ponto que também, em cursos básicos de programação, ganha bastante atenção. Mas a maior parte dos dados que você irá empregar ao longo desta, e de outras componentes, empregam outras formas de arquivo (como Pandas ou mesmo dados em Bancos de Dados) e a leitura de arquivos sequenciais aqui será mais exceção que a regra aqui. São, assim, suficientes essas operações básicas. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yCSClyJ8ouWs"
      },
      "source": [
        "# Numpy \n",
        "\n",
        "O `NumPy` é um pacote para computação científica em `Python` que dá suporte a arrays e matrizes multidimensionais e faz operações matemáticas de modo eficiente sobre essas estruturas.\n",
        "\n",
        "Na maior parte dos casos empregaremos as funções matemáticas do `NumPy` como operações para manipulação de matrizes e vetores, funções trigonométricas, estatísticas e de randomização. O `Pandas` o, pacote de manipulação de dados que empregamos, é construído sobre o `NumPy` e, assim, manipulações de séries de dados empregarão automaticamente a biblioteca `Numpy`.\n",
        "\n",
        "Não temos necessidade aqui de entender todas as operações de `Numpy` e um pequeno conjunto de operações será suficiente para nossos propósitos aqui. \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J4T0DNJLpW4T"
      },
      "source": [
        "## Criando arrays\n",
        "\n",
        "Os arrays podem ser de uma ou mais dimensões mas, diferentemente das listas, e como matrizes numéricas, todos elementos devem ter o mesmo tamanho e tipo. Eles são indexados iniciando por 0 e seguem as mesmas regras de indexação de listas e strings (o limite superior indicando o limite $<$ do range de valores a ser selecionado). "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3jyv8q38pr0D",
        "outputId": "c89f6487-809f-4a99-d46b-404f3dd7ac36"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "array1D = np.array([1,2,3])\n",
        "array2D = np.array([[1,2,3,4],[11,12,13,14],[21,22,23,24]])\n",
        "\n",
        "print(array1D.ndim, array2D.ndim) # dimensões\n",
        "print(array1D.shape, array2D.shape) # tamanho de cada dimensão\n",
        "print(array1D)\n",
        "print(array2D)\n",
        "print(array1D[1])\n",
        "print(array2D[1:3])\n",
        "print(array2D[1][3])\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 2\n",
            "(3,) (3, 4)\n",
            "[1 2 3]\n",
            "[[ 1  2  3  4]\n",
            " [11 12 13 14]\n",
            " [21 22 23 24]]\n",
            "2\n",
            "[[11 12 13 14]\n",
            " [21 22 23 24]]\n",
            "14\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fiuBJuQ6qssy"
      },
      "source": [
        "Os vetores do `NumPy` operam como listas indexadas e você pode empregar a mesma forma de índices que empregamos para percorrer arrays `NumPy` (incluindo o método `append`)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ktybvoGbreFQ",
        "outputId": "4b0452ab-a401-47c5-85ba-d005744bc440"
      },
      "source": [
        "for i in range(array1D.shape[0]):    \n",
        "    print(i, array1D[i])\n",
        "\n",
        "for i in range(array2D.shape[0]):       # percorre as linhas \n",
        "  for j in range(array2D.shape[1]):     # percorre as colunas      \n",
        "    print(i, j, array2D[i,j])\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1\n",
            "1 2\n",
            "2 3\n",
            "0 0 1\n",
            "0 1 2\n",
            "0 2 3\n",
            "0 3 4\n",
            "1 0 11\n",
            "1 1 12\n",
            "1 2 13\n",
            "1 3 14\n",
            "2 0 21\n",
            "2 1 22\n",
            "2 2 23\n",
            "2 3 24\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J_JDHeums6WB"
      },
      "source": [
        "## Operações sobre arrays `NumPy`\n",
        "\n",
        "Um dos recursos mais úteis do `NumPy` que não encontramos em arrays de outras linguagens como C e Java é que diversas  operações podem ser executadas diretamente sobre o arrays sem a necessidade de implementar iterações ou laços de programa. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "it89cSyVteNT",
        "outputId": "e6ecb37b-d9f2-491d-aab6-1a962fe65ac9"
      },
      "source": [
        "x = np.array([1,2,3])\n",
        "print( np.mean(x), np.sum(x), np.power(x,2) )\n",
        "print( 2*x, x+x, x**2 + 2*x + 1, np.log(x) )"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.0 6 [1 4 9]\n",
            "[2 4 6] [2 4 6] [ 4  9 16] [0.         0.69314718 1.09861229]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E2CWZ8hWtvzB"
      },
      "source": [
        "## Outras Operações Úteis\n",
        "\n",
        "Finalmente, abaixo, algumas operações que serão muito úteis nas seções seguintes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5YLuCzPDouWt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "34228ed4-bc5a-41b9-910c-8be5079bbd3c"
      },
      "source": [
        "x = np.array([1,2,3])\n",
        "\n",
        "x_list = x.tolist()  # convertendo um Numpy array para uma lista Python\n",
        "print(x, x_list)\n",
        "\n",
        "np.random.seed(1984)                                    # semente de geração aleatória \n",
        "print( np.random.randint(low=1, high=6, size=10) )      # gerando inteiros aleatórios\n",
        "print( np.random.rand(4) )                              # gerando valores aleatórios entre [0,1]\n",
        "print( np.random.sample(5) )                            # gerando um sample de dados aleatórios\n",
        "\n",
        "print( np.arange( 10, 20, 2) )     # gerando uma lista de valores no intervalo [10,20[ com incrementos de 2 \n",
        "\n",
        "print( np.linspace( 10, 20, 50) )  # gerando uma lista de valores de 50 valores no intervalo [10,20[\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3] [1, 2, 3]\n",
            "[5 4 2 1 1 3 3 2 3 1]\n",
            "[0.99873856 0.89441845 0.26139183 0.73330439]\n",
            "[0.14629798 0.17234917 0.61481704 0.59564882 0.68232631]\n",
            "[10 12 14 16 18]\n",
            "[10.         10.20408163 10.40816327 10.6122449  10.81632653 11.02040816\n",
            " 11.2244898  11.42857143 11.63265306 11.83673469 12.04081633 12.24489796\n",
            " 12.44897959 12.65306122 12.85714286 13.06122449 13.26530612 13.46938776\n",
            " 13.67346939 13.87755102 14.08163265 14.28571429 14.48979592 14.69387755\n",
            " 14.89795918 15.10204082 15.30612245 15.51020408 15.71428571 15.91836735\n",
            " 16.12244898 16.32653061 16.53061224 16.73469388 16.93877551 17.14285714\n",
            " 17.34693878 17.55102041 17.75510204 17.95918367 18.16326531 18.36734694\n",
            " 18.57142857 18.7755102  18.97959184 19.18367347 19.3877551  19.59183673\n",
            " 19.79591837 20.        ]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gfegaAkT9sqt"
      },
      "source": [
        "# Regras para programar\n",
        "\n",
        "Tendo ou não familiaridade com programação vale a pena lembrar algumas regras e boas práticas que são úteis para você no aprendizado de uma  nova linguagem de programação. \n",
        "\n",
        "1. **Programar não é fácil**, exige esforço e tempo. \n",
        "> Como aprender uma  nova língua você precisa assimilar e praticar os seus conhecimentos \n",
        "1. **Building Blocks**. Programe de modo **incremental** \n",
        "> Para resolver um problema vá construindo a solução aos poucos. Resolva um parte do problema e verifique se os resultados são os esperados. Em seguinda incremente sua solução com outras partes do problema e assim sucessivamente.\n",
        "1. **Small Building Blocks**.`Debug` o seu programa\n",
        "> Guanhou um erro? Não está funcionando? **Leia a mensagem de erro com atenção**. Se não ficou claro o problema volte e você está construindo seu programa de modo incremental, volte um passo na solução e **reconstrua sua solução em etapas ainda menores**. **Inspecione as variáveis** a cada passo fazendo `print` dos valores e verificando se o conteúdo das variáveis é o esperado.\n",
        "1.  **Copy Building Blocks**.Copy $\\rightarrow$ Paste $\\rightarrow$ Adapte\n",
        "> Empregue o Google e a internet ao seu favor. Existem milhares de soluções disponíveis. Empregue também alguma **referência online** de sua preferência. Você pode começar [aqui](https://www.w3schools.com/python/).\n",
        "1. **Reuse Building Blocks**. \n",
        "> Você deve aprender a 'ler' um código mesmo que não seja capaz de 'escrevê-lo'. Isso lhe dará a capacidade de criar inúmeras soluções poderosas mesmo que você não domine completamente a linguagem!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lcn6o4MD8gTp"
      },
      "source": [
        "# Referências de Python e Numpy\n",
        "\n",
        "A documentação do Python traz uma série de recursos para consulta e aprendizado de Python e será uma ferramenta essencial para você.\n",
        "\n",
        "* https://www.python.org/about/gettingstarted/\n",
        "\n",
        "* **Python > About > Getting Started**, Site do Python, com vários links para documentos, livros, video aulas, cursos free\n",
        "https://docs.python.org/3/tutorial/index.html\n",
        "\n",
        "O site do Numpy é,\n",
        "\n",
        "* https://numpy.org/\n",
        "\n",
        "E também traz a documentação das APIs e tutorais do tipo *get started*. \n",
        "\n",
        "Nosso material aqui traz todo o necessário para o desenvolvimento das atividades mas você pode ainda achar útil buscar outras fontes de introdução ao Python. De que forma você prefere aprender?  Há tutoriais para todo tipo de gosto, vídeos, livros, sites iterativos e deixo aqui algumas sugestões para você escolher o que for mais no seu estilo de aprendizado. \n",
        "\n",
        "* https://www.w3schools.com/python/\n",
        "\n",
        "> **Comando a comando, iterativo (você executa os comandos)**, funciona como um help e é fácil de consultar. Se você tem pouco tempo deveria começar por aqui.\n",
        "\n",
        "* https://www.youtube.com/playlist?list=PLBZBJbE_rGRWeh5mIBhD-hhDwSEDxogDg\n",
        "\n",
        "> **Se você prefere vídeos** sobre Python acompanhe esse canal. Os vídeos são separados por assunto. Ex-Google explicando programação para você!\n",
        "\n",
        "* https://www.slitherintopython.com/\n",
        "\n",
        "> **Se você aprende melhor por livros** pode experimentar esse livro texto de Python. Para leitura online ele é Free. Existem ainda vários outros livros .pdf de Python na Internet. Entretanto a publicação na rede não é oficial e, por isso, não divulgo aqui.\n",
        "\n",
        "* https://www.educative.io/courses/learn-python-from-scratch\n",
        "ou ainda \n",
        "* https://panda.ime.usp.br/aulasPython/static/aulasPython/index.html\n",
        "\n",
        "> **Se prefere fazer um curso iterativo**, esses são cursos básicos free. No primeiro é necessário fazer um pequeno cadastro antes de acessar. \n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hlJDeAY3OGTb"
      },
      "source": [
        "# Síntese\n",
        "\n",
        "Nesta trilha você apresentamos o ambiente interativo de Programação Python, o **Google Colab**. Familiarize-se com esse ambiente. Ele é o que iremos utilizar ao longo de toda esta componente, mas fique a vontade de buscar ambientes locais de programação se preferir.\n",
        "\n",
        "Percorremos aqui os principais conceitos que serão mais importante e empregados para programação em Python como variáveis e tipos, atribuições, operações numéricas, entradas e saídas de dados básicas pelo terminal, instruções de controle de fluxo, uso de funções, acesso básico a arquivos e as coleções de dados do Python, listas, sets, tuplas e dicionários. Esses recursos são bastante simples e muito próximo do que empregam outras linguagens e talvez a novidade resida principalmente na identação dos comandos (algo que usuários de outras linguagens pode levar algum tempo para se habituar) e nas estruturas de coleções de dados, em geral mais simples que em outras linguagens. Dessas coleções **listas e dicionários** são particulamente importante para o tratamento de dados e o que veremos a seguir. \n",
        "\n",
        "Um ponto importante de você notar é que empregar Python para Ciência de Dados pode ser diferente de empregar o Python para outros propósitos. Desse modo nosso aprendizado de Python está focado nos recursos que são necessários para exploração de dados, e destacamos isso em alguns pontos ao longo do texto (na manipulação de String e operações de File Handling por exemplo). De fato a linguagem traz muito mais recursos do que vemos aqui, como recursos de classes de Python (sim, o Python é também orientado a objetos), suporte a processamento mutithread, a integração com frameworks web etc. mas que não são necessários para os nossos propósitos. E do mesmo, para o Numpy separamos aqui apenas as principais funcionalidades que faremos uso.\n",
        "\n",
        "Por último, não deixe de explorar os ambientes, as referências e os códigos do texto. Como falamos na seção de *Regras para programar*, programar não é fácil, exige esforço e tempo. Exige uma prática que não pode ser obtida apenas com a leitura do material. Tenha isso em mente e, ao ler o texto, procure excutar e explorar os comandos apresentados pois é desse modo que deve ser feita a leitura de um livro de programação ;-)  \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-Rh3-Vt9Nev9"
      },
      "source": [
        "## Para saber mais\n",
        "\n",
        "Acesse **Choosing Python or R for Data Analysis? An Infographic.** em: https://www.datacamp.com/community/tutorials/r-or-python-for-data-analysis? para uma discussão entre o uso das linguagens Python e R.\n",
        "\n",
        "Assista ao vídeo <a href=\"https://www.youtube.com/watch?v=inN8seMm7UI\">Introdução ao Colab</a> ou simplesmente comece a usá-lo https://colab.research.google.com/. \n",
        "\n",
        "Explore a barra de ferramentas do Colab, a edição de células de texto e código e consulte:\n",
        "\n",
        "- [Visão geral do Colaboratory](/notebooks/basic_features_overview.ipynb)\n",
        "- [Guia sobre Markdown](/notebooks/markdown_guide.ipynb)\n",
        "\n",
        "Acesse um tutorial prático de Python [aqui](https://www.w3schools.com/python/).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h_6fwcVkCsLf"
      },
      "source": [
        "## Referências\n",
        "\n",
        "1. ___. **Choosing Python or R for Data Analysis? An Infographic.** Disponível em: https://www.datacamp.com/community/tutorials/r-or-python-for-data-analysis? Acesso: 17.05.2021.\n",
        "\n",
        "2. McKinney Wes. **Python for data analysis (1st. ed.)**. O'Reilly Media, Inc. (2012). \n",
        "\n",
        "3. Jake VanderPlas. **Python Data Science Handbook**. O'Reilly Media, Inc. (2016). ISBN: 9781491912058. Disponível em: https://jakevdp.github.io/PythonDataScienceHandbook/. Acesso: 17.05.2021.\n",
        "\n",
        "4. ___. **Python.** https://www.python.org/\n",
        "\n",
        "5. ___. **Numpy.** https://numpy.org/\n",
        "\n",
        "6. Mark Lutz. **Learning Python**, 5th Edition (2013) O'Reilly Media, Inc. ISBN: 9781449355739\n",
        "\n",
        "\n"
      ]
    }
  ]
}