Capítulo 03 - Funções.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 03 - Funções.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CdjftgP38Exu"
      },
      "source": [
        "# Capítulo 3: Funções"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "im3nnqSb8Exx"
      },
      "source": [
        "No contexto da programação, uma **função** é uma sequência nomeada de instruções que executa uma operação de computação. Ao definir uma função, você especifica o nome e a sequência de instruções. Depois, pode “chamar” a função pelo nome."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uF7IqI9C8Exy"
      },
      "source": [
        "## 3.1 - Chamada de função"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AlEIvLS88Exy"
      },
      "source": [
        "Já vimos um exemplo de **chamada de função**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zo7-59hR8Exy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "92b2eb46-7ce5-405f-9f54-c6b493f2cab1"
      },
      "source": [
        "type (42)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HlQowhav8Ex0"
      },
      "source": [
        "O nome da função é type. A expressão entre parênteses é chamada de **argumento** da função. Para esta função, o resultado é o tipo do argumento.\n",
        "\n",
        "É comum dizer que uma função “recebe” um argumento e “retorna” um resultado. O resultado também é chamado de **valor de retorno**.\n",
        "\n",
        "O Python oferece funções que convertem valores de um tipo em outro. A função `int` recebe qualquer valor e o converte em um número inteiro, se for possível, ou declara que há um erro:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0g_C2VpI8Ex0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aae91d6a-f151-443b-fc61-d52ec3338aff"
      },
      "source": [
        "int ('32')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "32"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7atZNr4G8ToA",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 171
        },
        "outputId": "9b48dc74-94df-41c6-bbc9-57a5123d98c4"
      },
      "source": [
        "int ('Hello')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-3-64b611f246e8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m'Hello'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'Hello'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Gnm6hbh8Ex2"
      },
      "source": [
        "`int` pode converter valores de ponto flutuante em números inteiros, mas não faz arredondamentos; ela apenas corta a parte da fração:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3v1wX29G8Ex2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "705f04a1-7df0-416e-91c7-e2b43b438977"
      },
      "source": [
        "int (3.99999)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DymBpFsK8Ex3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "57188783-e8da-43f8-b447-bc1646778291"
      },
      "source": [
        "int (-2.3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-2"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qI_FRqdS8Ex3"
      },
      "source": [
        "`float` converte números inteiros e strings em números de ponto flutuante:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LeqVJ4qQ8Ex3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0d522765-eac4-4f23-ee64-6a96f7bbf96b"
      },
      "source": [
        "float (32)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "32.0"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rSHJnDbt8Ex4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "76192733-c8b4-4364-c0b4-3921664fc3eb"
      },
      "source": [
        "float ('3.14159')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.14159"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-0cRYnkK8Ex4"
      },
      "source": [
        "Finalmente, `str` converte o argumento em uma string:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P5MY7yPF8Ex4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "9a739198-c133-45f4-e3e5-c23bd3d54694"
      },
      "source": [
        "str (32)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'32'"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uS_HRwm-8Ex5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "ab2a3d6a-801c-4137-9a49-f78a37f40119"
      },
      "source": [
        "str (3.14159)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'3.14159'"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "io5fyGFJ8Ex5"
      },
      "source": [
        "## 3.2 - Funções matemáticas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kPFu-r328Ex5"
      },
      "source": [
        "O Python tem um módulo matemático que oferece a maioria das funções matemáticas comuns. Um **módulo** é um arquivo que contém uma coleção de funções relacionadas.\n",
        "\n",
        "Antes que possamos usar as funções em um módulo, precisamos importá-lo com uma **instrução de importação**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-nlq4Oi78Ex5"
      },
      "source": [
        "import math"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NwqmaxN_8Ex6"
      },
      "source": [
        "Esta instrução cria um **objeto módulo** chamado math (matemática). Ao se exibir o objeto de módulo, são apresentadas informações sobre ele:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IQhmufCf8Ex6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "82e2525b-7477-4b0d-e637-27de5a607dca"
      },
      "source": [
        "math"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<module 'math' (built-in)>"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xS-hyisU8Ex6"
      },
      "source": [
        "O objeto de módulo contém as funções e variáveis definidas no módulo. Para acessar uma das funções, é preciso especificar o nome do módulo e o nome da função, separados por um ponto. Este formato é chamado de **notação de ponto**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QyWpDM1I8Ex6"
      },
      "source": [
        "```python\n",
        "razao = potencia_sinal / potencia_ruido\n",
        "decibels = 10 * math.log10 (razao)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4-dW1pvU8Ex7"
      },
      "source": [
        "radianos = 0.7"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vODdVuh08Ex7"
      },
      "source": [
        "altura = math.sin(radianos)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vSYz5sGl8Ex7"
      },
      "source": [
        "O primeiro exemplo usa `math.log10` para calcular a proporção de sinal e de ruído em decibéis (assumindo que `potencia_sinal` e `potencia_ruido` tenham sido definidos). O módulo matemático também oferece a função `log`, que calcula logaritmos de base e.\n",
        "\n",
        "O segundo exemplo encontra o seno de `radianos`. O nome da variável indica que `sin` e outras funções trigonométricas (`cos`, `tan` etc.) recebem argumentos em radianos. Para converter graus em radianos, divida por 180 e multiplique por π:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mSJqva258Ex7"
      },
      "source": [
        "graus = 45"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "435-OE0h8Ex7"
      },
      "source": [
        "radianos = graus / 180.0 * math.pi"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vyTMS_YL8Ex8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f24c425b-28bd-4839-b7db-b38c16477a4f"
      },
      "source": [
        "math.sin (radianos)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7071067811865475"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wr7wSbs38Ex8"
      },
      "source": [
        "A expressão `math.pi` recebe a variável pi do módulo matemático. Seu valor é uma aproximação de ponto flutuante de π, com precisão aproximada de 15 dígitos.\n",
        "\n",
        "Se souber trigonometria, você pode verificar o resultado anterior comparando-o com a raiz quadrada de 2 dividida por 2:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TrTEvlBt8Ex8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "27245ccd-d72b-4407-f258-2b6c599d2a08"
      },
      "source": [
        "math.sqrt(2) / 2.0"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7071067811865476"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MJ_IYWvq8Ex8"
      },
      "source": [
        "## 3.3 - Composição"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2bHjNfLE8Ex8"
      },
      "source": [
        "Por enquanto, falamos sobre os elementos de um programa – variáveis, expressões e instruções – de forma isolada, mas não sobre como combiná-los.\n",
        "\n",
        "Uma das características mais úteis das linguagens de programação é a sua capacidade de usar pequenos blocos de montar para **compor** programas. Por exemplo, o argumento de uma função pode ser qualquer tipo de expressão, inclusive operadores aritméticos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zo-z5n2d8Ex9"
      },
      "source": [
        "x = math.sin (graus / 360.0 * 2 * math.pi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jCtnQfw_8Ex9"
      },
      "source": [
        "E até chamadas de função:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fbaH4yNB8Ex9"
      },
      "source": [
        "x = math.exp (math.log(x+1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ziYlDvj68Ex9"
      },
      "source": [
        "É possível colocar um valor, uma expressão arbitrária, em quase qualquer lugar. Com uma exceção: o lado esquerdo de uma instrução de atribuição tem que ser um nome de variável. Qualquer outra expressão no lado esquerdo é um erro de sintaxe (veremos exceções a esta regra depois)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ew-gkg6s8Ex9"
      },
      "source": [
        "```python\n",
        "minutos = horas * 60                # correto\n",
        "horas * 60 = minutos                # errado!\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6f0Umdi28Ex9"
      },
      "source": [
        "## 3.4 - Como acrescentar novas funções"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u7HGYODh8Ex9"
      },
      "source": [
        "Por enquanto, só usamos funções que vêm com o Python, mas também é possível acrescentar novas funções. Uma definição de função especifica o nome de uma nova função e a sequência de instruções que são executadas quando a função é chamada.\n",
        "\n",
        "Aqui está um exemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X1zqPBzs8Ex-"
      },
      "source": [
        "def imprima_letra():\n",
        "    print(\"Meu coração, não sei o porquê\")\n",
        "    print(\"Bate feliz, quando te vê\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T4AoG6ZE8Ex-"
      },
      "source": [
        "`def` é uma palavra-chave que indica uma **definição de função**. O nome da função é `imprima_letra`. As regras para nomes de função são as mesmas que as das variáveis: letras, números e sublinhado são legais, mas o primeiro caractere não pode ser um número. Não podemos usar uma palavra-chave como nome de uma função e devemos evitar ter uma variável e uma função com o mesmo nome.\n",
        "\n",
        "Os parênteses vazios depois do nome indicam que esta função não usa argumentos.\n",
        "\n",
        "A primeira linha da definição de função chama-se **cabeçalho**; o resto é chamado de **corpo**. O cabeçalho precisa terminar em dois pontos e o corpo precisa ser endentado. Por convenção, a endentação sempre é de quatro espaços. O corpo pode conter qualquer número de instruções.\n",
        "\n",
        "As strings nas instruções de exibição são limitadas por aspas duplas. As aspas simples e as aspas duplas fazem a mesma coisa; a maior parte das pessoas usa aspas duplas apenas nos casos em que aspas simples (que também são apóstrofes) aparecem na string.\n",
        "\n",
        "Todas as aspas (simples e duplas) devem ser “aspas retas”, normalmente encontradas ao lado do Enter no teclado. “Aspas curvas”, como as desta oração, não são legais no Python.\n",
        "\n",
        "Se digitar uma definição de função no modo interativo, o interpretador exibe pontos (...) para mostrar que a definição não está completa:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dCdyJXhp8Ex_"
      },
      "source": [
        "```python\n",
        ">>> def imprima_letra():\n",
        "...     print (\"Meu coração, não sei o porquê\")`\n",
        "...     print(\"Bate feliz, quando te vê\")`\n",
        "...\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E0bV6vL68Ex_"
      },
      "source": [
        "Para terminar a função, é preciso inserir uma linha vazia.\n",
        "\n",
        "A definição de uma função cria um **objeto de função**, que tem o tipo function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T2JKBJGN8Ex_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ea9e83ef-731a-4365-b323-317afa1dc9b0"
      },
      "source": [
        "print (imprima_letra)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<function imprima_letra at 0x7ff4408a3cb0>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kPtyXAep8Ex_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b4032e4f-91b6-451a-d5d6-2f719ca2d371"
      },
      "source": [
        "type (imprima_letra)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "function"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ziiB08xQ8Ex_"
      },
      "source": [
        "A sintaxe para chamar a nova função é a mesma que a das funções integradas:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RRQedSC88Ex_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "24e943ff-ed18-4f3c-ea4d-ce652aee8d14"
      },
      "source": [
        "imprima_letra ()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Eh, oh, oh, vida de gado\n",
            "Povo marcado, eh!\n",
            "Povo feliz!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v5yrEHTU8EyA"
      },
      "source": [
        "Uma vez que a função tenha sido definida, é possível usá-la dentro de outra função. Por exemplo, para repetir o refrão anterior, podemos escrever uma função chamada `repita_letra`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vA3d9DHv8EyA"
      },
      "source": [
        "def repita_letra():\n",
        "    imprima_letra()\n",
        "    imprima_letra()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jVf-_xBZ8EyA"
      },
      "source": [
        "E daí chamar `repeat_lyrics`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Nvxc8tZ8EyA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dae9c51b-f74f-4dae-e340-1738ac8fa5ea"
      },
      "source": [
        "repita_letra ()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Meu coração, não sei o porquê\n",
            "Bate feliz, quando te vê\n",
            "Meu coração, não sei o porquê\n",
            "Bate feliz, quando te vê\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_eSTJeSe8EyA"
      },
      "source": [
        "Mas a canção não é bem assim."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JAWFjHcH8EyA"
      },
      "source": [
        "## 3.5 - Uso e definições"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2PhyCmFb8EyA"
      },
      "source": [
        "Juntando fragmentos de código da seção anterior, o programa inteiro fica assim:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SF7n-jML8EyB"
      },
      "source": [
        "def imprima_letra():\n",
        "    print(\"Meu coração, não sei o porquê\")\n",
        "    print(\"Bate feliz, quando te vê\")\n",
        "\n",
        "def repita_letra():\n",
        "    imprima_letra()\n",
        "    imprima_letra()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z5tqDsYh8EyB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3bcf2252-8807-44ee-d79e-51ebea0cfbc8"
      },
      "source": [
        "repita_letra ()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Meu coração, não sei o porquê\n",
            "Bate feliz, quando te vê\n",
            "Meu coração, não sei o porquê\n",
            "Bate feliz, quando te vê\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bO0EVCSX8EyB"
      },
      "source": [
        "Este programa contém duas definições de função: `imprima_letra` e `repita_letra`. As definições de função são executadas como outras instruções, mas o efeito é criar objetos de função. As instruções dentro da função não são executadas até que a função seja chamada, e a definição de função não gera nenhuma saída.\n",
        "\n",
        "Como poderíamos esperar, é preciso criar uma função antes de executá-la. Em outras palavras, a definição de função tem que ser executada antes que a função seja chamada.\n",
        "\n",
        "Como exercício, mova a última linha deste programa para o topo, para que a chamada de função apareça antes das definições. Execute o programa e veja qual é a mensagem de erro que aparece.\n",
        "\n",
        "Agora mova a chamada de função de volta para baixo e mova a definição de `imprima_letra` para depois da definição de `repita_letra`. O que acontece quando este programa é executado?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hK9w_MyL8EyB"
      },
      "source": [
        "## 3.6 - Fluxo de execução"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kcAWjNYX8EyB"
      },
      "source": [
        "Para garantir que uma função seja definida antes do seu primeiro uso, é preciso saber a ordem na qual as instruções serão executadas. Isso é chamado de **fluxo de execução**.\n",
        "\n",
        "A execução sempre começa na primeira instrução do programa. As instruções são executadas uma após a outra, de cima para baixo.\n",
        "\n",
        "As definições de função não alteram o fluxo da execução do programa, mas lembre-se de que as instruções dentro da função não são executadas até a função ser chamada.\n",
        "\n",
        "Uma chamada de função é como um desvio no fluxo de execução. Em vez de ir à próxima instrução, o fluxo salta para o corpo da função, executa as instruções lá, e então volta para continuar de onde parou.\n",
        "\n",
        "Parece bastante simples, até você lembrar que uma função pode chamar outra. Enquanto estiver no meio de uma função, o programa pode ter que executar as instruções em outra função. Então, enquanto estiver executando a nova função, o programa pode ter que executar mais uma função!\n",
        "\n",
        "Felizmente, o Python é bom em não perder o fio da meada, então cada vez que uma função é concluída, o programa continua de onde parou na função que o chamou. Quando chega no fim do programa, ele é encerrado.\n",
        "\n",
        "Resumindo, nem sempre se deve ler um programa de cima para baixo. Às vezes faz mais sentido seguir o fluxo de execução."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qWpU_Aaz8EyB"
      },
      "source": [
        "## 3.7 - Parâmetros e argumentos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RhaeCDuP8EyB"
      },
      "source": [
        "Algumas funções que vimos exigem argumentos. Por exemplo, ao chamar `math.sin`, você usa um número como argumento. Algumas funções exigem mais de um argumento: o `math.pow` exige dois, a base e o expoente.\n",
        "\n",
        "Dentro da função, os argumentos são atribuídos a variáveis chamadas **parâmetros**. Aqui está a definição de uma função que precisa de um argumento:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "keFiwexa8EyC"
      },
      "source": [
        "def print_twice(bruce): # twice significa duas vezes\n",
        "    print(bruce)\n",
        "    print(bruce)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0CAiJDyW8EyC"
      },
      "source": [
        "Esta função atribui o argumento a um parâmetro chamado `bruce`. Quando a função é chamada, ela exibe o valor do parâmetro (seja qual for) duas vezes.\n",
        "\n",
        "Esta função funciona com qualquer valor que possa ser exibido:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vlsgqg5I8EyC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "286b427f-b64a-43ba-8be1-142d4eaa6b43"
      },
      "source": [
        "print_twice ('Spam')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Spam\n",
            "Spam\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wnVDnkbY8EyC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a551b4fc-2c34-4a82-cb37-b0c5fbab763c"
      },
      "source": [
        "print_twice (42)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "42\n",
            "42\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d5FNzviz8EyC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4d71d2b3-e57f-446d-985d-d23442214f0e"
      },
      "source": [
        "print_twice (math.pi)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.141592653589793\n",
            "3.141592653589793\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nIPSSUhX8EyC"
      },
      "source": [
        "As mesmas regras de composição usadas para funções integradas também são aplicadas a funções definidas pelos programadores, então podemos usar qualquer tipo de expressão como argumento para `print_twice`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1OyLh_1F8EyD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2fc69b14-c0fe-4997-8cb1-2170201afe74"
      },
      "source": [
        "print_twice ('Spam '*4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Spam Spam Spam Spam \n",
            "Spam Spam Spam Spam \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "feE6TJMu8EyD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cf21924d-c442-48f8-9c8c-e3c68b08703b"
      },
      "source": [
        "print_twice (math.cos(math.pi))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-1.0\n",
            "-1.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F_-GhDeo8EyD"
      },
      "source": [
        "O argumento é avaliado antes de a função ser chamada. Então, nos exemplos, as expressões `'Spam' * 4` e `math.cos(math.pi)` só são avaliadas uma vez."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qqP7KdYH8EyD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f6576abc-984f-412a-be8b-b4264760574a"
      },
      "source": [
        "# Você também pode usar uma variável como argumento:\n",
        "outro_texto = 'Luiz Gonzaga, o rei do baião.'\n",
        "print_twice(outro_texto)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Luiz Gonzaga, o rei do baião.\n",
            "Luiz Gonzaga, o rei do baião.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9ECRUrwD8EyD"
      },
      "source": [
        "O nome da variável que passamos como argumento (`outro_texto`) não tem nada a ver com o nome do parâmetro (`bruce`). Não importa que o valor tenha sido chamado de volta (em quem chama); aqui em `print_twice`, chamamos todo mundo de `bruce`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oCUbiHmX8EyD"
      },
      "source": [
        "## 3.8 - As variáveis e os parâmetros são locais"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LH9rGVqV8EyE"
      },
      "source": [
        "Quando você cria uma variável dentro de uma função, ela é **local**, ou seja, ela só existe dentro da função. Por exemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hksaa9Ly8EyE"
      },
      "source": [
        "def cat_twice (part1, part2): # \"cat_twice\" não tem significado\n",
        "    cat = part1 + part2\n",
        "    print_twice (cat)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6eOzI3HI8EyE"
      },
      "source": [
        "Esta função recebe dois argumentos, concatena-os e exibe o resultado duas vezes. Aqui está um exemplo que a usa:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3O4-zeKd8EyE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "22f13b85-9e07-41c7-d8d9-4cf4cec441a4"
      },
      "source": [
        "line1 = 'Bing tiddle '\n",
        "line2 = 'tiddle bang.'\n",
        "cat_twice (line1, line2) # Busque pela expressão resultante na internet ;)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Bing tiddle tiddle bang.\n",
            "Bing tiddle tiddle bang.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cgMZC6AN8EyE"
      },
      "source": [
        "Quando `cat_twice` é encerrada, a variável `cat` é destruída. Se tentarmos exibí-la, recebemos uma exceção:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qvA595xLEn3C",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 171
        },
        "outputId": "99d6a8f8-6a22-4676-d32b-9fc7d4915942"
      },
      "source": [
        "print(cat)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-65-34599fba884e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'cat' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0gbQM8X08EyE"
      },
      "source": [
        "Os parâmetros também são locais. Por exemplo, além de `print_twice`, não existe o `bruce`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ezegjBta8EyF"
      },
      "source": [
        "## 3.9 - Diagrama da pilha"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uaYQPqz08EyF"
      },
      "source": [
        "Para monitorar quais variáveis podem ser usadas e onde, é uma boa ideia desenhar um **diagrama da pilha**. Assim como diagramas de estado, os diagramas da pilha mostram o valor de cada variável, mas também mostram a função à qual cada variável pertence.\n",
        "\n",
        "Cada função é representada por um **frame** (quadro). Um frame é uma caixa com o nome de uma função junto a ele e os parâmetros e as variáveis da função dentro dele. O diagrama da pilha para o exemplo anterior é exibido na Figura 3.1."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CKvFu_838EyF"
      },
      "source": [
        "<center><img src=\"https://github.com/PenseAllen/PensePython2e/raw/master/fig/tnkp_0301.png\"></center>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vm1mzA3G8EyF"
      },
      "source": [
        "<h5><center>Figura 3.1 – Diagrama da pilha.</center></h5>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "18NixWPd8EyF"
      },
      "source": [
        "Os frames são organizados em uma pilha que indica qual função que foi chamada por outra, e assim por diante. Neste exemplo, `print_twice` foi chamada por `cat_twice` e `cat_twice` foi chamada por `__main__`, que é um nome especial para o frame na posição mais proeminente. Quando você cria uma variável fora de qualquer função, ela pertence a `__main__`.\n",
        "\n",
        "Cada parâmetro refere-se ao mesmo valor como seu argumento correspondente. Desta forma, `part1` tem o mesmo valor que `line1`, `part2` tem o mesmo valor que `line2` e `bruce` tem o mesmo valor que `cat`.\n",
        "\n",
        "Se ocorrer um erro durante uma chamada de função, o Python exibe o nome da função, o nome da função que a chamou e o nome da função que chamou esta função por sua vez, voltando até `__main__`.\n",
        "\n",
        "Por exemplo, se você tentar acessar `cat` de dentro de `print_twice`, receberá uma mensagem de `NameError`:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOplLN3oFq_Y"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "raw",
      "metadata": {
        "id": "9oEaLdXO8EyF"
      },
      "source": [
        "```\n",
        "Traceback (innermost last):\n",
        "  File \"test.py\", line 13, in __main__\n",
        "    cat_twice(line1, line2)\n",
        "  File \"test.py\", line 5, in cat_twice\n",
        "    print_twice(cat)\n",
        "  File \"test.py\", line 9, in print_twice\n",
        "    print(cat)\n",
        "NameError: name 'cat' is not defined\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z7KX2sfh8EyF"
      },
      "source": [
        "Esta lista de funções é chamada de **traceback**. Ela mostra o arquivo do programa em que o erro ocorreu e em que linha, e quais funções estavam sendo executadas no momento. Ele também mostra a linha de código que causou o erro.\n",
        "\n",
        "A ordem das funções no traceback é a mesma que a ordem dos frames no diagrama da pilha. A função que está sendo executada no momento está no final."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z8P_Sgmm8EyF"
      },
      "source": [
        "## 3.10 - Funções com resultado e funções nulas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YcZCtZGZ8EyF"
      },
      "source": [
        "Algumas funções que usamos, como as funções matemáticas, devolvem resultados; por falta de um nome melhor, vou chamá-las de **funções com resultados**. Outras funções, como `print_twice`, executam uma ação, mas não devolvem um valor. Elas são chamadas de **funções nulas**.\n",
        "\n",
        "Quando você chama uma função com resultado, quase sempre quer fazer algo com o resultado; por exemplo, você pode atribuí-lo a uma variável ou usá-la como parte de uma expressão:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hreb0xq5HZoE"
      },
      "source": [
        "```python\n",
        "x = math.cos(radians)\n",
        "golden = (math.sqrt(5) + 1) / 2\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bh98e6lu8EyG"
      },
      "source": [
        "Quando você chama uma função no modo interativo, o Python exibe o resultado:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8yY6OXix8EyG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c39c2f7e-1a2b-4b74-8a14-0b92c60b9d64"
      },
      "source": [
        ">>> math.sqrt(5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.23606797749979"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_3fOxqhM8EyG"
      },
      "source": [
        "Mas em um script, se você chamar uma função com resultado e mais nada, o valor de retorno é perdido para sempre!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8ZPqDPusHreW"
      },
      "source": [
        "```python\n",
        "math.sqrt(5)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4K9exn1A8EyG"
      },
      "source": [
        "Este script calcula a raiz quadrada de 5, mas como não armazena ou exibe o resultado, não é muito útil.\n",
        "\n",
        "As funções nulas podem exibir algo na tela ou ter algum outro efeito, mas não têm um valor de retorno. Se você atribuir o resultado a uma variável, recebe um valor especial chamado None:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yloxc6D_8EyG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a1e5352a-a9bc-4c82-b069-35a0b57ffee1"
      },
      "source": [
        "result = print_twice ('Bing')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Bing\n",
            "Bing\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PAN_yl9N8EyH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "de5c23a1-1a7a-4c92-8fca-36a678da976a"
      },
      "source": [
        "print (result)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x9h9t4Ff8EyH"
      },
      "source": [
        "O valor **None** não é o mesmo que a string **'None'**. É um valor especial que tem seu próprio tipo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2BaCjuv08EyH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f34b5f38-2729-437e-9b84-f96e93e0fa1d"
      },
      "source": [
        "print (type(None))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'NoneType'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mO2BvYx88EyH"
      },
      "source": [
        "As funções que apresentamos por enquanto são todas nulas. Vamos apresentar funções com resultado mais adiante."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZUHwjT078EyH"
      },
      "source": [
        "## 3.11 - Por que funções?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3cUWL_Kr8EyH"
      },
      "source": [
        "Caso o objetivo de dividir um programa em funções não esteja claro, saiba que na verdade há várias razões:\n",
        "\n",
        "<ul>\n",
        "  <li>Criar uma nova função dá a oportunidade de nomear um grupo de instruções, o que deixa o seu programa mais fácil de ler e de depurar.</li>\n",
        "  <li>As funções podem tornar um programa menor, eliminando o código repetitivo. Depois, se fizer alguma alteração, basta fazê-la em um lugar só.</li>\n",
        "  <li>Dividir um programa longo em funções permite depurar as partes uma de cada vez e então reuní-las em um conjunto funcional.</li>\n",
        "  <li>As funções bem projetadas muitas vezes são úteis para muitos programas. Uma vez que escreva e depure uma, você pode reutilizá-la.</li>\n",
        "</ul>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1mAKw7Xe8EyH"
      },
      "source": [
        "## 3.12 - Depuração"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8LliyYkN8EyI"
      },
      "source": [
        "Uma das habilidades mais importantes que você vai aprender é a depuração. Embora possa ser frustrante, a depuração é uma das partes mais intelectualmente ricas, desafiadoras e interessantes da programação.\n",
        "\n",
        "De certa forma, depurar é similar ao trabalho de um detetive. Você tem pistas e precisa inferir os processos e eventos que levaram aos resultados exibidos.\n",
        "\n",
        "A depuração também é como ciência experimental. Uma vez que você tenha uma ideia sobre o que está errado, basta alterar o programa e tentar novamente. Se a sua hipótese estava correta, você pode prever o resultado da alteração e chegar um passo mais perto de um programa funcional. Se a sua hipótese estava errada, é preciso criar outra. Como dizia Sherlock Holmes, “Quando se elimina o impossível, o que sobra, por mais incrível que pareça, só pode ser a verdade.” (A. Conan Doyle, O signo dos quatro).\n",
        "\n",
        "Para algumas pessoas, programar e depurar são a mesma coisa. Isto é, a programação é o processo de depurar gradualmente um programa até que ele faça o que o programador quer. A ideia é que você comece com um programa funcional e faça pequenas alterações, depurando-as no decorrer do trabalho.\n",
        "\n",
        "Por exemplo, o Linux é um sistema operacional que contém milhões de linhas de código, mas começou como um programa simples que Linus Torvalds usava para explorar o chip Intel 80386. Segundo Larry Greenfield, “Um dos primeiros projetos de Linus foi um programa que alternaria entre a exibição de AAAA e BBBB. Mais tarde isso se desenvolveu até virar o Linux.” (Guia do usuário de Linux versão beta 1)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bMM2_ser8EyI"
      },
      "source": [
        "## 3.13 - Glossário"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "APJP2LwO8EyI"
      },
      "source": [
        "**função**<br>\n",
        "&emsp;Uma sequência nomeada de declarações que executa alguma operação útil. As funções podem receber argumentos ou não e podem ou não produzir algum resultado.\n",
        "\n",
        "**definição de função**<br>\n",
        "&emsp;Uma instrução que cria uma função nova, especificando seu nome, parâmetros e as instruções que contém.\n",
        "\n",
        "**objeto da função.**<br>\n",
        "&emsp;Um valor é criado por uma definição de função. O nome da função é uma variável que se refere a um objeto de função.\n",
        "\n",
        "**cabeçalho.**<br>\n",
        "&emsp;A primeira linha de uma definição de função.\n",
        "\n",
        "**corpo**<br>\n",
        "&emsp;A sequência de instruções dentro de uma definição de função.\n",
        "\n",
        "**parâmetro**<br>\n",
        "&emsp;Um nome usado dentro de uma função para se referir ao valor passado como argumento.\n",
        "\n",
        "**chamada de função**<br>\n",
        "&emsp;Uma instrução que executa uma função. É composta pelo nome da função seguido de uma lista de argumentos entre parênteses.\n",
        "\n",
        "**argumento**<br>\n",
        "&emsp;Um valor apresentado a uma função quando a função é chamada. Este valor é atribuído ao parâmetro correspondente na função.\n",
        "\n",
        "**variável local**<br>\n",
        "&emsp;Uma variável definida dentro de uma função. Uma variável local só pode ser usada dentro da sua função.\n",
        "\n",
        "**valor de retorno**<br>\n",
        "&emsp;O resultado de uma função. Se uma chamada de função for usada como uma expressão, o valor de retorno é o valor da expressão.\n",
        "\n",
        "**função com resultado**<br>\n",
        "&emsp;Uma função que devolve um valor.\n",
        "\n",
        "**função nula**<br>\n",
        "&emsp;Uma função que sempre devolve None.\n",
        "\n",
        "**None**<br>\n",
        "&emsp;Um valor especial apresentado por funções nulas.\n",
        "\n",
        "**módulo**<br>\n",
        "&emsp;Um arquivo que contém uma coleção de funções relacionadas e outras definições.\n",
        "\n",
        "**instrução de importação**<br>\n",
        "&emsp;Uma instrução que lê um arquivo de módulo e cria um objeto de módulo.\n",
        "\n",
        "**objeto de módulo**<br>\n",
        "&emsp;Um valor criado por uma instrução import que oferece acesso aos valores definidos em um módulo.\n",
        "\n",
        "**notação de ponto**<br>\n",
        "&emsp;A sintaxe para chamar uma função em outro módulo especificando o nome do módulo seguido de um ponto e o nome da função.\n",
        "\n",
        "**composição**<br>\n",
        "&emsp;O uso de uma expressão como parte de uma expressão maior ou de uma instrução como parte de uma instrução maior.\n",
        "\n",
        "**fluxo de execução**<br>\n",
        "&emsp;A ordem na qual as instruções são executadas.\n",
        "\n",
        "**diagrama da pilha**<br>\n",
        "&emsp;Representação gráfica de uma pilha de funções, suas variáveis e os valores a que se referem.\n",
        "\n",
        "**frame**<br>\n",
        "&emsp;Uma caixa em um diagrama da pilha que representa uma chamada de função. Contém as variáveis locais e os parâmetros da função.\n",
        "\n",
        "**traceback**<br>\n",
        "&emsp;Lista das funções que estão sendo executadas, exibidas quando ocorre uma exceção."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vMXJjuGk8EyI"
      },
      "source": [
        "## 3.14 - Exercícios"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9A42L7ZD8EyI"
      },
      "source": [
        "### Exercício 3.1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RQgzIKAZ8EyI"
      },
      "source": [
        "Escreva uma função chamada right_justify, que receba uma string chamada `s` como parâmetro e exiba a string com espaços suficientes à frente para que a última letra da string esteja na coluna 70 da tela:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9TI_Zjhe8EyI"
      },
      "source": [
        "```python\n",
        ">>> right_justify('monty')\n",
        "                                                                       monty\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "smgot6WV8EyI"
      },
      "source": [
        "Dica: Use concatenação de strings e repetição. Além disso, o Python oferece uma função integrada chamada len, que apresenta o comprimento de uma string, então o valor de `len('monty')` é 5."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PxARy0fO8EyJ"
      },
      "source": [
        "### Exercício 3.2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5mbt_Xvo8EyJ"
      },
      "source": [
        "Um objeto de função é um valor que pode ser atribuído a uma variável ou passado como argumento. Por exemplo, `faca_dobrado` é uma função que toma um objeto de função como argumento e o chama duas vezes:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s5Vj1w9z8EyJ"
      },
      "source": [
        "def faca_dobrado(f):\n",
        "    f()\n",
        "    f()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7f0vF9mf8EyJ"
      },
      "source": [
        "Aqui está um exemplo que usa `faca_dobrado` para chamar uma função chamada `imprima_spam` duas vezes:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6sfErp_x8EyJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ffb0f5fd-a884-43ef-e166-ed98628f84fe"
      },
      "source": [
        "def imprima_spam():\n",
        "    print('spam')\n",
        "faca_dobrado(imprima_spam)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "spam\n",
            "spam\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eDm61Of88EyJ"
      },
      "source": [
        "<ol>\n",
        "  <li>Digite este exemplo em um script e teste-o.</li>\n",
        "  <li>Altere `faca_dobrado` para que receba dois argumentos, um objeto de função e um valor, e chame a função duas vezes, passando o valor como um argumento.</li>\n",
        "  <li>Copie a definição de `print_twice` que aparece anteriormente neste capítulo no seu script.</li>\n",
        "  <li>Use a versão alterada de `faca_dobrado` para chamar `print_twice` duas vezes, passando 'spam' como um argumento.</li>\n",
        "  <li>Defina uma função nova chamada `faca_quadrado` que receba um objeto de função e um valor e chame a função quatro vezes, passando o valor como um parâmetro. Deve haver só duas afirmações no corpo desta função, não quatro.</li>\n",
        "</ol>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sHWCraKK8EyK"
      },
      "source": [
        "*Solução: http://thinkpython2.com/code/do_four.py.*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tJR2hBBO8EyK"
      },
      "source": [
        "### Exercício 3.3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kYCUmcP78EyK"
      },
      "source": [
        "Nota: Este exercício deve ser feito usando-se apenas as instruções e os outros recursos que aprendemos até agora."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cB7IGyW18EyK"
      },
      "source": [
        "1° Escreva uma função que desenhe uma grade como a seguinte:"
      ]
    },
    {
      "cell_type": "raw",
      "metadata": {
        "id": "bcCjm5Bf8EyK"
      },
      "source": [
        "```\n",
        "        + - - - - + - - - - +\n",
        "        |         |         |\n",
        "        |         |         |\n",
        "        |         |         |\n",
        "        |         |         |\n",
        "        + - - - - + - - - - +\n",
        "        |         |         |\n",
        "        |         |         |\n",
        "        |         |         |\n",
        "        |         |         |\n",
        "        + - - - - + - - - - +\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P4jHOmUH8EyK"
      },
      "source": [
        "Dica: para exibir mais de um valor em uma linha, podemos usar uma sequência de valores separados por vírgula:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-oDbk0jw8EyL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7a4c4676-7d95-4c7f-9fb4-20d3c54d8ff8"
      },
      "source": [
        "print ('+', '-')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+ -\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GzsQhM2M8EyL"
      },
      "source": [
        "Por padrão, print avança para a linha seguinte, mas podemos ignorar esse comportamento e inserir um espaço no fim, desta forma:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AXXKY7yb8EyL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ab94065a-deb1-43c4-deb3-f67d5b402799"
      },
      "source": [
        "print ('+', end=' ')\n",
        "print ('-')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+ -\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ub3Q9VsS8EyL"
      },
      "source": [
        "A saída dessas instruções é `+ -`. Uma instrução `print` sem argumento termina a linha atual e vai para a próxima linha."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lkpAgZjM8EyL"
      },
      "source": [
        "2° Escreva uma função que desenhe uma grade semelhante com quatro linhas e quatro colunas."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tF10nCHR8EyL"
      },
      "source": [
        "*Solução: http://thinkpython2.com/code/grid.py. Crédito: Este exercício é baseado em outro apresentado por Oualline, em Practical C Programming, Third Edition, O’Reilly Media, 1997.*"
      ]
    }
  ]
}