Python_para_ML_02.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python para ML - 02",
      "provenance": [],
      "authorship_tag": "ABX9TyNYVNm/A5hMStX+CIOklGrt",
      "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/Python-para-Machine-Learning/blob/master/Python_para_ML_02.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6xhb-xXjZQ65",
        "colab_type": "text"
      },
      "source": [
        "![alt text](https://raw.githubusercontent.com/ricardorocha86/Python-para-Machine-Learning/master/Imagens/capa%20-%20python%20para%20ml%2002.jpg)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-LOUIeZLZWo1",
        "colab_type": "text"
      },
      "source": [
        "# **Python para Machine Learning** - Parte 2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iyK5-8ivZccx",
        "colab_type": "text"
      },
      "source": [
        "Nesse notebook veremos:\n",
        "\n",
        "- [Importação de Bibliotecas](#impo)\n",
        "- [Solução do Exercício 1 da aula anterior](#sol1)\n",
        "- [Solução do Exercício 2 da aula anterior](#sol2)\n",
        "- [Operadores Lógicos](#oper)\n",
        "- [Listas](#lists)\n",
        "- [Funções Importantes](#func)\n",
        "- [Métodos de Listas](#metl)\n",
        "- [Métodos de Strings](#mets)\n",
        "- [Iteradores FOR e WHILE](#iter)\n",
        "- [Projeto - Jogo da Roleta](#proj)\n",
        "- [Exercício](#exer)\n",
        "- [Links Úteis](#links)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JmcfioJIOVwS",
        "colab_type": "text"
      },
      "source": [
        "## **Importação de Bibliotecas** <a name=\"impo\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TjviRBTGSkTB",
        "colab_type": "text"
      },
      "source": [
        "Existem várias maneiras de se importar funções de uma biblioteca a parte no python. Abaixo está listada as maneiras mais comuns. \n",
        "\n",
        "Veja que uma biblioteca precisa ser instalada antes de ser importada. No caso, as bibliotecas que usaremos na aula de hoje já estão instaladas no ambiente do Google Colab, por essa razão não é necessária fazer uma instalação prévia. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3CeuJc7NOaHw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "f0ca019b-e2e2-4927-929b-d9295fc5fc60"
      },
      "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": "Of5K4ao1OXSD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "75cf4066-39e2-49ab-a65e-43aad9e984e7"
      },
      "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": "apemaHD9OksT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "68f4b07c-58bc-4e86-cd70-6fe83713141f"
      },
      "source": [
        "import math as m\n",
        "print(m.pi)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.141592653589793\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NSNYFHzrOmZ7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "dae94277-dcab-4f34-872c-20dbffccc4f5"
      },
      "source": [
        "from math import pi as Piii\n",
        "print(Piii)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.141592653589793\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mKOPYeo2Ourn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "outputId": "6ee3e9ec-8136-4c3b-b75f-eead104f09ed"
      },
      "source": [
        "from math import *\n",
        "print(pi)\n",
        "print(sqrt(5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.141592653589793\n",
            "2.23606797749979\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O_bzFMF_xX9M",
        "colab_type": "text"
      },
      "source": [
        " <a name=\"sol1\"></a>**Solução do Exercício 1 da aula anterior** 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$. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nAl_lSsJxbsf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from math import pi\n",
        "\n",
        "def ChecaVolume(raio_balde, raio_esfera):\n",
        "    if raio_balde <=0:\n",
        "        print('Erro: valor do raio do balde inadequado')\n",
        "\n",
        "    elif raio_esfera <=0:\n",
        "        print('Erro: valor do raio da esfera inadequado')\n",
        "\n",
        "    else:\n",
        "        vol_balde = 2*raio_balde**3*pi\n",
        "        vol_esfera = 4/3*pi*raio_esfera**3\n",
        "\n",
        "        if vol_esfera <= vol_balde:\n",
        "            print('O volume da esfera cabe no balde')\n",
        "        else:\n",
        "            print('O volume da esfera não cabe no balde')"
      ],
      "execution_count": 126,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pKf6k2RLzxV-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "ee8a3414-3e78-466c-e656-61e75c1f28cb"
      },
      "source": [
        "ChecaVolume(-1,2)"
      ],
      "execution_count": 127,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Erro: valor do raio do balde inadequado\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FvbqK-JpNXie",
        "colab_type": "text"
      },
      "source": [
        "<a name=\"sol2\"></a>**Solução do Exercício 2 da aula anterior** 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": "code",
      "metadata": {
        "id": "i7VtxLEY0K-3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def Jokenpo(jogador1, jogador2):\n",
        "    if jogador1 == 'pedra':\n",
        "        if jogador2 == 'tesoura':\n",
        "            print('Jogador 1 ganhou')\n",
        "        elif jogador2 == 'papel':\n",
        "            print('Jogador 2 ganhou')\n",
        "        else:\n",
        "            print('Empate!')\n",
        "    \n",
        "    if jogador1 == 'tesoura':\n",
        "        if jogador2 == 'papel':\n",
        "            print('Jogador 1 ganhou')\n",
        "        elif jogador2 == 'pedra':\n",
        "            print('Jogador 2 ganhou')\n",
        "        else:\n",
        "            print('Empate!')\n",
        "    \n",
        "    if jogador1 == 'papel':\n",
        "        if jogador2 == 'pedra':\n",
        "            print('Jogador 1 ganhou')\n",
        "        elif jogador2 == 'tesoura':\n",
        "            print('Jogador 2 ganhou')\n",
        "        else:\n",
        "            print('Empate!')"
      ],
      "execution_count": 128,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NrnHdfr70WWv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "cea349d9-3c25-4358-ff1e-eb3540f108c7"
      },
      "source": [
        "Jokenpo(jogador1 = 'tesoura', jogador2 = 'papel')"
      ],
      "execution_count": 129,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Jogador 1 ganhou\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vdRNZpeu0bBm",
        "colab_type": "text"
      },
      "source": [
        "## **Operadores Lógicos**  <a name=\"oper\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LJ1LH_He3gKc",
        "colab_type": "text"
      },
      "source": [
        "Alguns operadores lógicos importantes:\n",
        "- ``and`` para o conectivo ``e``\n",
        "- ``or`` para o conectivo ``ou``\n",
        "- ``not`` para a negação de algo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "piqaX-vE386o",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "09332419-9a46-47a4-89dd-02be4ba2e5ea"
      },
      "source": [
        "True and True"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HbKhL6qz3_25",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "b5bfaa1b-1bfd-470f-bf10-86ed3931fcf0"
      },
      "source": [
        "True and False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XGJVzhbh4BiK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "4016a9a5-b0bd-4b17-f8e0-0d70d805fcb6"
      },
      "source": [
        "True or True"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oWhbUZYW4DCY",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "16c45f11-dc8a-49d7-a06a-dbec40b2792a"
      },
      "source": [
        "True or False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K9iEzD3W4EdH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "140f4c0b-1d2c-41d2-8ce4-c8d8dd6a7f60"
      },
      "source": [
        "not True"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dct9Vjh04F1w",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "877eb9b8-9a2e-411f-8252-647d43b35d91"
      },
      "source": [
        "any([False, False])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NX6fojF75D1Q",
        "colab_type": "text"
      },
      "source": [
        "Voltando no Exercício 1, podemos reescrever da seguinte maneira:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bZr7aQ5g9o_H",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def ChecaVolume(raio_balde, raio_esfera):\n",
        "    if raio_balde > 0 and raio_esfera > 0: #OBSERVE O CONECTIVO 'AND' NESSA LINHA\n",
        "        \n",
        "        vol_balde = 2*raio_balde**3*pi\n",
        "        vol_esfera = 4/3*pi*raio_esfera**3\n",
        "\n",
        "        if vol_esfera <= vol_balde:\n",
        "            print('O volume da esfera cabe no balde')\n",
        "        else:\n",
        "            print('O volume da esfera não cabe no balde')\n",
        "    else:\n",
        "        print('Valores de entrada inadequados')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H-eQY_VJ9voY",
        "colab_type": "text"
      },
      "source": [
        "## **Listas** <a name=\"lists\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bgBgFBTo-8gx",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "minha_lista = [1, 1, 2, 3, 5, 8, 13]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sxt_3Q_h_JuO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "c89f09ba-e51d-4f3a-9cfc-ed8bb460a313"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "e50d25e7-ea5e-47e8-e55c-8f5ba83e90ff"
      },
      "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",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "58bf7836-e73a-4246-cb5b-a943a10b1164"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "c79c68fc-fd1b-40b9-beba-ff47b276b9f4"
      },
      "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",
        "colab_type": "text"
      },
      "source": [
        "Uma lista permite armazenar todos os tipos de objetos do Python, veja no exemplo abaixo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mPMB_H5-BSHQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "f7da50e4-8846-4ab9-a3df-20c73313b983"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "623eb9e9-d81d-4ae2-8ea3-3869cac9aae9"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "97d9e804-836a-4ba3-e00c-b24b99edbd22"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "c6f681c0-d2c6-4e56-bd37-92e70234d1a9"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "ce4b9179-6cb4-4fbb-f7c2-8c82656c67bb"
      },
      "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",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "79f88f58-8338-4873-cbed-99209f1e585d"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "b57638e3-2f40-48a1-dd87-a16579e31ca9"
      },
      "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",
        "colab_type": "text"
      },
      "source": [
        "E podemos acessar listas dentro de listas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ce3loc-iCwp_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "6dd17226-c3c2-4962-ca3f-f2f83ccddd29"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "71193235-ba48-450d-bc07-a51a3377455d"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "9c56f0a4-22d6-4cd9-959e-f43961306413"
      },
      "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": "U1dMoG4YDNWr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L8PlzPF1Cx-w",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "96036126-5eee-48aa-99fb-07cad14b0d69"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "c992f6df-4438-4cb2-b046-0ca0276ed930"
      },
      "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",
        "colab_type": "text"
      },
      "source": [
        "Alguns comandos úteis para acessar elementos em listas:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y7EWm9MaDd7R",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "frase = 'Python é excelente para análise de dados'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0GFA9PY1Dloy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "e4ec071c-d743-4b13-e47c-0587dfd8acf8"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "cd62322d-8733-4cfd-aa28-78a6fb41ccf1"
      },
      "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",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "b54e34ec-95da-4bb5-f53a-183614f26f45"
      },
      "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",
        "colab_type": "text"
      },
      "source": [
        "Para inverter a ordem de uma lista, utilize"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R6Q_Pg2iEl1B",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "1b534e11-ab52-4d4d-f564-3febd93ba90e"
      },
      "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",
        "colab_type": "text"
      },
      "source": [
        "Para tomar elementos de 2 em 2, utilize"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a4VPNkkEFHSY",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "2658caa8-a85b-4940-d364-4cb6800e6e30"
      },
      "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",
        "colab_type": "text"
      },
      "source": [
        "Combine os comandos da maneira que lhe for conveniente"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yXNjLt4AEiyo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "be78d32b-f44f-4811-d27b-72a0872fe5e9"
      },
      "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": "Rgc2tLUFwYCs",
        "colab_type": "text"
      },
      "source": [
        "## **Funções Importantes** <a name=\"func\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Usm30s_ZUPHX",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "141f15fe-481b-4f69-bc1f-853dc318ceb4"
      },
      "source": [
        "x = input('Digite o seu nome: ')"
      ],
      "execution_count": 131,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Digite o seu nome: Ricardo\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y8Hlz87UUb1n",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "279a1055-7066-43ad-a474-9b1b7d84a45a"
      },
      "source": [
        "print(x)"
      ],
      "execution_count": 132,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ricardo\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vW4v9HdiUe6B",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "08843126-1de2-4d5c-fd95-407c486129c1"
      },
      "source": [
        "y = input('Digite a sua idade: ')\n",
        "print('\\nA idade declarada foi {}'.format(y))"
      ],
      "execution_count": 135,
      "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",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "483b7552-e9ee-47ad-fe82-e3a8df31f26c"
      },
      "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",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ZBxaKUswYSg",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "5432e8ed-36f1-48bb-fbc4-23bacd63b59f"
      },
      "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",
        "colab_type": "text"
      },
      "source": [
        "Para listar os valores da função range, utilize o comando **list**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FzLHaZmOXLIm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "4933f225-dfab-48ed-e2ff-2c7dbb8ba6dd"
      },
      "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",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "d08b8e19-0de4-4de4-e580-fbf441da1ff6"
      },
      "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",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "68a0934a-6bd0-44c4-ed23-e8964ff64cc5"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "0e3ac1c1-198e-4169-829b-bd6ea4d03d68"
      },
      "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",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "5921f70b-b120-419f-9d5e-30c97edd56a9"
      },
      "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": "gR0E1z2WEZtJ",
        "colab_type": "text"
      },
      "source": [
        "## **Métodos de Listas** <a name=\"metl\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OAxHMtUlFoXw",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "lista = ['A', 'B']"
      ],
      "execution_count": 144,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "40Th9p6NGWCH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 172
        },
        "outputId": "b5c6ec50-10cb-4fdf-9fa1-95c4261b3bb6"
      },
      "source": [
        "lista[2] = 'C'   # exemplo de que não funciona"
      ],
      "execution_count": 137,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-137-d1cd8654e241>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlista\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'C'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m: list assignment index out of range"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bc-jGonLEZx0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "4a2743c8-68de-4d30-eb41-43499b291c8d"
      },
      "source": [
        "lista.append('C')\n",
        "lista\n",
        " "
      ],
      "execution_count": 145,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['A', 'B', 'C']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 145
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1oq_OgH8EDKg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "3dbb5313-90a2-4317-f971-4e90e2c87169"
      },
      "source": [
        "lista.pop()"
      ],
      "execution_count": 146,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'C'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 146
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7g6ztmG-Dnhg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "d6e0730f-9975-412b-fa7c-364c3fa05fa9"
      },
      "source": [
        "lista"
      ],
      "execution_count": 147,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['A', 'B']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 147
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rUYPbsndag0z",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "7f467a9d-dc25-4b90-916b-8b1794ac3846"
      },
      "source": [
        "lista.count('B')"
      ],
      "execution_count": 150,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 150
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QtWTZze6aoQK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "2c59e9a4-5afb-4f73-8f57-4518333cbbaa"
      },
      "source": [
        "lista.index('B')"
      ],
      "execution_count": 151,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 151
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P32Re0fKRTmu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "4821df72-0db7-4bcc-952b-608abba499de"
      },
      "source": [
        "lista + lista"
      ],
      "execution_count": 152,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['A', 'B', 'A', 'B']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 152
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3HPfUnQvRbSa",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "335e7390-026b-4350-e68f-d5200345a660"
      },
      "source": [
        "lista * 2"
      ],
      "execution_count": 153,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['A', 'B', 'A', 'B']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 153
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ozt0-U8MRcZg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 172
        },
        "outputId": "f3ca4b96-4162-4308-c7bb-a445e97ab39a"
      },
      "source": [
        "lista + 2  #exemplo do que não funciona"
      ],
      "execution_count": 154,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-154-462b537a8f9e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlista\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: can only concatenate list (not \"int\") to list"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IvzSIyD-vQ0t",
        "colab_type": "text"
      },
      "source": [
        "## **Métodos de Strings** <a name=\"mets\"></a>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mZs_bHKnvqme",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "nome = 'Ricardo Rocha'"
      ],
      "execution_count": 155,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2WnusPh8bHAQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "05e2dcc0-0a82-4b2b-f0b9-171a39d62259"
      },
      "source": [
        "nome.lower()"
      ],
      "execution_count": 156,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'ricardo rocha'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 156
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "clmmVdIrbY8I",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "88477507-ac0e-4a27-cafc-0679d72041ab"
      },
      "source": [
        "nome.upper()"
      ],
      "execution_count": 157,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'RICARDO ROCHA'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 157
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NOL14vrtba4Y",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "415afb0f-7fe1-4869-f481-24b0bff112fc"
      },
      "source": [
        "nome.capitalize()"
      ],
      "execution_count": 158,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Ricardo rocha'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 158
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_oBa94mobetG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "ec4a764b-f489-4030-b4ba-ffefe886cea0"
      },
      "source": [
        "nome.split(' ')"
      ],
      "execution_count": 159,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Ricardo', 'Rocha']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 159
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "810gugS8vlH-",
        "colab_type": "text"
      },
      "source": [
        "## **Iteradores FOR e WHILE** <a name=\"iter\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nuwTyZqyvrFX",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {}
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "fa8bb0df-d383-43a0-ceb6-4cd73068755b"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 199
        },
        "outputId": "faa31159-c022-4e97-d914-e2784c1fb836"
      },
      "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",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "e70df48b-34c7-4ef9-f6ca-53082c9b7bd0"
      },
      "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": 171,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A probabilidade aproximada é 54.52%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e63f82migunw",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aCsKAKnogvoL",
        "colab_type": "text"
      },
      "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_",
        "colab_type": "code",
        "colab": {}
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        },
        "outputId": "ccb58d55-288a-4533-d169-977770dd1a28"
      },
      "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-",
        "colab_type": "text"
      },
      "source": [
        "Código equivalente utilizando o comando break para interromper o loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n5sqpDODiNIB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 181
        },
        "outputId": "c63468b9-6742-40cc-a844-ea7071949fc2"
      },
      "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",
        "colab_type": "text"
      },
      "source": [
        "Exemplo de um **while** infinito"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8OSTl1SQiqso",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "while True:\n",
        "    print('Python é legal demais!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZAOdZjiQiyJ8",
        "colab_type": "text"
      },
      "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",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        },
        "outputId": "b515dc9e-8416-4b66-fec4-d946b464e8f2"
      },
      "source": [
        "i = 1\n",
        "while i <= 10:\n",
        "    print(i * '*') \n",
        "    i += 1\n",
        "else:\n",
        "    print('*')"
      ],
      "execution_count": 163,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "*\n",
            "**\n",
            "***\n",
            "****\n",
            "*****\n",
            "******\n",
            "*******\n",
            "********\n",
            "*********\n",
            "**********\n",
            "*\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5x-9-W9cReKJ",
        "colab_type": "text"
      },
      "source": [
        "## **Projeto** - Jogo da Roleta <a name=\"proj\"></a>\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tCpIlj_djS9S",
        "colab_type": "text"
      },
      "source": [
        "Vamos criar um programa para simular o jogo da roleta. Vamos considerar uma simplificação do jogo, em que uma pessoa aposta em um número e aí se verifica se a roleta sorteou o número que a pessoa apostou. Para fins de ilustração, suponha também que a roleta possui apenas os números de 0 a 10. O programa deve controlar a quantidade de fichas que o usuário tem para jogar."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BLWLVIp-w8P8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from random import randint\n",
        "\n",
        "def Jogo():\n",
        "    n = input('\\nEm qual número da roleta você deseja apostar? ')\n",
        "    if n == 'sair':\n",
        "        return 'sair'\n",
        "    else:        \n",
        "        rol = randint(0, 5)\n",
        "        if int(n) == rol:\n",
        "            print('\\n' + '*' * 12)\n",
        "            print('Você ganhou!')\n",
        "            print('*' * 12)\n",
        "            saldo = 5\n",
        "        else:\n",
        "            print('\\nNão foi dessa vez!')\n",
        "            saldo = -1\n",
        "        return saldo\n"
      ],
      "execution_count": 164,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rWnVfI5IvXTP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def Roleta():\n",
        "\n",
        "    historico = []\n",
        "    print('\\nBem vindos a Roleta!')\n",
        "\n",
        "    fichas = int(input('\\nQuantas fichas você deseja comprar? '))\n",
        "\n",
        "    while fichas > 0:\n",
        "        a = Jogo()\n",
        "\n",
        "        if a == 'sair':\n",
        "            print('\\n***Fim de jogo, seu saldo final é de {} fichas***'.format(fichas))\n",
        "            print(historico)\n",
        "            break\n",
        "        else:\n",
        "            fichas += a\n",
        "            print('\\nSeu saldo de fichas é {}'.format(fichas))\n",
        "            if a == -1:\n",
        "                historico.append('D')\n",
        "            else:\n",
        "                historico.append('V')\n",
        "    else:\n",
        "        print('\\n***Fim de jogo!***')\n",
        "        print(historico)"
      ],
      "execution_count": 165,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sga-xfXxzuhA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 545
        },
        "outputId": "3f89a99a-1e86-4d92-c464-7cc67e47c882"
      },
      "source": [
        "Roleta()"
      ],
      "execution_count": 167,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Bem vindos a Roleta!\n",
            "\n",
            "Quantas fichas você deseja comprar? 5\n",
            "\n",
            "Em qual número da roleta você deseja apostar? 3\n",
            "\n",
            "Não foi dessa vez!\n",
            "\n",
            "Seu saldo de fichas é 4\n",
            "\n",
            "Em qual número da roleta você deseja apostar? 3\n",
            "\n",
            "************\n",
            "Você ganhou!\n",
            "************\n",
            "\n",
            "Seu saldo de fichas é 9\n",
            "\n",
            "Em qual número da roleta você deseja apostar? 3\n",
            "\n",
            "Não foi dessa vez!\n",
            "\n",
            "Seu saldo de fichas é 8\n",
            "\n",
            "Em qual número da roleta você deseja apostar? sair\n",
            "\n",
            "***Fim de jogo, seu saldo final é de 8 fichas***\n",
            "['D', 'V', 'D']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XW7xW90KucKA",
        "colab_type": "text"
      },
      "source": [
        "## **Exercício** <a name=\"exer\"></a>\n",
        "\n",
        "Faça um programa que simule uma **slot machine**.\n",
        "\n",
        "**Parte A:** 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 jogar até que acabe. Quando o programa terminar, uma mensagem resumindo os totais que ela ganhou deve ser exibida.\n",
        "\n",
        "**Parte B:** Estime as probabilidades de acontecer cada tipo de prêmio na slot machine."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5hW8TlDfpUaX",
        "colab_type": "text"
      },
      "source": [
        "## **Links Úteis** <a name=\"links\"></a>\n",
        "\n",
        "- [Documentação sobre os métodos de listas](https://docs.python.org/3/tutorial/datastructures.html)\n",
        "- [Documentação sobre os métodos de strings](https://docs.python.org/3/library/stdtypes.html)\n",
        "- [Documentação da biblioteca random](https://docs.python.org/3/library/random.html)"
      ]
    }
  ]
}