From 0f64df73d6243283c769521659fe8c02ae7ba73e Mon Sep 17 00:00:00 2001 From: Henrique Branco Date: Wed, 18 Sep 2024 07:45:09 -0300 Subject: [PATCH] =?UTF-8?q?feat:=20adi=C3=A7=C3=A3o=20se=C3=A7=C3=A3o=20fu?= =?UTF-8?q?n=C3=A7=C3=B5es=20lambda?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- book/08-funcoes/01-introducao.ipynb | 133 ++++++++++++++++++++++++++++ 1 file changed, 133 insertions(+) diff --git a/book/08-funcoes/01-introducao.ipynb b/book/08-funcoes/01-introducao.ipynb index 922a750..f1b554a 100644 --- a/book/08-funcoes/01-introducao.ipynb +++ b/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": [ + "\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 `` 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": {