Capítulo 08 - Strings.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.3"
    },
    "colab": {
      "name": "Capítulo 08 - Strings.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IsBWSJo7A7v2"
      },
      "source": [
        "# Capítulo 8: Strings\n",
        "\n",
        "Strings não são como números inteiros, de ponto flutuante ou booleanos. Uma string é uma **sequência**, ou seja, uma coleção ordenada de outros valores. Neste capítulo você verá como acessar os caracteres que compõem uma string e aprenderá alguns métodos que as strings oferecem.\n",
        "\n",
        "## 8.1 - Uma string é uma sequência\n",
        "\n",
        "Uma string é uma sequência de caracteres. Você pode acessar um caractere de cada vez com o operador de colchete:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CUP_HhkaA7v5"
      },
      "source": [
        "fruta = 'banana'\n",
        "letra = fruta[1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6fZ2YbvcA7v6"
      },
      "source": [
        "A segunda instrução seleciona o caractere número `1` de `fruta` e o atribui a `letra`.\n",
        "\n",
        "A expressão entre colchetes chama-se **índice**. O índice aponta qual caractere da sequência você quer (daí o nome).\n",
        "\n",
        "Mas pode ser que você não obtenha o que espera:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a4P5MvgkA7v7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "a8cba3eb-cb88-42d1-9bda-d12427d2bbf5"
      },
      "source": [
        "letra"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'a'"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uUvTlDj3A7v8"
      },
      "source": [
        "Para a maior parte das pessoas, a primeira letra de `'banana'` é `b`, não `a`. Mas para os cientistas da computação, o índice é uma referência do começo da string, e a referência da primeira letra é zero."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dEvuTru8A7v9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "3918b51c-b350-4a83-bd1d-21eb2f7deefc"
      },
      "source": [
        "letra = fruta[0]\n",
        "letra"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'b'"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FrDKNsOlA7v9"
      },
      "source": [
        "Então `b` é a 0ª (“zerésima”) letra de `'banana'`, `a` é a 1ª (primeira) letra e `n` é a 2ª (segunda) letra.\n",
        "\n",
        "Você pode usar uma expressão que contenha variáveis e operadores como índice:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fvappTdjA7v-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "cfb18b55-e5ab-4fb3-d43b-058ec0d2382d"
      },
      "source": [
        "i = 1\n",
        "fruta[i]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'a'"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eP0zBHbxA7v-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "d1f1fb0c-1f3e-4f4d-c542-9369b90ef51b"
      },
      "source": [
        "fruta[i+1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'n'"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S8La-N6aA7v_"
      },
      "source": [
        "Porém, o valor do índice tem que ser um número inteiro. Se não for, é isso que aparece:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-J3q73GNca4V",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 171
        },
        "outputId": "e04cc4ae-08c4-42e0-bbc0-834c21ed75fa"
      },
      "source": [
        "letra = fruta[1.5]"
      ],
      "execution_count": null,
      "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-6-a11f8bbea000>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mletra\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfruta\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1.5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: string indices must be integers"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yu8j9z_wA7wA"
      },
      "source": [
        "## 8.2 - <code>len</code>\n",
        "\n",
        "`len` é uma função integrada que devolve o número de caracteres em uma string:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-f297aadA7wA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "90e7588d-6894-433e-980a-098aa1f7420f"
      },
      "source": [
        "fruta = 'banana'\n",
        "len(fruta)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I7VPIbyFA7wA"
      },
      "source": [
        "Para obter a última letra de uma string, pode parecer uma boa ideia tentar algo assim:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ifiSzNPhA7wB"
      },
      "source": [
        "comprimento = len(fruta)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rOYq2CJ6csmk",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 171
        },
        "outputId": "4f0eb837-7506-4139-c49c-285882f2608a"
      },
      "source": [
        "ultima = fruta[comprimento]"
      ],
      "execution_count": null,
      "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-9-a051bfbdd4a6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0multima\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfruta\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcomprimento\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m: string index out of range"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GZGf99rLA7wB"
      },
      "source": [
        "A razão de haver um `IndexError` aqui é que não há nenhuma letra em `'banana'` com o índice `6`. Como a contagem inicia no zero, as seis letras são numeradas de `0` a `5`. Para obter o último caractere, você deve subtrair `1` de `comprimento`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_ZLHZ1fyA7wC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "fe415984-3507-49be-edc4-ed7989ae1a23"
      },
      "source": [
        "ultima = fruta[comprimento-1]\n",
        "ultima"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'a'"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c8UcfS7WA7wC"
      },
      "source": [
        "Ou você pode usar índices negativos, que contam de trás para a frente a partir do fim da string. A expressão `fruta[-1]` apresenta a última letra, `fruta[-2]` apresenta a segunda letra de trás para a frente, e assim por diante.\n",
        "\n",
        "## 8.3 - Travessia com <i>loop</i> <code>for</code>\n",
        "\n",
        "Muitos cálculos implicam o processamento de um caractere por vez em uma string. Muitas vezes começam no início, selecionam um caractere por vez, fazem algo e continuam até o fim. Este modelo do processamento chama-se **travessia**. Um modo de escrever uma travessia é com o _loop_ `while`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "myYvFTHrA7wC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e6651071-54cd-48cd-cae8-ed2b020c676e"
      },
      "source": [
        "indice = 0\n",
        "while indice < len(fruta):\n",
        "    letra = fruta[indice]\n",
        "    print(letra)\n",
        "    indice = indice + 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b\n",
            "a\n",
            "n\n",
            "a\n",
            "n\n",
            "a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lkW6UuZSA7wD"
      },
      "source": [
        "Este _loop_ atravessa a string e exibe cada letra sozinha em uma linha. A condição do _loop_ é `indice < len (fruta)`, então quando `indice` é igual ao comprimento da string, a condição é falsa e o corpo do _loop_ não é mais executado. O último caractere acessado é aquele com o índice `len (fruta)-1`, que é o último caractere na string.\n",
        "\n",
        "Como exercício, escreva uma função que receba uma string como argumento e exiba as letras de trás para a frente, uma por linha.\n",
        "\n",
        "Outra forma de escrever uma travessia é com um _loop_ `for`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cM5njaxuA7wD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c7f47ca3-c7f0-4484-ae6e-55db6dc825f7"
      },
      "source": [
        "for letra in fruta:\n",
        "    print(letra)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b\n",
            "a\n",
            "n\n",
            "a\n",
            "n\n",
            "a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EbPmW_VMA7wD"
      },
      "source": [
        "Cada vez que o programa passar pelo _loop_, o caractere seguinte na string é atribuído à variável `letra`. O _loop_ continua até que não sobre nenhum caractere.\n",
        "\n",
        "O próximo exemplo mostra como usar a concatenação (adição de strings) e um _loop_ `for` para gerar uma série abecedária (isto é, em ordem alfabética). No livro de Robert McCloskey, \"_Make Way for Ducklings_\" (Abram caminho para os patinhos), os nomes dos patinhos são Jack, Kack, Lack, Mack, Nack, Ouack, Pack e Quack. Este _loop_ produz estes nomes em ordem:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ZiMXr1FA7wE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b581f416-fe50-4319-e2f6-25b35fca00e0"
      },
      "source": [
        "prefixos = 'JKLMNOPQ'\n",
        "sufixo = 'ack'\n",
        "for letra in prefixos:\n",
        "    print(letra + sufixo)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Jack\n",
            "Kack\n",
            "Lack\n",
            "Mack\n",
            "Nack\n",
            "Oack\n",
            "Pack\n",
            "Qack\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8VpBCaJWA7wE"
      },
      "source": [
        "A saída é:"
      ]
    },
    {
      "cell_type": "raw",
      "metadata": {
        "id": "r5kyBNy9A7wE"
      },
      "source": [
        "```\n",
        "Jack\n",
        "Kack\n",
        "Lack\n",
        "Mack\n",
        "Nack\n",
        "Oack\n",
        "Pack\n",
        "Qack\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JDYoktuUA7wE"
      },
      "source": [
        "Claro que não está exatamente certo porque “Ouack” e “Quack” foram mal soletrados. Como exercício, altere o programa para corrigir este erro.\n",
        "\n",
        "## 8.4 - Fatiamento de strings\n",
        "\n",
        "Um segmento de uma string é chamado de **fatia**. Selecionar uma fatia é como selecionar um caractere:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J_2Xubg4A7wE",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "9534c1f5-c58d-42ee-9851-56a4688aec29"
      },
      "source": [
        "s = 'Monty Python'\n",
        "s[0:5]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Monty'"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iI5QHC7MA7wF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "a42105f9-31a0-45e1-ddc1-a20038667dec"
      },
      "source": [
        "s[6:12]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Python'"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RED9igaqA7wF"
      },
      "source": [
        "O operador `[n:m]` retorna a parte da string do “enésimo” caractere ao “emésimo” caractere, incluindo o primeiro, mas excluindo o último. Este comportamento é contraintuitivo, porém pode ajudar a imaginar os índices que indicam a parte *entre* os caracteres, como na Figura 8.1.\n",
        "\n",
        "![Figura 8.1 – Índices de fatias.](https://github.com/PenseAllen/PensePython2e/raw/master/fig/tnkp_0801.png)\n",
        "<br>_Figura 8.1 – Índices de fatias._\n",
        "\n",
        "Se você omitir o primeiro índice (antes dos dois pontos), a fatia começa no início da string. Se omitir o segundo índice, a fatia vai ao fim da string:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fvO4CllIA7wF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "b806e1e2-d0ae-4264-d81c-69618712050e"
      },
      "source": [
        "fruta = 'banana'\n",
        "fruta[:3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'ban'"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PxMBSwpvA7wF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "91f2c0eb-e258-426a-8c95-cb842e6289fb"
      },
      "source": [
        "fruta[3:]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'ana'"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SYSmzyw7A7wG"
      },
      "source": [
        "Se o primeiro índice for maior ou igual ao segundo, o resultado é uma **string vazia**, representada por duas aspas:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HVJkDW98A7wG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "befbcf45-1910-43dd-c90a-d59889acd9be"
      },
      "source": [
        "fruta = 'banana'\n",
        "fruta[3:3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "''"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n4MmkM56A7wG"
      },
      "source": [
        "Uma string vazia não contém nenhum caractere e tem o comprimento 0, fora isso, é igual a qualquer outra string.\n",
        "\n",
        "Continuando este exemplo, o que você acha que `fruta[:]` significa? Teste e veja."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z0l2e3JoA7wG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "9fc2a59e-95ee-4dd6-9bcd-9a58046664a1"
      },
      "source": [
        "fruta[:]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'banana'"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XrC0hL2lA7wG"
      },
      "source": [
        "## 8.5 - Strings são imutáveis\n",
        "\n",
        "É tentador usar o operador `[]` no lado esquerdo de uma atribuição, com a intenção de alterar um caractere em uma string. Por exemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fwqSA4XcA7wG"
      },
      "source": [
        "cumprimento = 'Hello, world!'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vh6r0G--d3W8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 171
        },
        "outputId": "bacec17e-03ed-4902-9c6b-6cbf73cea114"
      },
      "source": [
        "cumprimento[0] = 'J'"
      ],
      "execution_count": null,
      "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-22-875587a1e501>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcumprimento\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'J'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q2yrWOZWA7wH"
      },
      "source": [
        "O “objeto” neste caso é a string e o “item” é o caractere que você tentou atribuir. Por enquanto, um objeto é a mesma coisa que um valor, mas refinaremos esta definição mais adiante (Objetos e valores, no capítulo 10).\n",
        "\n",
        "A razão do erro é que as strings são **imutáveis**, o que significa que você não pode alterar uma string existente. O melhor que você pode fazer é criar uma string que seja uma variação da original:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I9UGchCfA7wH",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "63140b77-66af-403b-84b1-b0083d9dc3a7"
      },
      "source": [
        "novo_cumprimento = 'J' + cumprimento[1:]\n",
        "novo_cumprimento"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Jello, world!'"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5i6yr0PjA7wH"
      },
      "source": [
        "Esse exemplo concatena uma nova primeira letra a uma fatia de `cumprimento`. Não tem efeito sobre a string original.\n",
        "\n",
        "## 8.6 - Buscando"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P4gw0CFuA7wH"
      },
      "source": [
        "O que faz a seguinte função?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xGLIlRjMA7wH"
      },
      "source": [
        "def encontra(palavra, letra):\n",
        "    indice = 0\n",
        "    while indice < len(palavra):\n",
        "        if palavra[indice] == letra:\n",
        "            return indice\n",
        "        indice = indice + 1\n",
        "    return -1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gb0pcB26A7wI"
      },
      "source": [
        "De certo modo, `encontra` é o inverso do operador `[]`. Em vez de tomar um índice e extrair o caractere correspondente, ele toma um caractere e encontra o índice onde aquele caractere aparece. Se o caractere não for encontrado, a função retorna -1.\n",
        "\n",
        "Esse é o primeiro exemplo que vimos de uma instrução `return` dentro de um _loop_. Se `palavra[indice] == letra`, a função sai do loop e retorna imediatamente.\n",
        "\n",
        "Se o caractere não aparecer na string, o programa sai do _loop_ normalmente e devolve `-1`.\n",
        "\n",
        "Este modelo de cálculo – atravessar uma sequência e retornar quando encontramos o que estamos procurando – chama-se **busca**.\n",
        "\n",
        "Como exercício, altere `encontra` para que tenha um terceiro parâmetro: o índice em `palavra` onde deve começar a busca.\n",
        "\n",
        "## 8.7 - <i>Loop</i> e contagem\n",
        "\n",
        "O seguinte programa conta o número de vezes que a letra `a` aparece em uma string:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EbOVDmufA7wI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "820158ec-274f-410e-e7b9-b35ab7a3846a"
      },
      "source": [
        "palavra = 'banana'\n",
        "contador = 0\n",
        "for letra in palavra:\n",
        "    if letra == 'a':\n",
        "        contador = contador + 1\n",
        "print(contador)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dU1CxAJnA7wI"
      },
      "source": [
        "Este programa demonstra outro padrão de computação chamado **contador**. A variável `contador` é inicializada com `0` e então incrementada cada vez que um a é encontrado. Ao sair do loop, `contador` contém o resultado – o número total de letras `'a'`.\n",
        "\n",
        "Como exercício, encapsule este código em uma função denominada `contador` e generalize-o para que aceite a string e a letra como argumentos.\n",
        "\n",
        "Então reescreva a função para que, em vez de atravessar a string, ela use a versão de três parâmetros do `encontra` da seção anterior.\n",
        "\n",
        "## 8.8 - Métodos de strings\n",
        "\n",
        "As strings oferecem métodos que executam várias operações úteis. Um método é semelhante a uma função – toma argumentos e devolve um valor –, mas a sintaxe é diferente. Por exemplo, o método `upper` recebe uma string e devolve uma nova string com todas as letras maiúsculas.\n",
        "\n",
        "Em vez da sintaxe de função `upper(palavra)`, ela usa a sintaxe de método `palavra.upper()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-ZjtjF_LA7wI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "2d3aebbd-317d-4ec9-a456-62030d40f267"
      },
      "source": [
        "palavra = 'banana'\n",
        "nova_palavra = palavra.upper()\n",
        "nova_palavra"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'BANANA'"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b-4MSYxrA7wI"
      },
      "source": [
        "Esta forma de notação de ponto especifica o nome do método, `upper` e o nome da string, `palavra`, à qual o método será aplicado. Os parênteses vazios indicam que este método não toma nenhum argumento.\n",
        "\n",
        "Uma chamada de método denomina-se **invocação**; neste caso, diríamos que estamos invocando `upper` em `palavra`.\n",
        "\n",
        "E, na verdade, há um método de string denominado `find`, que é notavelmente semelhante à função que escrevemos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Er0DiECEA7wI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "90cff664-1d3d-4752-f39a-6d2cd876c42b"
      },
      "source": [
        "palavra = 'banana'\n",
        "indice = palavra.find('a')\n",
        "indice"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9AXpUfKjA7wJ"
      },
      "source": [
        "Neste exemplo, invocamos `find` em `palavra` e passamos a letra que estamos procurando como um parâmetro.\n",
        "\n",
        "Na verdade, o método `find` é mais geral que a nossa função; ele pode encontrar substrings, não apenas caracteres:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aZyzj9HEA7wJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d3135d16-e8a2-412b-8014-473304f7c413"
      },
      "source": [
        "palavra.find('na')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NtfTvtMrA7wJ"
      },
      "source": [
        "Por padrão, `find` inicia no começo da string, mas pode receber um segundo argumento, o índice onde deve começar:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3kgW8KI1A7wJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "310df11b-9bc5-470e-dfdb-bb1ca1162c33"
      },
      "source": [
        "palavra.find('na', 3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bPD7L6LvA7wJ"
      },
      "source": [
        "Este é um exemplo de um **argumento opcional**. `find` também pode receber um terceiro argumento, o índice para onde deve parar:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ys5wbDxyA7wJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9f90f8fe-8607-42f1-9b82-ab8325887c89"
      },
      "source": [
        "nome = 'bob'\n",
        "nome.find('b', 1, 2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-1"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hLzf3EbZA7wK"
      },
      "source": [
        "Esta busca falha porque `'b'` não aparece no intervalo do índice de 1 a 2, não incluindo 2. Fazer buscas até (mas não incluindo) o segundo índice torna `find` similar ao operador de fatiamento.\n",
        "\n",
        "## 8.9 - Operador <code>in</code>\n",
        "\n",
        "A palavra `in` é um operador booleano que recebe duas strings e retorna `True` se a primeira aparecer como uma substring da segunda:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DhC12axZA7wK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8140abf9-0fac-4de0-a08d-03e677bed5e9"
      },
      "source": [
        "'a' in 'banana'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lPJAJZWIA7wK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bb2a14a5-ea48-4cb9-a8ac-66f90aab2107"
      },
      "source": [
        "'semente' in 'banana'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6Lz4Jvf5A7wK"
      },
      "source": [
        "Por exemplo, a seguinte função imprime todas as letras de `palavra1` que também aparecem em `palavra2`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7gIC4BH8A7wK"
      },
      "source": [
        "def em_ambos(palavra1, palavra2):\n",
        "    for letra in palavra1:\n",
        "        if letra in palavra2:\n",
        "            print(letra)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X9PZrGdSA7wK"
      },
      "source": [
        "Com nomes de variáveis bem escolhidos, o Python às vezes pode ser lido como um texto em inglês. Você pode ler este _loop_, “para (cada) letra em (a primeira) palavra, se (a) letra (aparecer) em (a segunda) palavra, exiba (a) letra”.\n",
        "\n",
        "Veja o que é apresentado ao se comparar maçãs e laranjas:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B6Sp-nEJA7wK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "04095fc1-2754-4c40-a9b1-8bb509b56ef6"
      },
      "source": [
        "em_ambos('apples', 'oranges')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a\n",
            "e\n",
            "s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WAzWKmi2A7wL"
      },
      "source": [
        "## 8.10 - Comparação de strings\n",
        "\n",
        "Os operadores relacionais funcionam em strings. Para ver se duas strings são iguais:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8LgIeD49A7wL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "15672d8e-9376-480f-a894-9df0c69a04ea"
      },
      "source": [
        "if palavra == 'banana':\n",
        "    print('All right, bananas.')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "All right, bananas.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zWKmMQSLA7wL"
      },
      "source": [
        "Outras operações relacionais são úteis para colocar palavras em ordem alfabética:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-n0uo_l6A7wL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8abae877-3808-4a26-fb84-3caccd468168"
      },
      "source": [
        "if palavra < 'banana':\n",
        "    print('Sua palavra, ' + palavra + ', vem antes de banana.')\n",
        "elif palavra > 'banana':\n",
        "    print('Sua palavra, ' + palavra + ', vem depois de banana.')\n",
        "else:\n",
        "    print('All right, bananas.')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "All right, bananas.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9jlTxtczA7wL"
      },
      "source": [
        "O Python não lida com letras maiúsculas e minúsculas do mesmo jeito que as pessoas. Todas as letras maiúsculas vêm antes de todas as letras minúsculas, portanto:"
      ]
    },
    {
      "cell_type": "raw",
      "metadata": {
        "id": "5OvE0kz1A7wL"
      },
      "source": [
        "```python\n",
        "Your word, Pineapple, comes before banana.\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FUp_V-BlA7wM"
      },
      "source": [
        "Uma forma comum de lidar com este problema é converter strings em um formato padrão, como letras minúsculas, antes de executar a comparação. Lembre-se disso caso tenha que se defender de um [homem armado com um abacaxi](https://www.youtube.com/watch?v=jfIkMXw_YM4).\n",
        "\n",
        "## 8.11 - Depuração\n",
        "\n",
        "Ao usar índices para atravessar os valores em uma sequência, é complicado acertar o começo e o fim da travessia. Aqui está uma função que supostamente compara duas palavras e retorna `True` se uma das palavras for o reverso da outra, mas contém dois erros:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yMjiNsGHiEer"
      },
      "source": [
        "def eh_espelhado(palavra1, palavra2):\n",
        "    if len(palavra1) != len(palavra2):\n",
        "        return False\n",
        "    i = 0\n",
        "    j = len(palavra2)\n",
        "    while j > 0:\n",
        "        if palavra1[i] != palavra2[j]:\n",
        "            return False\n",
        "        i = i+1\n",
        "        j = j-1\n",
        "    return True"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "txqsiqSTA7wM"
      },
      "source": [
        "A primeira instrução `if` verifica se as palavras têm o mesmo comprimento. Se não for o caso, podemos retornar `False` imediatamente. Do contrário, para o resto da função, podemos supor que as palavras tenham o mesmo comprimento. Este é um exemplo do modelo guardião em “Verificação de tipos”, no Capítulo 6.\n",
        "\n",
        "`i` e `j` são índices: `i` atravessa `palavra1` para a frente, enquanto `j` atravessa `palavra2` para trás. Se encontrarmos duas letras que não combinam, podemos retornar `False` imediatamente. Se terminarmos o _loop_ inteiro e todas as letras corresponderem, retornamos `True`.\n",
        "\n",
        "Se testarmos esta função com as palavras `“pots”` e `“stop”`, esperamos o valor de retorno `True`, mas recebemos um `IndexError`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "23rqQZ_hiLAJ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        },
        "outputId": "ba2caeb7-e8fe-4e43-a8fe-8fd52dadb1a7"
      },
      "source": [
        "eh_espelhado('pots','stop')"
      ],
      "execution_count": null,
      "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-45-f68437e462c3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0meh_espelhado\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'pots'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'stop'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-44-caee3cfb5845>\u001b[0m in \u001b[0;36meh_espelhado\u001b[0;34m(palavra1, palavra2)\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpalavra2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32mwhile\u001b[0m \u001b[0mj\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m         \u001b[0;32mif\u001b[0m \u001b[0mpalavra1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mpalavra2\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m         \u001b[0mi\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mIndexError\u001b[0m: string index out of range"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XEwWv_SnA7wM"
      },
      "source": [
        "Para depurar este tipo de erro, minha primeira ação é exibir os valores dos índices imediatamente antes da linha onde o erro aparece."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ezzt2Qhzi5cS"
      },
      "source": [
        "def eh_espelhado(palavra1, palavra2):\n",
        "    if len(palavra1) != len(palavra2):\n",
        "        return False\n",
        "    i = 0\n",
        "    j = len(palavra2)\n",
        "    while j > 0:\n",
        "        print(i, j)        # exibir aqui\n",
        "        if palavra1[i] != palavra2[j]:\n",
        "            return False\n",
        "        i = i+1\n",
        "        j = j-1\n",
        "    return True"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ZIrgtXgA7wN"
      },
      "source": [
        "Agora quando executo o programa novamente, recebo mais informação:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BRLTnrmSjCfD",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 317
        },
        "outputId": "2a7e141a-5f2c-4d7c-9882-20fd62c9cac1"
      },
      "source": [
        "eh_espelhado('pots','stop')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 4\n"
          ]
        },
        {
          "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-47-f68437e462c3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0meh_espelhado\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'pots'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'stop'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-46-eafb2fb39669>\u001b[0m in \u001b[0;36meh_espelhado\u001b[0;34m(palavra1, palavra2)\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32mwhile\u001b[0m \u001b[0mj\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mj\u001b[0m\u001b[0;34m)\u001b[0m        \u001b[0;31m# exibir aqui\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         \u001b[0;32mif\u001b[0m \u001b[0mpalavra1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mpalavra2\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m         \u001b[0mi\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mIndexError\u001b[0m: string index out of range"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1nzuP466A7wN"
      },
      "source": [
        "Na primeira vez que o programa passar pelo _loop_ , o valor de `j` é `4`, que está fora do intervalo da string `'pots'`. O índice do último caractere é `3`, então o valor inicial de `j` deve ser `len(palavra2)-1`.\n",
        "\n",
        "Se corrigir esse erro e executar o programa novamente, recebo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZqIUWZGEjQ_Q"
      },
      "source": [
        "def eh_espelhado(palavra1, palavra2):\n",
        "    if len(palavra1) != len(palavra2):\n",
        "        return False\n",
        "    i = 0\n",
        "    j = len(palavra2)-1\n",
        "    while j > 0:\n",
        "        print(i, j)        # exibir aqui\n",
        "        if palavra1[i] != palavra2[j]:\n",
        "            return False\n",
        "        i = i+1\n",
        "        j = j-1\n",
        "    return True"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yD5b6tEuA7wN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2a450688-f016-41ce-a7eb-d48455147efc"
      },
      "source": [
        "eh_espelhado('pots','stop')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 3\n",
            "1 2\n",
            "2 1\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OTW8cLPaA7wN"
      },
      "source": [
        "Desta vez, recebemos a resposta certa, mas parece que o _loop_ só foi executado três vezes, o que é suspeito. Para ter uma ideia melhor do que está acontecendo, é útil desenhar um diagrama de estado. Durante a primeira iteração, o frame de `eh_espelhado` é mostrado na Figura 8.2.\n",
        "\n",
        "![Figura 8.2 – Diagrama de estado de eh_espelhado.](https://github.com/PenseAllen/PensePython2e/raw/master/fig/tnkp_0802.png)\n",
        "<br>_8.2 – Diagrama de estado de is&#95;reverse._\n",
        "\n",
        "Tomei a liberdade de arrumar as variáveis no _frame_ e acrescentei linhas pontilhadas para mostrar que os valores de `i` e `j` indicam caracteres em `palavra1` (\"word1\") e `palavra2` (\"word2\").\n",
        "\n",
        "Começando com este diagrama, execute o programa em papel, alterando os valores de `i` e `j` durante cada iteração. Encontre e corrija o segundo erro desta função.\n",
        "\n",
        "## 8.12 - Glossário\n",
        "\n",
        "**objeto** <br>\n",
        "&emsp;Algo a que uma variável pode se referir. Por enquanto, você pode usar “objeto” e “valor” de forma intercambiável.\n",
        "\n",
        "**sequência** <br>\n",
        "&emsp;Uma coleção ordenada de valores onde cada valor é identificado por um índice de número inteiro.\n",
        "\n",
        "**item** <br>\n",
        "&emsp;Um dos valores em uma sequência.\n",
        "\n",
        "**índice** <br>\n",
        "&emsp;Um valor inteiro usado para selecionar um item em uma sequência, como um caractere em uma string. No Python, os índices começam em 0.\n",
        "\n",
        "**fatia** <br>\n",
        "&emsp;Parte de uma string especificada por um intervalo de índices.\n",
        "\n",
        "**string vazia** <br>\n",
        "&emsp;Uma string sem caracteres e de comprimento 0, representada por duas aspas.\n",
        "\n",
        "**imutável** <br>\n",
        "&emsp;A propriedade de uma sequência cujos itens não podem ser alterados.\n",
        "\n",
        "**atravessar** <br>\n",
        "&emsp;Repetir os itens em uma sequência, executando uma operação semelhante em cada um.\n",
        "\n",
        "**busca** <br>\n",
        "&emsp;Um modelo de travessia que é interrompido quando encontra o que está procurando.\n",
        "\n",
        "**contador** <br>\n",
        "&emsp;Uma variável usada para contar algo, normalmente inicializada com zero e então incrementada.\n",
        "\n",
        "**invocação** <br>\n",
        "&emsp;Uma instrução que chama um método.\n",
        "\n",
        "**argumento opcional** <br>\n",
        "&emsp;Um argumento de função ou método que não é necessário.\n",
        "\n",
        "\n",
        "## 8.13 - Exercícios\n",
        "\n",
        "### Exercício 8.1\n",
        "\n",
        "Leia a documentação dos métodos de strings em http://docs.python.org/3/library/stdtypes.html#string-methods. Pode ser uma boa ideia experimentar alguns deles para entender como funcionam. `strip` e `replace` são especialmente úteis.\n",
        "\n",
        "A documentação usa uma sintaxe que pode ser confusa. Por exemplo, em `find(sub[, start[, end]])`, os colchetes indicam argumentos opcionais. Então `sub` é exigido, mas `start` é opcional, e se você incluir `start`, então `end` é opcional.\n",
        "\n",
        "### Exercício 8.2\n",
        "\n",
        "Há um método de string chamado `count`, que é semelhante à função em “_Loop_ e contagem”, no item 8.7. Leia a documentação deste método e escreva uma invocação que conte o número de letras `'a'` em 'banana'.\n",
        "\n",
        "### Exercício 8.3\n",
        "\n",
        "Uma fatia de string pode receber um terceiro índice que especifique o “tamanho do passo”; isto é, o número de espaços entre caracteres sucessivos. Um tamanho de passo 2 significa tomar um caractere e outro não; 3 significa tomar um e dois não etc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NXwueSunA7wN",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "026cebff-af35-42cf-9efe-4fd78ccd3eec"
      },
      "source": [
        "fruta = 'banana'\n",
        "fruta[0:5:2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'bnn'"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "78xaFus5A7wO"
      },
      "source": [
        "Um tamanho de passo -1 atravessa a palavra de trás para a frente, então a fatia `[::-1]` gera uma string invertida.\n",
        "\n",
        "Use isso para escrever uma versão de uma linha de `eh_palindromo` do Exercício 6.3.\n",
        "\n",
        "### Exercício 8.4\n",
        "\n",
        "As seguintes funções pretendem verificar se uma string contém alguma letra minúscula, mas algumas delas estão erradas. Para cada função, descreva o que ela faz (assumindo que o parâmetro seja uma string)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rp-vB8zWA7wO"
      },
      "source": [
        "```python\n",
        "def alguma_minuscula1(s):\n",
        "    for c in s:\n",
        "        if c.islower():\n",
        "            return True\n",
        "        else:\n",
        "            return False\n",
        "\n",
        "def alguma_minuscula2(s):\n",
        "    for c in s:\n",
        "        if 'c'.islower():\n",
        "            return 'True'\n",
        "        else:\n",
        "            return 'False'\n",
        "\n",
        "def alguma_minuscula3(s):\n",
        "    for c in s:\n",
        "        flag = c.islower()\n",
        "    return flag\n",
        "\n",
        "def alguma_minuscula4(s):\n",
        "    flag = False\n",
        "    for c in s:\n",
        "        flag = flag or c.islower()\n",
        "    return flag\n",
        "\n",
        "def alguma_minuscula5(s):\n",
        "    for c in s:\n",
        "        if not c.islower():\n",
        "            return False\n",
        "    return True\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SegQAPKlA7wO"
      },
      "source": [
        "### Exercício 8.5\n",
        "\n",
        "Uma cifra de César é uma forma fraca de criptografia que implica “rotacionar” cada letra por um número fixo de lugares. Rotacionar uma letra significa deslocá-lo pelo alfabeto, voltando ao início se for necessário, portanto `‘A’` rotacionado por 3 é `‘D’` e `‘Z’` rotacionado por 1 é `‘A’`.\n",
        "\n",
        "Para rotacionar uma palavra, faça cada letra se mover pela mesma quantidade de posições. Por exemplo, `“cheer”` rotacionado por 7 é `“jolly”` e `“melon”` rotacionado por -10 é `“cubed”`. No filme 2001: Uma odisseia no espaço, o computador da nave chama-se HAL, que é IBM rotacionado por -1.\n",
        "\n",
        "Escreva uma função chamada `rotaciona_palavra` que receba uma string e um número inteiro como parâmetros, e retorne uma nova string que contém as letras da string original rotacionadas pelo número dado.\n",
        "\n",
        "Você pode usar a função integrada `ord`, que converte um caractere em um código numérico e `chr`, que converte códigos numéricos em caracteres. As letras do alfabeto são codificadas em ordem alfabética, então, por exemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9JGdal1zA7wO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f77aafa2-38b1-4cf5-b4e5-3b80e930fcbf"
      },
      "source": [
        "ord('c') - ord('a')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lBlhhjawA7wO"
      },
      "source": [
        "Porque `'c'` é a “segunda” letra do alfabeto. Mas tenha cuidado: os códigos numéricos de letras maiúsculas são diferentes.\n",
        "\n",
        "Piadas potencialmente ofensivas na internet às vezes são codificadas em ROT13, que é uma cifra de César com rotação 13. Se não se ofender facilmente, encontre e decifre algumas delas."
      ]
    }
  ]
}