Aula06.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Aula06.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "include_colab_link": true
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 2
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython2",
      "version": "2.7.10"
    },
    "kernelspec": {
      "display_name": "Python 2",
      "language": "python",
      "name": "python2"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/agiribeiro/Python_beginner/blob/master/Aula06.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GKn5WWYSp2A1",
        "colab_type": "text"
      },
      "source": [
        "#Funções"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hDurPBLUp2A2",
        "colab_type": "text"
      },
      "source": [
        "Na maioria das vezes, em um algoritmo as instruções continuam repetindo e será um trabalho tedioso executar as mesmas instruções repetidas vezes e consumirá muita memória e não será eficiente. Por isso usamos funções :)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jECr5_jJp2A3",
        "colab_type": "text"
      },
      "source": [
        "Essa é a sintaxe básica de uma função"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LB-pIzOpp2A3",
        "colab_type": "text"
      },
      "source": [
        "def funcname(arg1, arg2,... argN):\n",
        "    \n",
        "    ''' Document String'''\n",
        "\n",
        "    statements\n",
        "\n",
        "\n",
        "    return <value>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zV5bWWuCp2A5",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "Leia a sintaxe acima como, Uma função pelo nome \"funcname\" é definida, que aceita argumentos \"arg1, arg2, .... argN\". A função está documentada e é '' Document String' ''. A função depois de executar as instruções retorna um \"value\"."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gLfVrXyop2A6",
        "colab_type": "code",
        "outputId": "9419fe3c-bfac-44ac-cbda-3c20ed273bdb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "print \"Oi Anna!\"\n",
        "print \"Anna, tudo bem?\""
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Oi Anna!\n",
            "Anna, tudo bem?\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XFVbFxckp2BC",
        "colab_type": "text"
      },
      "source": [
        "Em vez de escrever as duas declarações acima a cada vez, ela pode ser substituída definindo uma função que faria o trabalho em apenas uma linha.\n",
        "\n",
        "Definindo uma função firstfunc ()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aokP1VfQp2BD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def firstfunc():\n",
        "    print \"Oi Anna!\"\n",
        "    print \"Anna, tudo bem?\"  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v57flc9zp2BH",
        "colab_type": "code",
        "outputId": "fff1efc8-561b-4e92-95a7-438cbfec4bf5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "firstfunc()"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Oi Anna!\n",
            "Anna, tudo bem?\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jEGGdHhOp2BN",
        "colab_type": "text"
      },
      "source": [
        "**firstfunc ()** toda vez apenas imprime a mensagem para uma única pessoa. Podemos fazer com que nossa função **firstfunc ()** aceite argumentos que armazenam o nome e depois imprimem os respectivos nomes aceitos. Para fazer isso, adicione um argumento dentro da função, como mostrado.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QRDbFW9rp2BO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def firstfunc(username):\n",
        "    print \"oi\", username + '!'\n",
        "    print username + ',' ,\"Tudo bem?\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PBZXys61p2BX",
        "colab_type": "code",
        "outputId": "bae217af-4f5a-491d-bfdf-7f1103066f46",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "name1 = raw_input('Qual seu nome? : ')"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Qual seu nome? : Anna\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fmWcI9qkp2Bg",
        "colab_type": "text"
      },
      "source": [
        "O nome \"Anna\" é armazenado no nome1. Portanto, passamos essa variável para a função **firstfunc ()** como o nome de usuário da variável, porque essa é a variável definida para essa função. ou seja, o nome1 é passado como nome de usuário.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cDBtqJqtp2Bh",
        "colab_type": "code",
        "outputId": "2d7a5390-c766-4df1-b0f6-e7020fb855c0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "firstfunc(name1)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "oi Anna!\n",
            "Anna, Tudo bem?\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-f9A-nS8p2Bk",
        "colab_type": "text"
      },
      "source": [
        "Vamos simplificar isso ainda mais definindo outra função **secondfunc ()** que aceita o nome e armazena dentro de uma variável e depois chama o **firstfunc ()** de dentro da própria função.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HoHUmPmvp2Bl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def firstfunc(username):\n",
        "    print \"Oi\", username + '!'\n",
        "    print username + ',' ,\"Tudo bem?\"\n",
        "def secondfunc():\n",
        "    name = raw_input(\"Qual seu nome?: \")\n",
        "    firstfunc(name)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1LNk_lqCp2Bo",
        "colab_type": "code",
        "outputId": "43ef1ea6-46b3-4e5f-eba4-e2ff544744c9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "secondfunc()"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Qual seu nome?: Anna\n",
            "Oi Anna!\n",
            "Anna, Tudo bem?\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J4yN3Y0Fp2Bs",
        "colab_type": "text"
      },
      "source": [
        "##Retorno da função"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8bSZeGTmp2Bt",
        "colab_type": "text"
      },
      "source": [
        "Quando a função resulta em algum valor e esse valor deve ser armazenado em uma variável ou precisa ser enviado de volta ou retornado para operação futura no algoritmo principal, a instrução de retorno é usada.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q-pBl08lp2Bu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def times(x,y):\n",
        "    z = x*y\n",
        "    return z"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "USQdPYBbp2By",
        "colab_type": "text"
      },
      "source": [
        "A função **times ()** definida acima aceita dois argumentos e retorna a variável z que contém o resultado do produto dos dois argumentos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CDnpvmCHp2B0",
        "colab_type": "code",
        "outputId": "823b2798-d77c-4e85-cb48-7951b194ce62",
        "colab": {}
      },
      "source": [
        "c = times(4,5)\n",
        "print c"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "20\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fOO-d_ohp2B5",
        "colab_type": "text"
      },
      "source": [
        "O valor z é armazenado na variável c e pode ser usado para outras operações."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EjphodEUp2B6",
        "colab_type": "text"
      },
      "source": [
        "Em vez de declarar outra variável, toda a própria instrução pode ser usada na declaração de retorno, como mostrado.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FojWaQF5p2B7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def times(x,y):\n",
        "    '''Multiplica os dois argumentos'''\n",
        "    return x*y"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yeT-GBBHp2CA",
        "colab_type": "code",
        "outputId": "22a445cb-a35e-4483-d0b8-45423639fbf5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "c = times(4,5)\n",
        "print c"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "20\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qotV51SHp2CG",
        "colab_type": "text"
      },
      "source": [
        "Como a função **times ()** está agora definida, podemos documentá-la como mostrado acima. Este documento é retornado sempre que a função **times ()** é chamada na função **help ()**.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FD4lrAwFp2CI",
        "colab_type": "code",
        "outputId": "04f56743-027f-403a-eabf-0778180be68c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        }
      },
      "source": [
        "help(times)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on function times in module __main__:\n",
            "\n",
            "times(x, y)\n",
            "    Multiplica os dois argumentos\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zXwg4Hlgp2CP",
        "colab_type": "text"
      },
      "source": [
        "Várias variáveis ​​também podem ser retornadas, mas lembre-se da ordem.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "98uqd35_p2CQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "eglist = [10,50,30,12,6,8,100]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-MzuNh5Fp2CT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def egfunc(eglist):\n",
        "    highest = max(eglist)\n",
        "    lowest = min(eglist)\n",
        "    first = eglist[0]\n",
        "    last = eglist[-1]\n",
        "    return highest,lowest,first,last"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OupSZjqFp2CW",
        "colab_type": "text"
      },
      "source": [
        "Se a função é chamada apenas sem nenhuma variável para ser atribuída, o resultado é retornado dentro de uma tupla. Mas se as variáveis ​​são mencionadas, o resultado é atribuído à variável em uma ordem específica que é declarada na declaração de retorno.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WBjmqurnp2CW",
        "colab_type": "code",
        "outputId": "31af7f42-136c-43d2-f207-8ec9f6bd2ea8",
        "colab": {}
      },
      "source": [
        "egfunc(eglist)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(100, 6, 10, 100)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o_amOj6Vp2Ce",
        "colab_type": "code",
        "outputId": "a0491449-fb16-49f3-fb2a-83983bbb2681",
        "colab": {}
      },
      "source": [
        "a,b,c,d = egfunc(eglist)\n",
        "print ' a =',a,'\\n b =',b,'\\n c =',c,'\\n d =',d"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            " a = 100 \n",
            " b = 6 \n",
            " c = 10 \n",
            " d = 100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HjmZuHyjp2Ci",
        "colab_type": "text"
      },
      "source": [
        "##Argumentos implícitos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Cca0dq8p2Ci",
        "colab_type": "text"
      },
      "source": [
        "Quando um argumento de uma função é comum na maioria dos casos ou é \"implícito\", esse conceito é usado.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NL_wMjrgp2Cj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def implicitadd(x,y=3):\n",
        "    return x+y"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pqZHV1SCp2Cm",
        "colab_type": "text"
      },
      "source": [
        "**implicitadd( )** é uma função aceita dois argumentos, mas na maioria das vezes o primeiro argumento precisa ser adicionado apenas por 3. Portanto, o segundo argumento recebe o valor 3. Aqui, o segundo argumento é implícito.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y-lnIz7hp2Cm",
        "colab_type": "text"
      },
      "source": [
        "Agora, se o segundo argumento não for definido ao chamar a função **implicitadd ()**, ele será considerado como 3.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fqtWVXdhp2Cn",
        "colab_type": "code",
        "outputId": "934447e7-a9af-427b-d559-a96487104f08",
        "colab": {}
      },
      "source": [
        "implicitadd(4)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m6sAG79wp2Cs",
        "colab_type": "text"
      },
      "source": [
        "Mas, se o segundo argumento for especificado, esse valor substituirá o valor implícito atribuído ao argumento\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SMXncQJJp2Ct",
        "colab_type": "code",
        "outputId": "bdbfa291-667b-4971-eff2-094f0488c7ab",
        "colab": {}
      },
      "source": [
        "implicitadd(4,4)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0QsJtqAjp2C6",
        "colab_type": "text"
      },
      "source": [
        "##Múltiplos Argumentos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SduURp1jp2C7",
        "colab_type": "text"
      },
      "source": [
        "Se o número de argumentos a serem aceitos por uma função não for conhecido, um símbolo de asterisco será usado antes do argumento.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZXppCyE_p2C7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def add_n(*args):\n",
        "    res = 0\n",
        "    reslist = []\n",
        "    for i in args:\n",
        "        reslist.append(i)\n",
        "    print reslist\n",
        "    return sum(reslist)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CP-AQX47p2C-",
        "colab_type": "text"
      },
      "source": [
        "A função acima aceita qualquer número de argumentos, define uma lista e acrescenta todos os argumentos a essa lista e retorna a soma de todos os argumentos.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0cKrjpWdp2C-",
        "colab_type": "code",
        "outputId": "2907054f-abe8-4c1f-fefb-ff5b64c72ee4",
        "colab": {}
      },
      "source": [
        "add_n(1,2,3,4,5)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "15"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MVXtmN-4p2DC",
        "colab_type": "code",
        "outputId": "f9a1fe8d-46df-482e-fef8-66abd18e281e",
        "colab": {}
      },
      "source": [
        "add_n(1,2,3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fYicM0CUp2DF",
        "colab_type": "text"
      },
      "source": [
        "##Variáveis locais e globais"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4bFpoduTp2DH",
        "colab_type": "text"
      },
      "source": [
        "Qualquer variável que seja declarada dentro de uma função é variável local e fora da função na variável global.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8vLNkor-p2DI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "eg1 = [1,2,3,4,5]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "goGSkn9Ep2DL",
        "colab_type": "text"
      },
      "source": [
        "Na função abaixo, estamos anexando um elemento à lista declarada dentro da função. A variável eg2 declarada dentro da função é uma variável local.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jenvjv6tp2DM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "64950567-90a6-4ec9-90cb-4bc34ec24311"
      },
      "source": [
        "def egfunc1():\n",
        "    def thirdfunc(arg1):\n",
        "        eg2 = arg1[:]\n",
        "        eg2.append(6)\n",
        "        print \"Isso acontece dentro da função :\", eg2 \n",
        "    print \"Isso acontece antes da função ser chamada : \", eg1\n",
        "    thirdfunc(eg1)\n",
        "    print \"Isso acontece fora da função :\", eg1   \n",
        "    print \"Tentando acessar uma variável declarada dentro da função, fora dela :\" , eg2"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KbZoFTpwp2DO",
        "colab_type": "code",
        "outputId": "4eceb086-a7d2-481b-b9ff-ed63753a42bc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 317
        }
      },
      "source": [
        "egfunc1()"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Isso acontece antes da função ser chamada :  [1, 2, 3, 4, 5]\n",
            "Isso acontece dentro da função : [1, 2, 3, 4, 5, 6]\n",
            "Isso acontece fora da função : [1, 2, 3, 4, 5]\n",
            "Tentando acessar uma variável declarada dentro da função, fora dela :"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m\u001b[0m",
            "\u001b[0;31mNameError\u001b[0mTraceback (most recent call last)",
            "\u001b[0;32m<ipython-input-22-a0aede218e7c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0megfunc1\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-21-002c6a343f2b>\u001b[0m in \u001b[0;36megfunc1\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0mthirdfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0meg1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0;32mprint\u001b[0m \u001b[0;34m\"Isso acontece fora da função :\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meg1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m     \u001b[0;32mprint\u001b[0m \u001b[0;34m\"Tentando acessar uma variável declarada dentro da função, fora dela :\"\u001b[0m \u001b[0;34m,\u001b[0m \u001b[0meg2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: global name 'eg2' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "seoHInv8p2DS",
        "colab_type": "text"
      },
      "source": [
        "Se uma variável **global** é definida como mostrado no exemplo abaixo, então essa variável pode ser chamada de qualquer lugar.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "immsVaH8p2DS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "eg3 = [1,2,3,4,5]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WsmXKa8Ap2DV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def egfunc1():\n",
        "    def thirdfunc(arg1):\n",
        "        global eg2\n",
        "        eg2 = arg1[:]\n",
        "        eg2.append(6)\n",
        "        print \"Isso acontece dentro da função :\", eg2 \n",
        "    print \"Isso acontece antes da função ser chamada : \", eg1\n",
        "    thirdfunc(eg1)\n",
        "    print \"Isso acontece fora da função :\", eg1   \n",
        "    print \"Tentando acessar uma variável declarada dentro da função, fora dela :\" , eg2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bdl3waWkp2DZ",
        "colab_type": "code",
        "outputId": "380c8a6a-f78c-4e2d-a95b-7b5928cf4b77",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        }
      },
      "source": [
        "egfunc1()"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Isso acontece antes da função ser chamada :  [1, 2, 3, 4, 5]\n",
            "Isso acontece dentro da função : [1, 2, 3, 4, 5, 6]\n",
            "Isso acontece fora da função : [1, 2, 3, 4, 5]\n",
            "Tentando acessar uma variável declarada dentro da função, fora dela : [1, 2, 3, 4, 5, 6]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z7N8px8Up2Dg",
        "colab_type": "text"
      },
      "source": [
        "##Funções Lambda"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SfIPASlfp2Dh",
        "colab_type": "text"
      },
      "source": [
        "Estas são pequenas funções que não são definidas com nenhum nome e possuem uma única expressão cujo resultado é retornado. As funções do Lambda são muito úteis quando operam com listas. Essas funções são definidas pela palavra-chave **lambda** seguida pelas variáveis, dois pontos e a respectiva expressão.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yKrJTXqQwNhT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1o4ZyqZcp2Di",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "z = lambda x: x * x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "otBMuoEvp2Dr",
        "colab_type": "code",
        "outputId": "5ef28c77-92b4-4790-ff79-1f50ab7be461",
        "colab": {}
      },
      "source": [
        "z(8)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qm6BrbUup2Dv",
        "colab_type": "text"
      },
      "source": [
        "###map"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gBjLy8evp2Dx",
        "colab_type": "text"
      },
      "source": [
        "**map( )** basicamente executa a função que é definida para cada elemento da lista separadamente.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ZSrPiKyp2Dy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "list1 = [1,2,3,4,5,6,7,8,9]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J16Bhi6ap2D2",
        "colab_type": "code",
        "outputId": "097bbfd9-d9cc-497e-c59b-4631d8a54f59",
        "colab": {}
      },
      "source": [
        "eg = map(lambda x:x+2, list1)\n",
        "print eg"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3, 4, 5, 6, 7, 8, 9, 10, 11]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eVOGECSsp2D7",
        "colab_type": "text"
      },
      "source": [
        "Você pode adicionar somar duas listas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E029vlNup2D8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "list2 = [9,8,7,6,5,4,3,2,1]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-qxlrJEjp2EA",
        "colab_type": "code",
        "outputId": "062705b5-7672-4ee6-b34b-4b6ad7ff86fd",
        "colab": {}
      },
      "source": [
        "eg2 = map(lambda x,y:x+y, list1,list2)\n",
        "print eg2"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[10, 10, 10, 10, 10, 10, 10, 10, 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "E8ItTnivp2EF",
        "colab_type": "text"
      },
      "source": [
        "Pode usar qualquer tipo de função padrão , não somente lambda"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Mw2hW3Wp2EF",
        "colab_type": "code",
        "outputId": "bbc9850e-96a9-4c2f-8d89-72a07e85c6e7",
        "colab": {}
      },
      "source": [
        "eg3 = map(str,eg2)\n",
        "print eg3"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['10', '10', '10', '10', '10', '10', '10', '10', '10']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UjmSPC2vp2EI",
        "colab_type": "text"
      },
      "source": [
        "###filter"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "amF6JXiQp2EJ",
        "colab_type": "text"
      },
      "source": [
        "**filter( )** é usada para filtrar os valores em uma lista. Observe que a função **filter ()** retorna o resultado em uma nova lista."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HjMDZr1yp2EL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "list1 = [1,2,3,4,5,6,7,8,9]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "47w4Oi60p2EN",
        "colab_type": "text"
      },
      "source": [
        "Elementos menores que 5:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KknZ-Ynrp2EN",
        "colab_type": "code",
        "outputId": "d2382d11-abfd-4982-e9c6-78fad26a0118",
        "colab": {}
      },
      "source": [
        "filter(lambda x:x<5,list1)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X8MqoMV-p2ES",
        "colab_type": "text"
      },
      "source": [
        "Veja o que acontece quando **map()** é usado nesse caso"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5vjjC6dBp2ET",
        "colab_type": "code",
        "outputId": "4d99912b-083a-40c4-b737-82c1b1290b08",
        "colab": {}
      },
      "source": [
        "map(lambda x:x<5, list1)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[True, True, True, True, False, False, False, False, False]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pJIRgM-8p2Ea",
        "colab_type": "text"
      },
      "source": [
        "Podemos concluir que, seja o que for que seja retornado verdadeiro na função **map ()**, esse elemento em particular é retornado quando a função **filter ()** é usada.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wp3k9PDAp2Eb",
        "colab_type": "code",
        "outputId": "82a9ee2d-0f1d-4fed-feb9-1f7b65fbdef1",
        "colab": {}
      },
      "source": [
        "filter(lambda x:x%4==0,list1)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[4, 8]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    }
  ]
}