Fundamentos_de_Python_para_Data_Science.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Fundamentos de Python para Data Science.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyNHWZHI4S3UGn576FdO3Atj",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ricardorocha86/Fundamentos-de-Python-para-ML/blob/main/Fundamentos_de_Python_para_Data_Science.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9spOcMo4FPNI"
      },
      "source": [
        "# **Fundamentos de Python para Data Science**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "63jz0LpiQDx3"
      },
      "source": [
        "![Capa](https://desenvolvedorsa.com/blog_novo/wp-content/uploads/2019/07/opengraph-icon-200x2001-1.png) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RgKi_rebQYm9"
      },
      "source": [
        "\n",
        "Essa é uma introdução bem rápida aos conceitos fundamentais de programação em Python. Se familiarizar com tais conceitos é um primeiro passo suficiente para fazer seus primeiros programas e também entender outros códigos feitos em Python. No entanto, não se engane, o universe de Python é gigante e existe muita coisa interessante para se conhecer ainda!\n",
        "\n",
        "Após terminar essa introdução, não deixe de se desafiar nos exercícios propostos! São importantíssimos para criar manejo e intimidade com a linguagem. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HoQw4n_SMn9P"
      },
      "source": [
        "## **Conteúdo desse notebook:**\n",
        "\n",
        "1. [Atribuição de Variáveis](#atri)\n",
        "2. [Primeiras Funções](#prim)\n",
        "3. [Operadores Aritméticos](#oper)\n",
        "4. [Comparações e Booleanos](#comp)\n",
        "5. [Condicional IF-ELSE](#cond)\n",
        "6. [Definição de Funções](#defi) \n",
        "6. [Importação de Bibliotecas](#impo) \n",
        "6. [A Biblioteca Numpy](#nump) \n",
        "\n",
        "6. [Listas](#lists) \n",
        "6. [Métodos de Listas](#metl) Iteradores FOR e WHILE\n",
        "6. [Métodos de Strings](#mets) \n",
        "6. [Funções Importantes](#func) \n",
        "6. [Iteradores FOR e WHILE](#iter) \n",
        "6. [Projeto: Álbum de Figurinhas](#proj) \n",
        "\n",
        "7. [Exercícios](#exer) \n",
        "9. [Links Úteis](#links)\n",
        "10. [Anexo: Zen of Python](#anex)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8kMiWTL0pvFF"
      },
      "source": [
        "## **Atribuição de Variáveis** <a name=\"atri\"></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dwHX8egGBuTc",
        "outputId": "ed01ed77-adb5-4142-88ac-dcb29a53e006",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        }
      },
      "source": [
        "meu_nome = 'Ricardo'\n",
        "meu_sobrenome = 'Rocha'\n",
        "meu_produto = \"Caixa d'agua\"\n",
        "minha_frase = '\"Vamos que vamos!\"'\n",
        "\n",
        "print(meu_nome)\n",
        "print(meu_sobrenome)\n",
        "print(meu_produto)\n",
        "print(minha_frase)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ricardo\n",
            "Rocha\n",
            "Caixa d'agua\n",
            "\"Vamos que vamos!\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a_tw5S1Hq0Ep"
      },
      "source": [
        "Não é possível atribuir variáveis com nomes começando com números, nem com espaços no nome ou com aspas. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nWqVaqeBrAb_"
      },
      "source": [
        "OBS.: O **hashtag #** na frente de uma linha torna ela um **comentário**, pois o interpretador ignora tudo que vem depois dela "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "38emYI_xJqeO"
      },
      "source": [
        "## **Primeiras Funções** <a name=\"prim\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7JyT6165pi6l"
      },
      "source": [
        "Conheça a função **len**, que retorna o tamanho de uma string (e de outros tipos de objetos também).\n",
        "\n",
        "A função **type**, que retorna o tipo do objeto na variável de entrada\n",
        "\n",
        "A função **round**, que arredonda um número de acordo com as casas decimas desejadas\n",
        "\n",
        "E a função **help**, que retorna a documentação da função inserida como entrada."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CNTROt8rb4Lg",
        "outputId": "7aedb501-b5ac-4956-ea3d-eb7879efe1d2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "nome = 'Ricardo'\n",
        "len(nome)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 162
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZH4vZ7NtI5Jx"
      },
      "source": [
        "Não só no Python, mas em programação em geral, sempre precisamos controlar o tipo das variáveis que utilizamos. Veja o exemplo abaixo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DvKNUkrPIlDt",
        "outputId": "793aaf4a-23d5-43af-f82a-c37ea1050044",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "minha_idade = '33'\n",
        "type(minha_idade)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 160
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fyCVd6Tov_ao"
      },
      "source": [
        "Usando a função **int** para converter a variável em formato string para o formato inteiro"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "svsiydRLv8vT",
        "outputId": "8acee7fd-17cd-49d3-df49-23ef86642b69",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "\n",
        "minha_idade = int(minha_idade)\n",
        "type(minha_idade)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 159
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PUH_pzLDJa4Q"
      },
      "source": [
        "## **Operadores Aritméticos** <a name=\"oper\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bS7hxv-Codpz"
      },
      "source": [
        "Confira na tabela abaixo como funcionam os operadores aritméticos em Python. \n",
        "\n",
        "Em especial, veja que a sintaxe da exponenciação não é feita através do sinal '^'."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mHsbgk0UGIaL"
      },
      "source": [
        "| Operator     | Name           | Description                                            |\n",
        "|--------------|----------------|--------------------------------------------------------|\n",
        "| ``a + b``    | Adiçao       | Soma entre ``a`` e ``b``                                 |\n",
        "| ``a - b``    | Subtração    | Diferença entre ``a`` e ``b``                          |\n",
        "| ``a * b``    | Multiplicação | Produto entre ``a`` e ``b``                             |\n",
        "| ``a / b``    | Divisão  | Divisão usual entre ``a`` e ``b``                            |\n",
        "| ``a // b``   | Divisão inteira | A divisão entre ``a`` e ``b``, removendo as partes decimais |\n",
        "| ``a % b``    | Resto da divisão        | O resto da divisão inteira de ``a`` por ``b``     |\n",
        "| ``a ** b``   | Exponenciação | ``a`` elevado a ``b``                     |\n",
        "| ``-a``       | Negação       | O negativo de ``a``                                  |"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T9gTYGKo31B4"
      },
      "source": [
        "print(a + b)\n",
        "print(a - b)\n",
        "print(a * b)\n",
        "print(a / b)\n",
        "print(a // b)\n",
        "print(a % b)\n",
        "print(a ** b)\n",
        "print(-a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FLOeFbsZGcx2",
        "outputId": "35dabf11-ce8f-4f7a-c352-aedbddcaa52b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        }
      },
      "source": [
        "print(max(a, b))\n",
        "print(min(a, b))\n",
        "print(abs(-a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.0\n",
            "1\n",
            "-2\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lh6dGL01YdHZ"
      },
      "source": [
        "## **Comparações e Booleanos** <a name=\"comp\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zJGYOSKzn62F"
      },
      "source": [
        "Quando comparamos objetos em Python é como se estivéssemos fazendo uma pergunta a ele. Duas variáveis são iguais? Uma é maior que a outra? \n",
        "\n",
        "E a resposta é um objeto do tipo **booleano**, que é indicado por **True** ou **False**, indicando, respectivamente, se a resposta é verdadeira ou falsa."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h13Wb-T0YoL8",
        "outputId": "8d504728-9ffe-44bc-9943-63d7c18df4fa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "var1 = 35\n",
        "var2 = 36\n",
        "\n",
        "var1 == var2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 136
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W_tNf7CldSvp",
        "outputId": "07c6be9d-fc00-4a02-c9c4-12a68097b444",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 73
        }
      },
      "source": [
        "print(type(33.2) == str)\n",
        "print(type(33.2) == int)\n",
        "print(type(33.2) == float)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8BwQWdHmQCuY",
        "outputId": "119bbfcf-fb20-4d06-802a-ec1dc6e6aba6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "True and True\n",
        "True or False\n",
        "not False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SF6EtbmrZQO3"
      },
      "source": [
        "## **Condicional IF-ELSE** <a name=\"cond\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t9WtbCPDAWkW"
      },
      "source": [
        "Veja abaixo como funciona a estrutura geral de condicionais no Python. \n",
        "\n",
        "Temos a versão IF ELSE, e a versão IF ELIF ELSE.\n",
        "\n",
        "Note que é possível utilizar o ELIF várias vezes se necessário.\n",
        "\n",
        "No espaço de condição, o Python espera um objeto booleano. Se for True, ele executa, se for False, segue adiante. \n",
        "\n",
        "Note também a estrutura de identação do Python. Aqui não usamos (), [] ou {} para estipular o que deve ser executado nas condicionais. Simplesmente colocamos o código que deve ser executado na linha seguinte, mas identado. Em geral, se utiliza o espaço de **1 tab**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kuqS_I9GdobX"
      },
      "source": [
        "# sintaxe IF-ELSE geral\n",
        "if condição:\n",
        "    executa aqui\n",
        "else:\n",
        "    executa aqui\n",
        "\n",
        "# sintaxe IF-ELIF-ELSE geral\n",
        "if condição:\n",
        "    executa aqui\n",
        "elif outra_condição:\n",
        "    executa aqui\n",
        "else:\n",
        "    executa aqui\n",
        "\n",
        "#não executar essa célula!"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X7Fw4opvdznZ",
        "outputId": "83a5d3fb-5898-4627-de2c-56f8f85f723d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "a, b, c = 1, -2 , 0\n",
        "\n",
        "delta = b**2 - 4*a*c\n",
        "\n",
        "if delta > 0:\n",
        "    x1 = (-b + delta**0.5)/(2*a)\n",
        "    x2 = (-b - delta**0.5)/(2*a)\n",
        "    print('As raízes são {} e {}'.format(x1, x2))\n",
        "elif delta == 0:\n",
        "    x = -b/(2*a)\n",
        "    print('A única raíz é {}'.format(x))\n",
        "else:\n",
        "    print('Não há soluções reais para essa equação')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "As raízes são 3.0 e 1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3K7wNqEIembT"
      },
      "source": [
        "## **Definição de Funções** <a name=\"defi\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jEMYVdTLlf5t"
      },
      "source": [
        "Uma função é um recurso para não precisarmos repetir o mesmo código desnecessariamente. Assim como as funções da matemática, sua tarefa é transformar um input, uma entrada, uma coleção de variáveis, em uma saída, um output. \n",
        "\n",
        "No exemplo abaixo, utilizamos como variáveis o tipo de símbolo e o tamanho da linha que queremos fazer. Você entenderá melhor vendo o exemplo:\n",
        "\n",
        "Da mesma maneira que na estrutura de condicionais, o conteúdo de uma função fica nas linhas seguintes sendo indicados pela **indentação** do código"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VQ-INeRi6tTG"
      },
      "source": [
        "def Mensagem(simbolo = '*', tamanho = 51):\n",
        "    print(simbolo*tamanho)\n",
        "    print('Estamos só começando, o melhor ainda estar por vir!')\n",
        "    print(simbolo*tamanho)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YLiKW1mVu3B2",
        "outputId": "a5f2236f-48c0-4e88-d196-c2d8df28772d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        }
      },
      "source": [
        "Mensagem('-', 51)  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "---------------------------------------------------\n",
            "Estamos só começando, o melhor ainda estar por vir!\n",
            "---------------------------------------------------\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s8XyjoLsmZB3"
      },
      "source": [
        "Voltando no exemplo da fórmula de Bhaskara, fica bem conveniente quando colocamos no formato de função, para analisar as saídas de maneira mais prática. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9s_3C-ZrgKPb"
      },
      "source": [
        "def Bhaskara(a, b, c):\n",
        "    # dando uma resposta adequada para quando o valor de a for igual a zero\n",
        "    if a == 0:\n",
        "        print('Quando a = 0 não se aplica Bhaskara')\n",
        "    else:\n",
        "        delta = b**2 - 4*a*c\n",
        "\n",
        "        if delta > 0:\n",
        "            x1 = (-b + delta**0.5)/(2*a)\n",
        "            x2 = (-b - delta**0.5)/(2*a)\n",
        "            print('As raízes são {} e {}'.format(round(x1, 2), round(x2, 2)))\n",
        "        elif delta == 0:\n",
        "            x = -b/(2*a)\n",
        "            print('A única raíz é {}'.format(x))\n",
        "        else:\n",
        "            print('Não há soluções reais para essa equação')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zs9zyfICgddJ",
        "outputId": "17e12e19-8632-4ca0-a6ea-e18897d1f8ef",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "Bhaskara(3, 2, 0.9)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Não há soluções reais para essa equação\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9vmnCWv9mNwX"
      },
      "source": [
        "## **Importação de Bibliotecas** <a name=\"impo\"></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JuvRAAl0mTD8",
        "outputId": "c737cdf9-c6c8-4ece-c97b-37564642cd32",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "from math import pi\n",
        "print(pi)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.141592653589793\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HoE-Zyp5ma7S",
        "outputId": "d274206f-9a38-4e95-96ed-7361ad8ba436",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "import math\n",
        "print(math.pi)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.141592653589793\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tCtUvjfY6Nbw",
        "outputId": "0522ab9f-37f4-4902-85fd-b6a17bc4976f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "import math as m\n",
        "print(m.pi)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.141592653589793\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d4qDl7aWXlnN"
      },
      "source": [
        "## **A Biblioteca Numpy** <a name=\"nump\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wBb8VajVYDEb"
      },
      "source": [
        "Numpy é a biblioteca mais popular do python para se trabalhar com arrays. \n",
        "\n",
        "Arrays são conjuntos de valores, que podem ser n-dimensionais. \n",
        "\n",
        "Geralmente, um número apenas, um ponto, é um array de dimensão 0\n",
        "\n",
        "Uma lista de valores é um array de dimensão 1. \n",
        "\n",
        "Uma matriz de valores é uma array de dimensão 2. \n",
        "\n",
        "Um tensor de valores é um array de dimensão 3. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nvdq1LlPZXKH"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "64NE6_M6ZYxh"
      },
      "source": [
        "a0 = np.array(1)\n",
        "a1 = np.array([1, 2])\n",
        "a2 = np.array([[1, 2], [3, 4]])\n",
        "a3 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0YWoD5e6aVwu",
        "outputId": "93511906-d017-4028-8d90-196e784b2fbd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 258
        }
      },
      "source": [
        "print('Array a0:\\n', a0)\n",
        "print('Array a1:\\n', a1)\n",
        "print('Array a2:\\n', a2)\n",
        "print('Array a3:\\n', a3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Array a0:\n",
            " 1\n",
            "Array a1:\n",
            " [1 2]\n",
            "Array a2:\n",
            " [[1 2]\n",
            " [3 4]]\n",
            "Array a3:\n",
            " [[[1 2]\n",
            "  [3 4]]\n",
            "\n",
            " [[5 6]\n",
            "  [7 8]]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zYn8Dx86Zcpw"
      },
      "source": [
        "Use o atributo ndim para verificar a dimensão dos arrays numpy"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gGQQ1uQBZaLe",
        "outputId": "0231212e-1bed-4d56-be04-bb8a8a89ff44",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 91
        }
      },
      "source": [
        "print('Dimensão de a0:', a0.ndim)\n",
        "print('Dimensão de a1:', a1.ndim)\n",
        "print('Dimensão de a2:', a2.ndim)\n",
        "print('Dimensão de a3:', a3.ndim)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dimensão de a0: 0\n",
            "Dimensão de a1: 1\n",
            "Dimensão de a2: 2\n",
            "Dimensão de a3: 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kXGd2r3ra0X9"
      },
      "source": [
        "Transforme uma lista em um array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "497CDTd9awol"
      },
      "source": [
        "lista = [1, 2, 3, 4]\n",
        "array = np.array(lista)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u6PBFagAa7VP"
      },
      "source": [
        "Arrays são feitos para se trabalhar com álgebra linear. Veja a diferença quando multiplicamos cada elemento por um escalar"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KbhXL49ibF50",
        "outputId": "d50caf94-d885-4d84-a47a-766c9a4d9d35",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "print(2*lista)\n",
        "print(2*array)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 1, 2, 3, 4]\n",
            "[2 4 6 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g7VxSD9DbJYl"
      },
      "source": [
        "Similarmente, podemos realizar as demais operações com arrays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DRPNPtIibP3s",
        "outputId": "2fc14ccd-e3f2-4438-d001-b5a86bc77fcd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 128
        }
      },
      "source": [
        "print(array + array)\n",
        "print(array * 2)\n",
        "print(array / 3)\n",
        "print(array ** 2)\n",
        "print(array // 2)\n",
        "print(array % 2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2 4 6 8]\n",
            "[2 4 6 8]\n",
            "[0.33333333 0.66666667 1.         1.33333333]\n",
            "[ 1  4  9 16]\n",
            "[0 1 1 2]\n",
            "[1 0 1 0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H-eQY_VJ9voY"
      },
      "source": [
        "## **Listas** <a name=\"lists\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bgBgFBTo-8gx"
      },
      "source": [
        "Um objeto do tipo lista é um dos mais importantes do universo Python. Sua versatilidade permite a construção e organização simples de diversas funcionalidades. **Uma lista é definida por conchetes [ ]**. Vejamos alguns exemplos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oxQQgv2j_TGn"
      },
      "source": [
        "minha_lista = [1, 1, 2, 3, 5, 8, 13]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sxt_3Q_h_JuO",
        "outputId": "c89f09ba-e51d-4f3a-9cfc-ed8bb460a313",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "print(minha_lista)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 1, 2, 3, 5, 8, 13]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "twfQLsSOBFUi",
        "outputId": "e50d25e7-ea5e-47e8-e55c-8f5ba83e90ff",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "len(minha_lista)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2s66TOcfAhh5"
      },
      "source": [
        "**Importante**: A indexação no Python, assim como em diversas linguagens de programação, começam com índice 0\n",
        "\n",
        "Isso quer dizer que o primeiro elemento está na entrada 0 da lista, o segundo elemento na entrada 1, e assim por diante.\n",
        "\n",
        "Nós acessamos os elementos de uma lista também utilizando **colchetes**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IFrs9gJt_hoo",
        "outputId": "58bf7836-e73a-4246-cb5b-a943a10b1164",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "minha_lista[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LLz1CsHF_rQx",
        "outputId": "c79c68fc-fd1b-40b9-beba-ff47b276b9f4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "minha_lista[len(minha_lista) - 1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "13"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rCxiEy34_95J"
      },
      "source": [
        "Uma lista permite armazenar todos os tipos de objetos do Python, veja no exemplo abaixo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mPMB_H5-BSHQ",
        "outputId": "f7da50e4-8846-4ab9-a3df-20c73313b983",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista = ['Python', 1996, True, len, [1,2,'Ricardo']]\n",
        "print(lista)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Python', 1996, True, <built-in function len>, [1, 2, 'Ricardo']]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ub4FXtitBZW4",
        "outputId": "623eb9e9-d81d-4ae2-8ea3-3869cac9aae9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista[0] + ' é muito massa' "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Python é muito massa'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6vQfJXe_BckY",
        "outputId": "97d9e804-836a-4ba3-e00c-b24b99edbd22",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista[1] + 1337"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3333"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_p8LnFNoBy_Z",
        "outputId": "c6f681c0-d2c6-4e56-bd37-92e70234d1a9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista[2] and True"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xYbglI3QB49K",
        "outputId": "ce4b9179-6cb4-4fbb-f7c2-8c82656c67bb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista[3](lista)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iYaycgzoB8RQ"
      },
      "source": [
        "Podemos acessar caracteres de listas através de colchetes também. No python, strings são como listas de caracteres:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tc7JYUWuCHbo",
        "outputId": "79f88f58-8338-4873-cbed-99209f1e585d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'Python'[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'P'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_P_pkjYZCHfG",
        "outputId": "b57638e3-2f40-48a1-dd87-a16579e31ca9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "py = 'Python'\n",
        "py[0] + py[5]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Pn'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DK3LkMgqCOrR"
      },
      "source": [
        "E podemos acessar listas dentro de listas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ce3loc-iCwp_",
        "outputId": "6dd17226-c3c2-4962-ca3f-f2f83ccddd29",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista[4]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "01UJ8UcBC2bB",
        "outputId": "71193235-ba48-450d-bc07-a51a3377455d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista[4][2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Ricardo'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aFacnDGgDApB",
        "outputId": "9c56f0a4-22d6-4cd9-959e-f43961306413",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista[4][2][0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'R'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L8PlzPF1Cx-w",
        "outputId": "96036126-5eee-48aa-99fb-07cad14b0d69",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Python'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7jAN0-DFC42g",
        "outputId": "c992f6df-4438-4cb2-b046-0ca0276ed930",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista[0][0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'P'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zMa7ivrxC7EL"
      },
      "source": [
        "Alguns comandos úteis para acessar elementos em listas:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y7EWm9MaDd7R"
      },
      "source": [
        "frase = 'Python é excelente para análise de dados'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0GFA9PY1Dloy",
        "outputId": "e4ec071c-d743-4b13-e47c-0587dfd8acf8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "frase[:6]  #retorna todos os elementos até o indice 6 da lista (o indice 6 (sétimo elemento) não está incluido)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Python'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D5aR7aeGD1gT",
        "outputId": "cd62322d-8733-4cfd-aa28-78a6fb41ccf1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "frase[6:]  #retorna todos os elementos após o indice 6 da lista"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "' é excelente para análise de dados'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cpzQ0wxyESUY"
      },
      "source": [
        "No Python, o padrão é trabalhar com **intervalos semi-abertos [ , )**, como no exemplo abaixo. O índice 9 está incluso na seleção, mas não o 18. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8g1SouLeD5hJ",
        "outputId": "b54e34ec-95da-4bb5-f53a-183614f26f45",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "frase[9:18] # retorna o elemento de indice 9 até o 18, mas não inclui o 18"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'excelente'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 105
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-PPDP_x3Elvp"
      },
      "source": [
        "Para inverter a ordem de uma lista, utilize"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R6Q_Pg2iEl1B",
        "outputId": "1b534e11-ab52-4d4d-f564-3febd93ba90e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "frase[::-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'sodad ed esilána arap etnelecxe é nohtyP'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 110
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BRWDbZLXFBy4"
      },
      "source": [
        "Para tomar elementos de 2 em 2, utilize"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a4VPNkkEFHSY",
        "outputId": "2658caa8-a85b-4940-d364-4cb6800e6e30",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "frase[::2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Pto  xeet aaaáied ao'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 111
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zgfaeacMElyi"
      },
      "source": [
        "Combine os comandos da maneira que lhe for conveniente"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yXNjLt4AEiyo",
        "outputId": "be78d32b-f44f-4811-d27b-72a0872fe5e9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "frase[::-1][::3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'saeelar nee hP'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 113
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gR0E1z2WEZtJ"
      },
      "source": [
        "## **Métodos de Listas** <a name=\"metl\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OAxHMtUlFoXw"
      },
      "source": [
        "**Métodos são como funções que são aplicáveis a um certo tipo de objetos.** Nesse caso, veremos os métodos para os objetos do tipo lista. Métodos são inerentes ao Python pelo contexto de programação orientada a objetos, que veremos com mais detalhes adiante nesse curso"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u8c0s9IBFjxI"
      },
      "source": [
        "lista = ['A', 'B']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bc-jGonLEZx0",
        "outputId": "4a2743c8-68de-4d30-eb41-43499b291c8d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista.append('C')\n",
        "lista\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['A', 'B', 'C']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 145
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1oq_OgH8EDKg",
        "outputId": "3dbb5313-90a2-4317-f971-4e90e2c87169",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista.pop()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'C'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 146
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rUYPbsndag0z",
        "outputId": "7f467a9d-dc25-4b90-916b-8b1794ac3846",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista.count('B')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 150
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QtWTZze6aoQK",
        "outputId": "2c59e9a4-5afb-4f73-8f57-4518333cbbaa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista.index('B')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 151
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IvzSIyD-vQ0t"
      },
      "source": [
        "## **Métodos de Strings** <a name=\"mets\"></a>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mZs_bHKnvqme"
      },
      "source": [
        "nome = 'Ricardo Rocha'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2WnusPh8bHAQ",
        "outputId": "05e2dcc0-0a82-4b2b-f0b9-171a39d62259",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "nome.lower()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'ricardo rocha'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 156
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "clmmVdIrbY8I",
        "outputId": "88477507-ac0e-4a27-cafc-0679d72041ab",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "nome.upper()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'RICARDO ROCHA'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 157
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NOL14vrtba4Y",
        "outputId": "415afb0f-7fe1-4869-f481-24b0bff112fc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "nome.capitalize()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Ricardo rocha'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 158
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_oBa94mobetG",
        "outputId": "ec4a764b-f489-4030-b4ba-ffefe886cea0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "nome.split(' ')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Ricardo', 'Rocha']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 159
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rgc2tLUFwYCs"
      },
      "source": [
        "## **Funções Importantes** <a name=\"func\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Usm30s_ZUPHX"
      },
      "source": [
        "O comando **input** serve para se comunicar com o usuário enquanto se executa um programa. Veja o exemplo abaixo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xiBIg2DvUWCN",
        "outputId": "141f15fe-481b-4f69-bc1f-853dc318ceb4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "x = input('Digite o seu nome: ')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Digite o seu nome: Ricardo\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y8Hlz87UUb1n",
        "outputId": "279a1055-7066-43ad-a474-9b1b7d84a45a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ricardo\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vW4v9HdiUe6B",
        "outputId": "08843126-1de2-4d5c-fd95-407c486129c1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        }
      },
      "source": [
        "y = input('Digite a sua idade: ')\n",
        "print('\\nA idade declarada foi {}'.format(y))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Digite a sua idade: 33\n",
            "\n",
            "A idade declarada foi 33\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hIAv3lqpU1CE"
      },
      "source": [
        "Mas note que os inputs são sempre no format string. Se quisermos usá-lo numericamente, temos que converter as entradas adequadamanente. Em geral usamos a função **int** para inteiros ou **float** para números reais. Você pode usar a função float para números que são inteiros também."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0ZU8B0hwVQoK",
        "outputId": "483b7552-e9ee-47ad-fe82-e3a8df31f26c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        }
      },
      "source": [
        "y = int(input('Digite a sua idade '))\n",
        "\n",
        "print('\\nSe você já fez aniversário esse ano, seu ano de nascimento foi {}.'.format(2020 - y))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Digite a sua idade 33\n",
            "\n",
            "Se você já fez aniversário esse ano, seu ano de nascimento foi 1987.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KJ82dttbW44T"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ZBxaKUswYSg"
      },
      "source": [
        "A função **range** cria um objeto capaz de gerar listas de valores entre dois números. Ela não gera a lista em si, mas um gerador de lista pra quando ela for utilizada. **Ela trabalha com intervalos semi-abertos do tipo [ , )**. Veja os exemplos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f4N5FABWW-6P",
        "outputId": "5432e8ed-36f1-48bb-fbc4-23bacd63b59f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "range(4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(0, 4)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "umj3TALlXBJG"
      },
      "source": [
        "Para listar os valores da função range, utilize o comando **list**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FzLHaZmOXLIm",
        "outputId": "4933f225-dfab-48ed-e2ff-2c7dbb8ba6dd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "list(range(4))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 2, 3]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SK-6cuaIXJbU"
      },
      "source": [
        "Use-a com dois parâmetros para definir o começo e o fim da lista. Note que o primeiro valor é incluido, mas o último não, pois o intervalo dela é semi-aberto"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fbgK2M_CXZSp",
        "outputId": "d08b8e19-0de4-4de4-e580-fbf441da1ff6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "list(range(3, 10))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3, 4, 5, 6, 7, 8, 9]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R5VMnOFlXfBB"
      },
      "source": [
        "Você ainda pode usar um terceiro parâmetro, que é o passo da lista. Ele deve ser inteiro e representa o salto de um número para o outro."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YXI4nmWTXnYP",
        "outputId": "68a0934a-6bd0-44c4-ed23-e8964ff64cc5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "list(range(2, 21, 2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vmqGMlkRX5fA",
        "outputId": "0e3ac1c1-198e-4169-829b-bd6ea4d03d68",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "list(range(10, 101, 10))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kgAeaNFnaz6Z"
      },
      "source": [
        "A função **list** também pode ser utilizada para quebrar uma string em caracteres dentro de uma lista, veja:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EsH_I9yya7vQ",
        "outputId": "5921f70b-b120-419f-9d5e-30c97edd56a9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "list('Python')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['P', 'y', 't', 'h', 'o', 'n']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "810gugS8vlH-"
      },
      "source": [
        "## **Iteradores FOR e WHILE** <a name=\"iter\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nuwTyZqyvrFX"
      },
      "source": [
        "Utilizamos a estrutura de repetição FOR sempre que desejamos repetir um certo pedaço de código, com alterações ou não, por um número pre-determinado de vezes.\n",
        "\n",
        "Veja os exemplos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N9ZLbdPTeYa4"
      },
      "source": [
        "for variante in lista_de_variações:\n",
        "    codigo a ser repetido\n",
        "\n",
        "#esquema geral do FOR, não executar esse bloco"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oMlptGxbel3R",
        "outputId": "fa8bb0df-d383-43a0-ceb6-4cd73068755b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        }
      },
      "source": [
        "for i in ['banana', 'mamão', 'abacate']:\n",
        "    print('Eu gosto de {}'.format(i))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Eu gosto de banana\n",
            "Eu gosto de mamão\n",
            "Eu gosto de abacate\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S9ZcdJy1vrRH",
        "outputId": "faa31159-c022-4e97-d914-e2784c1fb836",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 199
        }
      },
      "source": [
        "for i in range(10):\n",
        "    print(i*'*')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "*\n",
            "**\n",
            "***\n",
            "****\n",
            "*****\n",
            "******\n",
            "*******\n",
            "********\n",
            "*********\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-mhqfzfGfnbS"
      },
      "source": [
        "Problema: Se eu tomar dois números inteiros no intervalo [1, 10], qual a probabilidade aproximada da soma dos números ser maior que 10?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H98ra85ke7bY",
        "outputId": "e70df48b-34c7-4ef9-f6ca-53082c9b7bd0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "from random import randint\n",
        "lista = []\n",
        "replicas = 10000\n",
        "\n",
        "for i in range(replicas):\n",
        "    if randint(1,10) + randint (1,10) > 10:\n",
        "        lista.append(True)\n",
        "    else:\n",
        "        lista.append(False)\n",
        "\n",
        "prob = sum(lista)/replicas\n",
        "\n",
        "print('A probabilidade aproximada é {}%'.format(100*prob))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A probabilidade aproximada é 54.52%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e63f82migunw"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aCsKAKnogvoL"
      },
      "source": [
        "O iterador WHILE usamos quando queremos repetir código sem saber de antemão quando este deve ser interrompido. Ele será finalizado quando alguma condição for satisfeita. \n",
        "\n",
        "Por isso, tome cuidado em não escrever um WHILE infinito. Você terá que cancelar a execução do código para pará-lo.\n",
        "\n",
        "Veja a estrutura geral"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XZq7UqmPhBQ_"
      },
      "source": [
        "while condicao_verdadeira:\n",
        "    codigo repetido\n",
        "    if condicao:\n",
        "        break\n",
        "        \n",
        "#esquema geral do FOR, não executar esse bloco"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PlNNJ5xAhgBG",
        "outputId": "ccb58d55-288a-4533-d169-977770dd1a28",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        }
      },
      "source": [
        "i = 1\n",
        "while i <= 10:\n",
        "    print(i * '*') \n",
        "    i += 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "*\n",
            "**\n",
            "***\n",
            "****\n",
            "*****\n",
            "******\n",
            "*******\n",
            "********\n",
            "*********\n",
            "**********\n",
            "*\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FZwNhK1bidv-"
      },
      "source": [
        "Código equivalente utilizando o comando break para interromper o loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n5sqpDODiNIB",
        "outputId": "c63468b9-6742-40cc-a844-ea7071949fc2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 181
        }
      },
      "source": [
        "i = 1\n",
        "while True:\n",
        "    print(i * '*') \n",
        "    i += 1\n",
        "    if i == 10:\n",
        "        break\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "*\n",
            "**\n",
            "***\n",
            "****\n",
            "*****\n",
            "******\n",
            "*******\n",
            "********\n",
            "*********\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y_vENC2cim9V"
      },
      "source": [
        "Exemplo de um **while** infinito"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8OSTl1SQiqso"
      },
      "source": [
        "while True:\n",
        "    print('Python é legal demais!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZAOdZjiQiyJ8"
      },
      "source": [
        "O **while** também aceita o comando **else** no após o seu fim. Algo para executar após o break acontecer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B9vxNRKOi9zH",
        "outputId": "b515dc9e-8416-4b66-fec4-d946b464e8f2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        }
      },
      "source": [
        "i = 1\n",
        "while i <= 10:\n",
        "    print(i * '*') \n",
        "    i += 1\n",
        "else:\n",
        "    print('*')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "*\n",
            "**\n",
            "***\n",
            "****\n",
            "*****\n",
            "******\n",
            "*******\n",
            "********\n",
            "*********\n",
            "**********\n",
            "*\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PufIjCGaXmAU"
      },
      "source": [
        "## ***Projeto: simulação de um álbum de figurinhas*** <a name=\"proj\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iTybxsEjYEko"
      },
      "source": [
        "### EXEMPLO: **Álbum Premier League 2019-2020**\n",
        "1. Total de cromos: **636**\n",
        "2. Preço do livro ilustrado capa brochura: **R\\$ 8,90**\n",
        "3. Envelope com 5 cromos: **R\\$ 2,50**\n",
        "\n",
        "### SUPOSIÇÕES\n",
        "1. Todas as figurinhas tem igual probabilidade de serem sorteradas\n",
        "2. Um pacotinho é comprado por vez  \n",
        "\n",
        "### ALGORITMO\n",
        "1. Comprar um pacotinho de figurinhas (5 figurinhas cada, que podem ser repetidas);\n",
        "2. Colar no álbum e verificar se o álbum está completo;\n",
        "3. Caso esteja incompleto, comprar mais um pacotinho, caso contrário, terminar.\n",
        "\n",
        "### PERGUNTAS\n",
        "1. Qual o valor médio investido para completar o álbum nessas condições?\n",
        "2. Quantos pacotes são necessários comprar, em média, para completar o álbum?\n",
        "3. Qual é a distribuição empírica do valor investido para completar o álbum?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h2l9BcKaV_eX"
      },
      "source": [
        "n_album = 636\n",
        "preco_pacote = 2.50\n",
        "preco_album = 8.90\n",
        "simulacoes = 1000"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xB0munEeV_n_"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# representação do álbum\n",
        "album = np.zeros(n_album) \n",
        "\n",
        "# representação do pacote de figurinhas\n",
        "pacotinho = np.random.choice(range(n_album), 5)\n",
        "pacotinho\n",
        "\n",
        "# 'colando' as figurinhas obtidas no álbum\n",
        "for i in pacotinho:\n",
        "    album[i] += 1"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jvyn7lBTYEtO",
        "outputId": "eb687ecd-c44c-4653-f0cf-4ea17ca4e9b1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "# comprando figurinhas até completar o álbum\n",
        "def SimulaAlbum():\n",
        "    album = np.zeros(n_album) \n",
        "    pacotes = 0\n",
        "    while not np.all(album > 0):\n",
        "        pacotinho = np.random.choice(range(n_album), 5)\n",
        "        pacotes += 1\n",
        "\n",
        "        for i in pacotinho:\n",
        "            album[i] += 1\n",
        " \n",
        "\n",
        "    valor_gasto = preco_album + preco_pacote * pacotes \n",
        "\n",
        "    return valor_gasto, pacotes\n",
        "\n",
        "SimulaAlbum()"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2703.9, 1078)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q1khZHjQoJhg",
        "outputId": "8a19a98d-6132-432d-e612-2424cab971dc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        }
      },
      "source": [
        "valores = []\n",
        "for i in range(simulacoes):\n",
        "    valores.append(SimulaAlbum()[0])\n",
        "    if (i+1) % 50 == 0:\n",
        "        print('Simulação: ', i+1, '/', simulacoes)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Simulação:  50 / 1000\n",
            "Simulação:  100 / 1000\n",
            "Simulação:  150 / 1000\n",
            "Simulação:  200 / 1000\n",
            "Simulação:  250 / 1000\n",
            "Simulação:  300 / 1000\n",
            "Simulação:  350 / 1000\n",
            "Simulação:  400 / 1000\n",
            "Simulação:  450 / 1000\n",
            "Simulação:  500 / 1000\n",
            "Simulação:  550 / 1000\n",
            "Simulação:  600 / 1000\n",
            "Simulação:  650 / 1000\n",
            "Simulação:  700 / 1000\n",
            "Simulação:  750 / 1000\n",
            "Simulação:  800 / 1000\n",
            "Simulação:  850 / 1000\n",
            "Simulação:  900 / 1000\n",
            "Simulação:  950 / 1000\n",
            "Simulação:  1000 / 1000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PM_3RPS5q_Z9"
      },
      "source": [
        "As respostas das perguntas 1 e 2, respectivamente, são:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aWgOBRkHqoKk",
        "outputId": "75cb6afb-762f-4abf-e88c-051942db3bff",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "print('O valor médio gasto foi:', round(np.mean(valores), 2))\n",
        "print('O numero de pacotes médio foi:', round((np.mean(valores) - preco_album)/preco_pacote, 2))"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "O valor médio gasto foi: 2245.0\n",
            "O numero de pacotes médio foi: 894.44\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eFFhtwKkrF__"
      },
      "source": [
        "Podemos visualizar a distribuição empírica do valor gasto através do **histograma** dos valores simulados"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-jMyRhC-rNim",
        "outputId": "5bc7a3a8-b107-4ff2-c7fb-bcbb674f94c1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        }
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.hist(valores, bins = 20, density = True, edgecolor = 'black')\n",
        "plt.title('Distribuição Empírica do Valor Gasto para Completar o Álbum')\n",
        "plt.show()"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "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": "2rBE-DdbJ3Am"
      },
      "source": [
        "# **Exercícios: Python para Data Science**  <a name=\"exer\"></a>\n",
        "Os exercícios abaixo foram pensados para que iniciantes desenvolvam manejo e intimidade programando em python, utilizando os recursos fundamentais da linguagem.\n",
        "\n",
        "Os dois primeiros exercícios são mais simples. O exercício 3 já é um pouco mais elaborado e pode ser resolvido de várias formas. E o último exercício é apenas um complemento do projeto desenvolvido em aula sobre o álbum de figurinhas. Foram feitas mais perguntas para serem respondidas com o experimento. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r1X1E_zEge7K"
      },
      "source": [
        "## **Exercício 1** \n",
        "Considere um balde cuja base possui raio  $r_1$ e altura igual ao diâmetro da base. Considere também uma esfera de raio $r_2$ cheia de água. Faça um programa que verifique se o volume da esfera cabe no balde, dados os valores de $r_1$ e $r_2$. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZRfHvmZ548aq"
      },
      "source": [
        "\n",
        "## **Exercício 2** \n",
        "Crie uma função que simule o jogo do *jokempô*, isto é, dada a entrada de dois jogadores, retorne a indicação de qual deles venceu. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XW7xW90KucKA"
      },
      "source": [
        "## **Exercício 3**  \n",
        "\n",
        "Faça um programa que simule uma **slot machine**. Uma slot machine é uma máquina muito comum em cassinos. A pessoa puxa uma alavanca e aparecem na tela 3 símbolos aleatoriamente, de uma lista com diversos deles. Se os símbolos forem iguais, então a pessoa ganha. A pessoa entrar com um tanto escolhido de fichas, e joga até que acabe. Quando o programa terminar, uma mensagem resumindo os totais que ela ganhou deve ser exibida."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HsJzoJHmPBDR"
      },
      "source": [
        "## **Exercício 4**\n",
        "\n",
        "Considere o contexto do projeto do álbum de figurinhas e responda as perguntas adicionais: \n",
        "1. Quantas vezes saiu a figurinha mais repetida, em média?\n",
        "2. Em média, quantas figurinhas não se repetem ao completar o álbum?\n",
        "3. Qual a probabilidade de se gastar mais que R\\$3000,00 para completar o álbum?\n",
        "4. Qual a probabilidade de se gastar menos que R\\$1500,00 para completar o álbum?\n",
        "5. Qual a probabilidade de se gastar mais do que a média para completar o álbum?\n",
        "6. Qual é o intervalo de confiança de 95% para o gasto ao se completar o álbum?\n",
        "7. Qual o valor médio gasto caso se esteja completando o álbum com mais um amigo?\n",
        "8. Quanto se economiza ao utilizar o cenário da questão 7?\n",
        "9. Qual o valor médio gasto caso se esteja completando o álbum com mais dois amigos?\n",
        "10. Quanto se economiza ao utilizar o cenário da questão 9?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nSJC-C50lrdi"
      },
      "source": [
        " ## **Links Úteis** <a name=\"links\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qvCE4Gnglshy"
      },
      "source": [
        "1. [Documentação do Python](https://docs.python.org/3/)\n",
        "2. [Download do Anaconda](https://anaconda.org/)\n",
        "3. [Curso do Gustavo Guanabara no YouTube (Canal Curso em Vídeo)](https://www.youtube.com/watch?v=S9uPNppGsGo&list=PLvE-ZAFRgX8hnECDn1v9HNTI71veL3oW0)\n",
        "4. [Curso de Python gratuito do Kaggle (inglês)](https://www.kaggle.com/learn/python)\n",
        "5. [Conceitos de Python em 40min por Derek Banas (inglês)](https://www.youtube.com/watch?v=N4mEzFDjqtA) \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UE-KpVQlpZYZ"
      },
      "source": [
        "## **Anexo** <a name=\"anex\"></a>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Qt56rwNP2rW"
      },
      "source": [
        "\n",
        "### **The Zen of Python, por Tim Peters**\n",
        "\n",
        "É um conjunto de regras pela qual o Python é idealizado.\n",
        "\n",
        "1. Bonito é melhor que feio.\n",
        "2. Explícito é melhor que implícito.\n",
        "3.  Simples é melhor que complexo.\n",
        "4. Complexo é melhor que complicado.\n",
        "5. Plano é melhor que aglomerado.\n",
        "6. Esparso é melhor que denso.\n",
        "7. Legibilidade faz diferença.\n",
        "8. Casos especiais não são especiais o bastante para quebrar as regras.\n",
        "9. Embora a praticidade vença a pureza.\n",
        "10. Erros nunca devem passar silenciosamente.\n",
        "11. A menos que sejam explicitamente silenciados.\n",
        "12. Diante da ambigüidade, recuse a tentação de adivinhar.\n",
        "13. Deve haver um -- e preferencialmente só um -- modo óbvio para fazer algo.\n",
        "14. Embora esse modo possa não ser óbvio à primeira vista a menos que você seja holandês.\n",
        "15. Agora é melhor que nunca.\n",
        "16. Embora nunca freqüentemente seja melhor que *exatamente* agora.\n",
        "17. Se a implementação é difícil de explicar, é uma má idéia.\n",
        "18. Se a implementação é fácil de explicar, pode ser uma boa idéia.\n",
        "19. Namespaces são uma grande idéia -- vamos fazer mais dessas! "
      ]
    }
  ]
}