feat: adição seção funções lambda

book/08-funcoes/01-introducao.ipynb

@@ -687,6 +687,139 @@
     "salario_joao = calcular_salario(base=3000, vale_refeicao=500, plano_saude=200)\n",
     "```"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Funções anônimas"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Agora que já aprendemos o básico sobre funções, vamos falar sobre um tipo especial de função chamado de função anônima.\n",
+    "\n",
+    "Quando criamos uma função conforme mostrei acima, usando `def`, estamos criando uma função nomeada na memória do computador. Vou apresentar um exemplo mais simples somente para fins didáticos:\n",
+    "\n",
+    "```python\n",
+    "def dobro(numero: int) -> int:\n",
+    "    return numero * 2\n",
+    "```\n",
+    "\n",
+    "Quando executamos o código acima, ele literalmente cria algo na memória do computador que fica disponível para quando quisermos usar. Prova disso é que podemos imprimir a função (somente o objeto da função, sem chamá-la) e ver o que ela é:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<function dobro at 0x00000235A026ECA0>\n"
+     ]
+    }
+   ],
+   "source": [
+    "def dobro(numero: int) -> int:\n",
+    "    return numero * 2\n",
+    "\n",
+    "\n",
+    "print(dobro)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```{admonition} Nota (objetos de função vs execução da função) \n",
+    ":class: note\n",
+    "Reparem que usando apenas `dobro`, eu estou imprimindo o objeto da função, e não chamando a função com `()`. É diferente de `dobro(10)` que é a execução da função. A execução em si requer a passagem dos parâmetros obrigatórios.\n",
+    "```\n",
+    "O código acima mostra algo do tipo `<function dobro at 0x00000235A026ECA0>` que representa o endereço de memória onde a função `dobro` foi armazenada. Isso é o que chamamos de função nomeada. \n",
+    "\n",
+    "Existe, porém, um outro tipo de função que é chamada de função anônima, ou lambda. Ela é uma função que não é armazenada na memória do computador, existindo só durante a execução do código. Quando as funções são mais simples, com apenas uma linha. Vamos construir o mesmo exemplo da função `dobro` acima, mas agora usando uma função anônima:\n",
+    "\n",
+    "```python\n",
+    "lambda x: x * 2\n",
+    "```\n",
+    "\n",
+    "Percebam que a função anônima é bem mais simples e direta, sem a necessidade de usar `def` e `return`. A função anônima é criada usando a palavra reservada `lambda`, seguida dos parâmetros e do que a função faz. Os valores à esquerda dos `:` representam os parâmetros de entrada separados por `,`, e à direita, o valor retornado pela função. No caso acima, a função anônima recebe um parâmetro `x` e retorna o dobro dele, `x * 2`.\n",
+    "\n",
+    "É possível criar uma função lambda que recebe mais de um parâmetro, como no exemplo abaixo:\n",
+    "\n",
+    "```python\n",
+    "lambda x, y: x + y\n",
+    "```\n",
+    "\n",
+    "A função anônima é muito útil quando você precisa de uma função simples e rápida, e não quer criar uma função nomeada.\n",
+    "\n",
+    "Vamos aplicar ambas as funções para dobrar os valores de uma dada lista de números. Primeiro, vamos usar a função nomeada `dobro`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2, 4, 6, 8, 10, 12, 14]\n"
+     ]
+    }
+   ],
+   "source": [
+    "lista_numeros = [1, 2, 3, 4, 5, 6, 7]  # 1\n",
+    "\n",
+    "\n",
+    "def dobro(numero: int) -> int:  # 2\n",
+    "    return numero * 2\n",
+    "\n",
+    "\n",
+    "valores_dobrados = list(map(dobro, lista_numeros))  # 3\n",
+    "\n",
+    "print(valores_dobrados)  # 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "No exemplo acima, nós:\n",
+    "\n",
+    "1. Criamos uma lista de números\n",
+    "2. Definimos a função `dobro` como uma função nomeada que recebe um parâmetro `numero` e retorna o dobro dele.\n",
+    "3. Aplicamos a função `dobro` a cada elemento da lista usando a função `map()`, que aplica uma função a todos os elementos de uma sequência. Aqui a função `dobro` é passada como parâmetro para `map()`. Transformamos o resultado do `map()` em uma lista para visualização.\n",
+    "4. Imprimimos a lista com os valores dobrados.\n",
+    "\n",
+    "Agora vamos ver o mesmo exemplo, mas usando a função anônima:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lista_numeros = [1, 2, 3, 4, 5, 6, 7]\n",
+    "\n",
+    "valores_dobrados = list(map(lambda x: x * 2, lista_numeros))\n",
+    "\n",
+    "print(valores_dobrados)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Basicamente, ao invés de definir a função e usá-la, nós usamos a função anônima diretamente dentro do `map()`, sem precisar criar uma função nomeada. A função anônima é mais simples e direta, e é muito usada em situações onde você precisa de uma função simples (funções de uma única linha)."
+   ]
   }
  ],
  "metadata": {