ipynb/Capitulo-06.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Capítulo 06 - Funções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Abstraindo:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Em Python, uma **função** é uma sequência de comandos que executa alguma tarefa e que tem um nome."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- É uma técnica de programação que nos permite pensar num problema em diversos níveis.\n",
    "- A idéia é que quando estamos pensando num problema macroscopicamente, não estamos preocupados com minúcias."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Dividir para conquistar:\n",
    " - Um problema é dividido em diversos sub-problemas.\n",
    " - As soluções dos sub-programas são combinadas numa solução do problema maior."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Contextualizando um pouco:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Programação Estruturada"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "- É um paradigma de programação, no qual se incorpora o conceito de \"Dividir e conquistar\".\n",
    "  - Programação Orientada a Objetos é outra coisa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Programas são divididos em sub-programas\n",
    "  - Cada sub-programa é invocado por meio de um identificador e uma lista de entradas.\n",
    "  - Permitir especificar como um problema pode ser resolvido em geral.\n",
    "  - O mesmo sub-programa pode ser invocado para resolver diversos problemas de mesma natureza, mas com valores específicos diferentes.\n",
    "  - Os resultados computados por um sub-programa pode ser combinado com os de outros sub-programas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 6.1. Estrutura de uma função"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Em Python, sub-programas têm nome de **funções**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Formato de uma função:**\n",
    "\n",
    "```python\n",
    "def nome_da_função(arg, arg, ..., arg):\n",
    "    comando\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "    comando\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Onde:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- *`nome`* é o nome da função\n",
    "- *`args`* são especificações de argumentos da função\n",
    "  - Uma função pode ter 0, 1 ou mais argumentos\n",
    "- *`comandos`* contêm as instruções a serem executadas quando a função é invocada"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Podemos dar qualquer nome para uma função, desde que esse nome não seja uma palavra reservada em python.\n",
    "E os nomes devem seguir a regra de identificadores permitido e de boas práticas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python vem com diversar bibliotecas padrão, nas quais chamamos de **baterias incluídas** ou (Bibliotecas padrão)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Podemos criar uma função para atender a um problema específico, ou usar um das diversas funções embutidas na biblioteca padrão.\n",
    "\n",
    "Um exemplo simples de função embutica, é a **função** `abs()`.\n",
    "\n",
    "`abs()` recebe um valor numérico e devolve seu valor absoluto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Abaixo temos uma lista de algumas funções inclusas na linguagem.\n",
    "\n",
    "![figura-6.0](../images/figura-6.0.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "### 6.2. Funções que retornam algo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Uma função tipicamente computa um ou mais valores\n",
    "- Para indicar o valor a ser devolvido como o resultado da função, usa-se o comando `return` que tem o formato `return expressão`.\n",
    "- Ao encontrar o comando `return`, a função termina imediatamente e o controle do programa volta ao ponto onde a função foi chamada.\n",
    "- Se uma função chega ao seu fim sem nenhum valor de retorno ter sido especificado, o valor de retorno é **None**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exemplos:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def função():\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(função())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def saudação(): \n",
    "    return 'Olá'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Olá'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "saudação()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def saudação(nome):\n",
    "    return \"Olá %s\" % nome "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Olá Fábio'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "saudação('Fábio')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 6.3. Variáveis locais e globais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Variáveis definidas em funções são **locais**, isto é, só podem ser usadas nas funções em que foram definidas.\n",
    "- Variáveis definidas fora das funções são conhecidadas com **variáveis globais**\n",
    "  - É possível no código de uma função ler o conteúdo de uma variável global\n",
    "  - Para alterar uma variável global, ela precisa se declarada no corpo da função usando o comado *`global`*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exemplos:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def função():\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "função()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def função():\n",
    "    a = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "função()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def função():\n",
    "    global a\n",
    "    a = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "função()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 6.4.  Argumentos (ou parâmetros) de funções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Argumentos (ou parâmetros) são como variáveis que recebem seus valores iniciais do chamador.\n",
    "- Essas variáveis, assim como outras definidas dentro da função, são ditas **locais**, isto é, só existem no lugar onde foram definidas.\n",
    "  - Ao retornar ao ponto de chamada, as variáveis locais são descartadas.\n",
    "- Se uma função define `n` argumentos, valores para todos eles devem ser passados pelo chamado\n",
    "  - Exceção: argumentos com valores default."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exemplos:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def função(x): return x*x  # quando uma função é pequena, podemos simplificar em uma linha apenas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "print(função(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'x' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-66-fc17d851ef81>\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[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Argumentos default:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- É possível dar valores *`default`* a argumentos\n",
    "  - Se o chamador não especificar os valores para esses argumentos, os default são usados.\n",
    "- Formato:\n",
    "  - `def nome(arg=default1, ..., argN=defaultN)`\n",
    "- Se apenas alguns argumentos têm default, esses devem ser os últimos\n",
    "  - Se não fosse assim, haveria ambigüidade na passagem de argumentos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exemplos:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def função(nome, saudação=\"Oi\", pontuação=\"!!!\"):\n",
    "    return saudação+\", \"+nome+pontuação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Oi, Fábio!!!'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "função(\"Fábio\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Oh, Fábio!!!'"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "função(\"Fábio\", \"Oh\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Funções definidas em funções:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Funções podem ser definidas dentro de funções.\n",
    "- Se um função **g** é definida dentro de uma função **f**, ela tem acesso ao seu próprio escopo (em primeiro luga) e também ao escopo de **f**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exemplo:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def função(x):\n",
    "    def g(y): return x*y\n",
    "    return g(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "função(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 6.5. Documentação de uma função (docstrings):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Ao invés de usar comentários para descrever o que uma função, é mais vantajoso usar **docstrings**.\n",
    "\n",
    "Docstrings são strings multilinha, delimitadas por `\"\"\"três aspas\"\"\"`. Quando colocadas na primeira linha da declaração de uma função (abaixo do comando def) elas ganham função especial e são interpretadas como strings de documentação.\n",
    "\n",
    "Permite o acesso à documentação a partir do interpretador, usando a notação `função.__doc__` ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Em Python, uma documentação deve indicar o que o código faz, não como ele funciona.\n",
    "\n",
    "Algumas convenções no uso de docstrings são discutidas na [PEP 257](https://www.python.org/dev/peps/pep-0257/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exemplos de Docstrings:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Usadas para funções cuja funcionalidade é óbvia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def double(x):\n",
    "    \"\"\"Retorna o dobro de x.\"\"\"\n",
    "    return x * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Acessando a documentação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Retorna o dobro de x.'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "double.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def fatorial(n):\n",
    "    \"\"\"Retorna o fatorial de n.\"\"\"\n",
    "    for i in range(n -1 , 1, -1): n*= i\n",
    "    return n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Retorna o fatorial de n.'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fatorial.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Docstrings multilinha:**\n",
    "\n",
    "Usadas quando é necessária uma descrição mais elaborada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def word_counter(words):\n",
    "    \"\"\" \n",
    "    Conta quantas vezes uma palavra se repete\n",
    "    :param words: lista de palavras.\n",
    "    :return: dicionário de palavras com a quantidade de vezes \n",
    "    que uma palavra foi repetida.\n",
    "    \"\"\"\n",
    "    \n",
    "    count = 0\n",
    "    word_dict = {}\n",
    "    for word in words:\n",
    "        if word not in word_dict:\n",
    "            word_dict[word] = 1\n",
    "            count += 1\n",
    "        else:\n",
    "            word_dict[word] += 1\n",
    "    return word_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "words = ['banana', 'cebolinha', 'mamão', 'melancia', 'cebola', \n",
    "         'pessego', 'abacate', 'uva', 'mamão', 'hortelã', \n",
    "         'couve', 'banana', 'alho', 'maçã', 'beterraba',\n",
    "         'cenoura', 'alface', 'salsinha', 'salsa', 'pimentão', \n",
    "         'pimenta-do-reino', 'alecrin', 'banana', 'cebola', 'uva']\n",
    "word_dict = word_counter(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'cebola': 2, 'pimentão': 1, 'uva': 2, 'maçã': 1, 'beterraba': 1, 'cebolinha': 1, 'banana': 3, 'pessego': 1, 'alecrin': 1, 'alho': 1, 'cenoura': 1, 'salsa': 1, 'alface': 1, 'mamão': 2, 'melancia': 1, 'couve': 1, 'pimenta-do-reino': 1, 'salsinha': 1, 'hortelã': 1, 'abacate': 1}\n"
     ]
    }
   ],
   "source": [
    "print(word_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Documentação:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' \\n    Conta quantas vezes uma palavra se repete\\n    :param words: lista de palavras.\\n    :return: dicionário de palavras com a quantidade de vezes \\n    que uma palavra foi repetida.\\n    '"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_counter.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 6.6. Escopo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Escopo é o nome que se dá ao conjunto de nomes acessíveis de um determinado ponto de um programa.\n",
    "  - Também é chamado de *espaço de nomes* ou *namespace*\n",
    "- Um programa começa em um escopo (chamado escopo global), enquanto que cada função acrescenta um escopo próprio (local)\n",
    "  - Módulos e classes também definem escopos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Ao se fazer acesso a um nome, todos os escopos, do mais interno para o mais externo, são consultados.\n",
    "- Isto explica por que definir uma variável numa função pode fazer com que uma variável global deixe de ser acessível."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div align='center'>\n",
    "   <a href='../ipynb/Capitulo-05.ipynb#/slide-0-0' style=\"padding-right: 2em;\"><i class=\"fa fa-angle-double-left\"></i> Estrutura de Dados</a>\n",
    "   <a href='../ipynb/Capitulo-07.ipynb#/slide-0-0'>Bibliografia <i class=\"fa fa-angle-double-right\"></i></a>\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}