Functions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f4b9cee3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "17\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "#Funções\n",
    "\n",
    "\"\"\"\n",
    "Em programação, uma função é um bloco de código que realiza uma tarefa \n",
    "específica e pode ser executado várias vezes em diferentes partes do \n",
    "programa. As funções ajudam a organizar e modularizar o código, \n",
    "tornando-o mais legível, reutilizável e fácil de manter.\n",
    "\"\"\"\n",
    "\n",
    "#Criando uma função de soma\n",
    "def soma(a, b):\n",
    "    return a + b\n",
    "\n",
    "resultado = soma(2, 3)\n",
    "print(resultado)  # Saída: 5\n",
    "\n",
    "resultado = soma(8, 9)\n",
    "print(resultado)  # Saída: 5\n",
    "\n",
    "resultado = soma(3, 7)\n",
    "print(resultado)  # Saída: 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e597ebc8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b2a15346",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite o primeiro número: 5\n",
      "Digite o segundo número: 15\n",
      "A soma é: 20\n"
     ]
    }
   ],
   "source": [
    "#Criando uma função de soma\n",
    "def soma(a, b):\n",
    "    return a + b\n",
    "\n",
    "numero1 = int(input(\"Digite o primeiro número: \"))\n",
    "numero2 = int(input(\"Digite o segundo número: \"))\n",
    "\n",
    "resultado = soma(numero1, numero2)\n",
    "print(\"A soma é:\", resultado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21be5791",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "96de803c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, Maria! Bem-vindo(a)!\n"
     ]
    }
   ],
   "source": [
    "#Parâmetros e Argumentos em uma função\n",
    "def saudacao(nome):\n",
    "    \"\"\"Função que exibe uma saudação personalizada.\"\"\"\n",
    "    print(\"Olá, \" + nome + \"! Bem-vindo(a)!\")\n",
    "\n",
    "# Argumento passado para a função\n",
    "nome_usuario = \"Maria\"\n",
    "\n",
    "# Chamada da função com o argumento\n",
    "saudacao(nome_usuario)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "762f7136",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "3cf11f58",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nome: João\n",
      "Idade: 25\n",
      "Cidade: São Paulo\n",
      "\n",
      "Nome: Maria\n",
      "Idade: 30\n",
      "Cidade: Desconhecida\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Argumentos Default e Non-default\n",
    "\n",
    "\"\"\"\n",
    "Em Python, ao definir uma função, você pode atribuir valores \n",
    "padrão aos parâmetros da função. Esses valores padrão são chamados de \n",
    "\"argumentos default\" (padrão) e permitem que você chame a função sem precisar \n",
    "fornecer valores para esses parâmetros, pois eles já têm um valor pré-definido.\n",
    "\n",
    "Por outro lado, os \"argumentos non-default\" (não padrão) são aqueles que não \n",
    "possuem um valor padrão atribuído na definição da função e, portanto, precisam ser \n",
    "fornecidos como argumentos quando a função é chamada.\n",
    "\"\"\"\n",
    "\n",
    "def exibir_informacoes(nome=\"Allan\", idade=39, cidade=\"Desconhecida\"):\n",
    "    \n",
    "    \"\"\"Função que exibe informações pessoais.\"\"\"\n",
    "    print(\"Nome:\", nome)\n",
    "    print(\"Idade:\", idade)\n",
    "    print(\"Cidade:\", cidade)\n",
    "    print()\n",
    "\n",
    "# Argumentos sem valores default\n",
    "exibir_informacoes(\"João\", 25, \"São Paulo\")\n",
    "\n",
    "# Argumento com valor default\n",
    "exibir_informacoes(\"Maria\", 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "066bda8d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "83e71120",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, João! Bem-vindo(a) ao nosso programa.\n",
      "O resultado da soma é: 7\n"
     ]
    }
   ],
   "source": [
    "#Exemplo com print():\n",
    "def saudacao(nome):\n",
    "    \n",
    "    \"\"\"Função que imprime uma saudação personalizada.\"\"\"\n",
    "    print(\"Olá, \" + nome + \"! Bem-vindo(a) ao nosso programa.\")\n",
    "\n",
    "saudacao(\"João\")\n",
    "\n",
    "#Exemplo com return:\n",
    "def soma(a, b):\n",
    "    \n",
    "    \"\"\"Função que retorna a soma de dois números.\"\"\"\n",
    "    return a + b\n",
    "\n",
    "resultado = soma(3, 4)\n",
    "print(\"O resultado da soma é:\", resultado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce9f4e53",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "62d33a23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A soma dos números é: 30\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Vários argumentos *args com números\n",
    "\n",
    "\"\"\"\n",
    " parâmetro especial *args, que permite receber um número variável de argumentos numéricos. \n",
    " Dentro da função, os argumentos são tratados como uma tupla.\n",
    "\"\"\"\n",
    "\n",
    "def soma(*args):\n",
    "    \n",
    "    \"\"\"Função que retorna a soma de vários números.\"\"\"\n",
    "    resultado = sum(args)\n",
    "    return resultado\n",
    "\n",
    "total = soma(2, 4, 6, 8, 10)\n",
    "print(\"A soma dos números é:\", total)\n",
    "\n",
    "\"\"\"\n",
    "Dessa forma, a função soma() é capaz de lidar com qualquer quantidade de argumentos \n",
    "numéricos e retorna a soma total desses números.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fd1ccff",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "191500b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite uma sequência de números separados por espaços: 10 5 8 9\n",
      "Média: 8.0\n",
      "Maior Número: 10.0\n",
      "Menor Número: 5.0\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Função para Calcular Estatísticas de Números\n",
    "\n",
    "Objetivo: Familiarizar com a definição de funções que \n",
    "aceitem um número variável de argumentos usando *args, bem como calcular \n",
    "algumas estatísticas básicas de um conjunto de números.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Defina uma função chamada estatisticas que aceite \n",
    "    um número variável de argumentos numéricos.\n",
    "    \n",
    "    2. A função deve retornar a média, o maior e o menor número do conjunto.\n",
    "    3. Peça ao usuário para inserir uma sequência de números, separados por espaços.\n",
    "    4. Converta essa entrada do usuário em uma lista de números.\n",
    "    5. Use a função estatisticas para calcular a média, o maior e o menor número da lista.\n",
    "    6. Mostre ao usuário a média, o maior e o menor número.\n",
    "\"\"\"\n",
    "\n",
    "def estatisticas(*args):\n",
    "    \n",
    "    return sum(args) / len(args), max(args), min(args)\n",
    "\n",
    "\"\"\"\n",
    "input(\"Digite uma sequência de números separados por espaços: \"): A função \n",
    "input() é usada para obter uma entrada do usuário no console. Nesse caso, a \n",
    "mensagem \"Digite uma sequência de números separados por espaços: \" é exibida para \n",
    "o usuário, pedindo que ele insira uma sequência de números separados por espaços.\n",
    "\n",
    ".split(): O método split() é chamado na string de entrada fornecida pelo \n",
    "usuário. Ele divide a string em partes separadas por espaços em branco, criando \n",
    "uma lista de strings.\n",
    "\n",
    "map(float, ...): A função map() é usada para aplicar a função \n",
    "float() a cada elemento da lista de strings. A função float() é responsável \n",
    "por converter uma string que representa um número em um número de ponto \n",
    "flutuante (float). Isso é feito para garantir que todos os números da sequência \n",
    "digitada sejam tratados como valores numéricos de ponto flutuante.\n",
    "\n",
    "list(...) : O resultado da função map(float, ...) é convertido em uma lista de \n",
    "números de ponto flutuante. Agora, a variável numeros é uma lista contendo os \n",
    "números digitados pelo usuário, convertidos em valores de ponto flutuante.\n",
    "\n",
    "Depois disso, a função estatisticas(*numeros) é chamada com a lista de números \n",
    "numeros desempacotada usando o operador *. A função estatisticas calcula a média, o \n",
    "maior e o menor número da sequência e retorna esses valores.\n",
    "\n",
    "Finalmente, os resultados são impressos na tela usando a função print() para \n",
    "mostrar a média, o maior e o menor número da sequência digitada pelo usuário.\n",
    "\"\"\"\n",
    "numeros = list(map(float, input(\"Digite uma sequência de números separados por espaços: \").split()))\n",
    "\n",
    "media, maior, menor = estatisticas(*numeros)\n",
    "\n",
    "print(f\"Média: {media}\")\n",
    "print(f\"Maior Número: {maior}\")\n",
    "print(f\"Menor Número: {menor}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68577686",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ab5d4c01",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nome: João\n",
      "idade: 25\n",
      "cidade: São Paulo\n",
      "sexo: Masculino\n"
     ]
    }
   ],
   "source": [
    "#Vários argumentos xargs nomeando parametros\n",
    "\n",
    "#função que recebe vários argumentos nomeados usando **kwargs:\n",
    "\n",
    "\"\"\"\n",
    "Em Python, **kwargs é um parâmetro especial usado em definições de função \n",
    "para capturar argumentos nomeados extras passados para a função. \n",
    "O termo \"kwargs\" é uma convenção comumente usada, mas o nome em si pode ser \n",
    "qualquer outro desde que seja precedido por dois asteriscos (**).\n",
    "\n",
    "O parâmetro **kwargs permite que uma função aceite um número variável \n",
    "de argumentos nomeados adicionais. Os argumentos nomeados extras são \n",
    "passados para a função como um dicionário, onde as chaves são os nomes \n",
    "dos argumentos e os valores são os valores atribuídos a esses argumentos.\n",
    "\"\"\"\n",
    "\n",
    "def exibir_informacoes(**teste):\n",
    "    \n",
    "    \"\"\"Função que exibe informações pessoais\"\"\"\n",
    "    for chave, valor in teste.items():\n",
    "        print(chave + \": \" + str(valor))\n",
    "        \n",
    "exibir_informacoes(nome=\"João\", idade=25, cidade=\"São Paulo\", sexo=\"Masculino\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67638a78",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "26ee4d95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eu sou uma variável local\n",
      "Eu sou uma variável global\n",
      "Eu sou uma variável global\n",
      "1\n",
      "2\n",
      "3\n",
      "\n",
      "---------------------------\n",
      "\n",
      "Eu sou externa\n",
      "Eu fui modificada pela função interna\n",
      "Eu fui modificada pela função interna\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Escopo de Variáveis\n",
    "o\tVariáveis locais vs. globais\n",
    "o\tUso do global\n",
    "o\tUso do nonlocal (em funções aninhadas)\n",
    "\n",
    "\n",
    "Variáveis Locais vs. Globais\n",
    "\n",
    "Uma variável definida dentro de uma função é chamada de \n",
    "variável local, enquanto uma definida fora de todas as funções é \n",
    "chamada de variável global.\n",
    "\"\"\"\n",
    "\n",
    "# Definindo uma variável global fora de qualquer função\n",
    "variavel_global = \"Eu sou uma variável global\"\n",
    "\n",
    "# Definindo a função funcao_exemplo\n",
    "def funcao_exemplo():\n",
    "    \n",
    "    # Criando uma variável local dentro da função\n",
    "    variavel_local = \"Eu sou uma variável local\"\n",
    "    \n",
    "    # Imprimindo a variável local\n",
    "    print(variavel_local)\n",
    "    \n",
    "    # Imprimindo a variável global dentro da função (é possível acessá-la, mas \n",
    "    # para modificá-la, precisaríamos usar a palavra-chave 'global')\n",
    "    print(variavel_global)\n",
    "    \n",
    "\n",
    "# Chamando a função funcao_exemplo, que imprimirá ambas as variáveis\n",
    "funcao_exemplo()\n",
    "\n",
    "# Imprimindo a variável global fora da função\n",
    "print(variavel_global)\n",
    "\n",
    "# print(variavel_local)  # Isso resultaria em um erro, pois variavel_local não existe fora da função.\n",
    "\n",
    "\"\"\"\n",
    "Uso do global\n",
    "\n",
    "Para modificar uma variável global dentro de uma função, você \n",
    "precisa usar a palavra-chave global:\n",
    "\"\"\"\n",
    "\n",
    "# Definindo uma variável global chamada 'contador' e inicializando com 0\n",
    "contador = 0\n",
    "\n",
    "\n",
    "# Definindo a função 'incrementar_contador'\n",
    "def incrementar_contador():\n",
    "    \n",
    "    # Informando à função que vamos usar a variável global 'contador' e não uma variável local\n",
    "    global contador\n",
    "    \n",
    "    # Incrementando o valor da variável global 'contador'\n",
    "    # contador = contador + 1\n",
    "    contador += 1\n",
    "    \n",
    "    # Imprimindo o valor atualizado de 'contador'\n",
    "    print(contador)\n",
    "\n",
    "# Chamando a função 'incrementar_contador' pela primeira vez\n",
    "# Isso incrementa 'contador' para 1 e imprime o valor\n",
    "incrementar_contador()  # Imprime 1\n",
    "\n",
    "# Chamando a função 'incrementar_contador' novamente\n",
    "# Agora, 'contador' é incrementado para 2 e o novo valor é impresso\n",
    "incrementar_contador()  # Imprime 2\n",
    "\n",
    "incrementar_contador()  # Imprime 3\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Uso do nonlocal (em funções aninhadas)\n",
    "\n",
    "A palavra-chave nonlocal é usada para trabalhar com variáveis em um \n",
    "escopo mais próximo, mas não global, como em funções aninhadas:\n",
    "\"\"\"\n",
    "\n",
    "print(\"\\n---------------------------\\n\")\n",
    "\n",
    "# Definindo a função 'funcao_externa'\n",
    "def funcao_externa():\n",
    "    \n",
    "    # Criando uma variável 'variavel_externa' dentro do escopo da 'funcao_externa'\n",
    "    variavel_externa = \"Eu sou externa\"\n",
    "    \n",
    "    # Definindo uma função aninhada chamada 'funcao_interna' dentro de 'funcao_externa'\n",
    "    def funcao_interna():\n",
    "        \n",
    "        # Usando a palavra-chave 'nonlocal' para indicar que queremos\n",
    "        # modificar a 'variavel_externa' do escopo imediatamente \n",
    "        # superior, ou seja, da 'funcao_externa'\n",
    "        nonlocal variavel_externa\n",
    "        \n",
    "        print(variavel_externa)\n",
    "        \n",
    "        # Modificando a 'variavel_externa'\n",
    "        variavel_externa = \"Eu fui modificada pela função interna\"\n",
    "        \n",
    "        # Imprimindo a 'variavel_externa' após modificá-la\n",
    "        print(variavel_externa)\n",
    "        \n",
    "    # Chamando a 'funcao_interna' dentro da 'funcao_externa', que \n",
    "    # por sua vez modifica e imprime a 'variavel_externa'\n",
    "    funcao_interna()\n",
    "    \n",
    "    # Imprimindo a 'variavel_externa' após a 'funcao_interna' \n",
    "    # ter sido chamada e ter modificado seu valor\n",
    "    print(variavel_externa)\n",
    "\n",
    "# Chamando a função 'funcao_externa' para executar o fluxo acima\n",
    "funcao_externa()\n",
    "\n",
    "\"\"\"\n",
    "No exemplo acima, a função funcao_interna modifica a \n",
    "variavel_externa da função funcao_externa usando a palavra-chave nonlocal. \n",
    "\n",
    "Se você não usasse nonlocal, ocorreria um erro, pois estaria tentando \n",
    "modificar uma variável local que não foi definida na função interna.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12d3b2a4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "d0f90af2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, mundo!\n",
      "Olá, Alice!\n",
      "Oi!\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Funções como Objetos de Primeira Classe\n",
    "\n",
    "o\tAtribuindo funções a variáveis\n",
    "o\tPassando funções como argumentos\n",
    "o\tRetornando funções de outras funções\n",
    "\n",
    "Funções são objetos de primeira classe. Isso significa que \n",
    "elas podem ser tratadas como qualquer outro objeto, como strings, listas \n",
    "ou até mesmo classes. \n",
    "\n",
    "Aqui estão exemplos dos três casos mencionados:\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#Atribuindo funções a variáveis:\n",
    "# Definindo uma função simples\n",
    "def saudacao():\n",
    "    \n",
    "    return \"Olá, mundo!\"\n",
    "\n",
    "# Atribuindo a função à variável 'cumprimentar'\n",
    "cumprimentar = saudacao\n",
    "\n",
    "# Chamando a função através da variável\n",
    "print(cumprimentar())  # Saída: Olá, mundo!\n",
    "\n",
    "#---------------------------\n",
    "\n",
    "#Passando funções como argumentos\n",
    "\n",
    "# Definindo duas funções simples\n",
    "def saudacao_nome(nome):\n",
    "    \n",
    "    return f\"Olá, {nome}!\"\n",
    "\n",
    "def cumprimentar(funcao, nome):\n",
    "    \n",
    "    return funcao(nome)\n",
    "\n",
    "# Usando a função 'cumprimentar' e passando 'saudacao_nome' como um argumento\n",
    "print(cumprimentar(saudacao_nome, \"Alice\"))  # Saída: Olá, Alice!\n",
    "\n",
    "#------------------------------\n",
    "\n",
    "\n",
    "#Retornando funções de outras funções\n",
    "\n",
    "# Definindo uma função que retorna outra função\n",
    "def nivel_saudacao(nivel):\n",
    "    \n",
    "    def saudacao_basica():\n",
    "        return \"Oi!\"\n",
    "    \n",
    "    def saudacao_avancada():\n",
    "        return \"Olá, como você está?\"\n",
    "\n",
    "    if nivel == \"basico\":\n",
    "        \n",
    "        return saudacao_basica\n",
    "    \n",
    "    else:\n",
    "        return saudacao_avancada\n",
    "\n",
    "# Chamando a função 'nivel_saudacao' que retorna uma função, e depois chamando a função retornada\n",
    "cumprimento = nivel_saudacao(\"basico\")\n",
    "print(cumprimento())  # Saída: Oi!\n",
    "\n",
    "cumprimento = nivel_saudacao(\"avancado\")\n",
    "print(cumprimento())  # Saída: Olá, como você está?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "152f7400",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "83dfe444",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite o primeiro número: 4\n",
      "Digite o segundo número: 9\n",
      "Escolha uma operação (adicionar, subtrair, multiplicar e dividir: qualquer coisa\n",
      "Operação Inválida\n",
      "Resultado: 5.0\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Calculadora Simples com Funções\n",
    "\n",
    "Objetivo: Criar uma calculadora simples que pode realizar \n",
    "quatro operações básicas: adição, subtração, multiplicação e divisão.\n",
    "\n",
    "O usuário deverá fornecer dois números e a operação desejada. A solução \n",
    "deve ser implementada usando funções.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    Defina quatro funções: adicionar(), subtrair(), multiplicar() e dividir(). \n",
    "    \n",
    "    - Cada função deve aceitar dois parâmetros (números) e retornar o resultado \n",
    "    da operação correspondente.\n",
    "    - Peça ao usuário para inserir dois números.\n",
    "    - Peça ao usuário para escolher uma das quatro operações (por exemplo, \n",
    "    ele pode digitar \"adicionar\" para adição).\n",
    "    - Com base na escolha do usuário, chame a função correspondente e imprima o resultado.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "# Definindo as funções para as operações básicas\n",
    "\n",
    "# Definindo a função para adicionar dois números\n",
    "def adicionar(a, b):\n",
    "    \n",
    "    # Retorna a soma de a e b\n",
    "    return a + b  \n",
    "\n",
    "# Definindo a função para subtrair um número do outro\n",
    "def subtrair(a, b):\n",
    "    \n",
    "    # Retorna a diferença entre a e b\n",
    "    return a - b  \n",
    "\n",
    "# Definindo a função para multiplicar dois números\n",
    "def multiplicar(a, b):\n",
    "    \n",
    "    # Retorna o produto de a e b\n",
    "    return a * b  \n",
    "\n",
    "# Definindo a função para dividir um número pelo outro\n",
    "def dividir(a, b):\n",
    "    \n",
    "    # Retorna a divisão de a por b\n",
    "    return a / b  \n",
    "\n",
    "# Solicitando ao usuário o primeiro número e convertendo-o para float\n",
    "num1 = float(input(\"Digite o primeiro número: \"))\n",
    "\n",
    "# Solicitando ao usuário o segundo número e convertendo-o para float\n",
    "num2 = float(input(\"Digite o segundo número: \"))\n",
    "\n",
    "# Solicitando ao usuário que escolha uma das operações definidas\n",
    "op = input(\"Escolha uma operação (adicionar, subtrair, multiplicar, dividir): \")\n",
    "\n",
    "# Usando condicionais para determinar qual função chamar com base na escolha do usuário\n",
    "if op == \"adicionar\":\n",
    "    \n",
    "    # Chama a função de adição se o usuário escolheu 'adicionar'\n",
    "    resultado = adicionar(num1, num2)  \n",
    "    \n",
    "elif op == \"subtrair\":\n",
    "    \n",
    "    # Chama a função de subtração se o usuário escolheu 'subtrair'\n",
    "    resultado = subtrair(num1, num2)   \n",
    "    \n",
    "elif op == \"multiplicar\":\n",
    "    \n",
    "    # Chama a função de multiplicação se o usuário escolheu 'multiplicar'\n",
    "    resultado = multiplicar(num1, num2) \n",
    "    \n",
    "elif op == \"dividir\":\n",
    "    \n",
    "    # Chama a função de divisão se o usuário escolheu 'dividir'\n",
    "    resultado = dividir(num1, num2)     \n",
    "    \n",
    "else:\n",
    "    \n",
    "    # Imprime uma mensagem de erro se o usuário não escolheu uma operação válida\n",
    "    print(\"Operação inválida.\")         \n",
    "\n",
    "# Imprime o resultado da operação escolhida\n",
    "print(\"Resultado:\", resultado)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a20e4ae0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "20dcea6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "15\n",
      "30\n",
      "2.5\n",
      "Operação não suportada.\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Fábrica de Funções de Operações Matemáticas\n",
    "\n",
    "Imagine que você está construindo uma calculadora. Porém, ao invés de \n",
    "implementar cada operação matemática (soma, subtração, multiplicação e divisão) \n",
    "diretamente, você decide criar uma \"fábrica de funções\". Esta fábrica, quando fornecida \n",
    "com o nome de uma operação, deve retornar uma função que realiza a operação desejada.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    - Escreva uma função chamada fábrica_de_operacoes que aceite uma \n",
    "    string: 'soma', 'subtracao', 'multiplicacao' ou 'divisao'.\n",
    "    \n",
    "    - Dependendo do argumento fornecido, sua função deve retornar uma das \n",
    "    operações matemáticas. Por exemplo, se o argumento for 'soma', a função \n",
    "    retornada deve ser capaz de somar dois números.\n",
    "    \n",
    "    - Se a operação não for reconhecida, retorne uma função que \n",
    "    imprima \"Operação não suportada.\".\n",
    "    \n",
    "    \n",
    "Desafio Extra:\n",
    "Adapte a fábrica para aceitar operações com \n",
    "mais de dois números. Por exemplo, a operação de soma deve \n",
    "ser capaz de somar três, quatro ou mais números de uma só vez.\n",
    "\n",
    "Dica: Utilize argumentos variáveis (*args) para essa adaptação.\n",
    "\"\"\"\n",
    "\n",
    "def fabrica_de_funcoes(operacao):\n",
    "    \n",
    "    # Esta função recebe um número indefinido de argumentos e os soma.\n",
    "    def soma(*args):\n",
    "        \n",
    "        return sum(args)\n",
    "    \n",
    "    # Esta função subtrai todos os números subsequentes do primeiro número.\n",
    "    def subtracao(*args):\n",
    "        \n",
    "        resultado = args[0]\n",
    "        \n",
    "        # Itera sobre todos os números após o primeiro\n",
    "        for num in args[1:]:\n",
    "            \n",
    "            #resultado = resultado - num\n",
    "            resultado -= num\n",
    "            \n",
    "        return resultado\n",
    "    \n",
    "    # Esta função multiplica todos os números fornecidos.\n",
    "    def multiplicacao(*args):\n",
    "        \n",
    "        resultado = 1\n",
    "        \n",
    "        # Itera sobre todos os números e os multiplica\n",
    "        for num in args:\n",
    "            \n",
    "            #resultado = resultado * num\n",
    "            resultado *= num\n",
    "            \n",
    "        return resultado\n",
    "    \n",
    "    # Esta função divide o primeiro número pelos números subsequentes.\n",
    "    def divisao(*args):\n",
    "        \n",
    "        resultado = args[0]\n",
    "        \n",
    "        # Itera sobre todos os números após o primeiro\n",
    "        for num in args[1:]:\n",
    "            \n",
    "            # Verifica se algum número é zero (para evitar divisão por zero)\n",
    "            if num == 0:\n",
    "                \n",
    "                \"\"\"\n",
    "                é usada para lançar (ou \"raise\", em inglês) uma exceção do tipo ValueError.\n",
    "\n",
    "                Em programação, uma exceção é uma forma de sinalizar que algo inesperado \n",
    "                aconteceu durante a execução de um programa. Quando uma exceção é \n",
    "                lançada e não tratada, ela interrompe a execução do programa e produz \n",
    "                uma mensagem de erro.\n",
    "\n",
    "                A razão pela qual lançamos essa exceção específica é porque a divisão por zero \n",
    "                é matematicamente indefinida e resultaria em um erro se tentássemos fazer \n",
    "                isso em Python (ou na maioria das linguagens de programação). Em vez de permitir \n",
    "                que esse erro ocorra, detectamos o caso em que um número é dividido por zero e \n",
    "                lançamos uma exceção com uma mensagem explicativa.\n",
    "\n",
    "                Em outras palavras, essa linha foi adicionada para:\n",
    "\n",
    "                    Prevenir a ocorrência de um erro de divisão por zero.\n",
    "                    \n",
    "                    Fornecer uma mensagem de erro amigável e explicativa para o usuário, \n",
    "                    informando-o do problema.\n",
    "\n",
    "                Se você remover essa linha e tentar dividir por zero, o Python lançará sua \n",
    "                própria exceção de ZeroDivisionError, que pode não ser tão amigável ou específica \n",
    "                quanto à mensagem que fornecemos.\n",
    "                \"\"\"\n",
    "                raise ValueError(\"Divisão por zero não é permitida.\")\n",
    "                \n",
    "            resultado /= num\n",
    "            \n",
    "        return resultado\n",
    "    \n",
    "    # Retorna a função correspondente baseada no valor da 'operacao'\n",
    "    if operacao == \"soma\":\n",
    "        \n",
    "        return soma\n",
    "    \n",
    "    elif operacao == \"subtracao\":\n",
    "        \n",
    "        return subtracao\n",
    "    \n",
    "    elif operacao == \"multiplicacao\":\n",
    "        \n",
    "        return multiplicacao\n",
    "    \n",
    "    elif operacao == \"divisao\":\n",
    "        \n",
    "        return divisao\n",
    "    \n",
    "    else:\n",
    "        \n",
    "        def operacao_nao_suportada(*args):\n",
    "\n",
    "            return \"Operação não suportada.\"\n",
    "        \n",
    "        return operacao_nao_suportada\n",
    "    \n",
    "    \n",
    "# Testando o código\n",
    "adicionar = fabrica_de_funcoes(\"soma\")\n",
    "print(adicionar(5, 3, 2, 9, 4, 7)) # Esperado: 30\n",
    "\n",
    "subtrair = fabrica_de_funcoes(\"subtracao\")\n",
    "print(subtrair(50, 30, 5)) # Esperado: 15\n",
    "\n",
    "multiplicar = fabrica_de_funcoes(\"multiplicacao\")\n",
    "print(multiplicar(5, 3, 2)) # Esperado: 30\n",
    "\n",
    "dividir = fabrica_de_funcoes(\"divisao\")\n",
    "print(dividir(10, 2, 2)) # Esperado: 2.5\n",
    "\n",
    "operacao_invalida = fabrica_de_funcoes(\"modulo\")\n",
    "print(operacao_invalida(5, 3)) # Esperado: \"Operação não suportada.\"\n",
    "            \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c583507",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "b4875c19",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Função Regular: 10\n",
      "Função Lambda: 10\n",
      "Positivo\n",
      "Positivo\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Funções Anônimas (Lambda)\n",
    "o\tDefinição e uso\n",
    "o\tLimitações em relação às funções regulares\n",
    "\n",
    "\n",
    "Função lambda\n",
    "\n",
    "\n",
    "Funções lambda são funções anônimas de pequena extensão. Ao contrário \n",
    "de uma função definida com def, a função lambda pode ter apenas uma \n",
    "expressão e retorna implicitamente o resultado dessa expressão. Ela é \n",
    "frequentemente usada para pequenas operações que são convenientes de \n",
    "se definir sem nomear uma função completa.\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#Exemplo Prático 1: Definição e uso\n",
    "\n",
    "#Função Regular para Dobrar um Número\n",
    "\n",
    "def dobrar(n):\n",
    "    \n",
    "    return n * 2\n",
    "\n",
    "print(\"Função Regular:\", dobrar(5)) # Saída: 10 \n",
    "\n",
    "#Função Lambda para Dobrar um Número\n",
    "dobrar_com_lambda = lambda n: n * 2\n",
    "\n",
    "print(\"Função Lambda:\", dobrar_com_lambda(5)) # Saída: 10 \n",
    "\n",
    "\"\"\"\n",
    "Exemplo Prático 2: Limitações\n",
    "\n",
    "    Expressividade\n",
    "\n",
    "Função Regular para Classificar Números:\n",
    "\"\"\"\n",
    "\n",
    "def classificar_numero(n):\n",
    "    \n",
    "    if n < 0:\n",
    "        \n",
    "        return \"Negativo\"\n",
    "    \n",
    "    elif n == 0:\n",
    "        \n",
    "        return \"Zero\"\n",
    "    \n",
    "    else:\n",
    "        \n",
    "        return \"Positivo\"\n",
    "\n",
    "print(classificar_numero(5)) #Saída: Positivo\n",
    "\n",
    "#Tentativa de Função lambda para Classificar Números (Menos Clara):\n",
    "\n",
    "classificar_numero_lambda = lambda n: \"Negativo\" if n < 0 else ( \"Zero\" if n == 0 else \"Positivo\")\n",
    "\n",
    "print(classificar_numero_lambda(5)) #Saída: Positivo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "89d2f52e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Maria', 25), ('João', 35), ('Pedro', 40)]\n",
      "\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Nomeação\n",
    "\n",
    "Sem atribuir a função lambda a uma variável, ela permanece anônima. \n",
    "Você pode usá-la, por exemplo, em funções como sorted:\n",
    "\n",
    "Ordenar uma lista de strings pelo comprimento usando função lambda:\n",
    "\"\"\"\n",
    "\n",
    "#Função lambda com sorted\n",
    "\n",
    "\"\"\"\n",
    "Exemplo com sorted:\n",
    "\n",
    "Suponha que você tenha uma lista de tuplas representando \n",
    "pessoas e suas idades, e você queira classificá-las pela idade:\n",
    "\"\"\"\n",
    "\n",
    "pessoas = [(\"João\", 35), (\"Maria\", 25), (\"Pedro\", 40)]\n",
    "pessoas_ordenadas = sorted(pessoas, key=lambda x: x[1])\n",
    "\n",
    "print(pessoas_ordenadas)  # Saída: [('Maria', 25), ('João', 35), ('Pedro', 40)]\n",
    "\n",
    "#No exemplo acima, estamos usando a função lambda \n",
    "#para especificar que queremos ordenar as tuplas pela idade (índice 1).\n",
    "\n",
    "\"\"\"\n",
    "    sorted(): É uma função built-in do Python que retorna uma nova \n",
    "    lista contendo todos os itens da lista original em ordem crescente.\n",
    "    \n",
    "    Uma função built-in é uma função que já vem incluída no \n",
    "    núcleo do Python, de modo que você não precisa importar nenhum módulo ou \n",
    "    pacote adicional para usá-la. Essas funções estão sempre disponíveis no namespace \n",
    "    principal e ajudam a realizar tarefas comuns sem a necessidade de escrever código extra.\n",
    "\n",
    "    pessoas: É a lista que você deseja ordenar. No exemplo fornecido, \n",
    "    pessoas é uma lista de tuplas onde cada tupla contém um nome e uma idade.\n",
    "\n",
    "    key: É um argumento opcional que você pode passar para a função \n",
    "    sorted(). Ele espera uma função que pode aceitar um item da \n",
    "    lista (neste caso, uma tupla) e retornar um valor que será usado \n",
    "    para ordenar a lista.\n",
    "\n",
    "    lambda x: x[1]: Esta é uma função lambda que aceita uma \n",
    "    tupla x e retorna o segundo item da tupla (ou seja, x[1]). Neste \n",
    "    contexto, isso significa que estamos pegando a idade de cada \n",
    "    tupla. A função sorted() usará essas idades para ordenar a lista de tuplas.\n",
    "\n",
    "Então, quando você escreve pessoas_ordenadas = sorted(pessoas, key=lambda x: x[1]), você está dizendo:\n",
    "\n",
    "    \"Eu quero ordenar a lista pessoas.\"\n",
    "    \n",
    "    \"Para determinar a ordem, para cada tupla em pessoas, pegue o segundo \n",
    "    item da tupla (a idade) e use-o como a chave de ordenação.\"\n",
    "    \n",
    "    \"Coloque o resultado ordenado na variável pessoas_ordenadas.\"\n",
    "\n",
    "O resultado é uma lista de tuplas ordenadas por idade.\n",
    "\"\"\"\n",
    "print()\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "    Restrição de escopo\n",
    "\n",
    "Vamos considerar um exemplo em que tentamos modificar uma variável \n",
    "global usando global em uma função lambda, mas não podemos.\n",
    "\n",
    "Função Regular Modificando uma Variável Global:\n",
    "\"\"\"\n",
    "\n",
    "contador = 0\n",
    "\n",
    "def aumentar_contador():\n",
    "    \n",
    "    global contador\n",
    "    \n",
    "    contador += 1 \n",
    "\n",
    "aumentar_contador()\n",
    "print(contador)\n",
    "\n",
    "aumentar_contador()\n",
    "print(contador)\n",
    "\n",
    "aumentar_contador()\n",
    "print(contador)\n",
    "\n",
    "#Tentativa de Função Lambda Modificando uma Variável Global (Isso causará um erro):\n",
    "# A seguinte linha causará um erro se descomentada\n",
    "# aumentar_contador = lambda: global contador; contador += 1\n",
    "\n",
    "\n",
    "#Esses exemplos práticos ajudam a entender a versatilidade e as \n",
    "#limitações das funções lambda em comparação com as funções regulares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15e4a470",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a833f528",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#função lambda com filter\n",
    "\n",
    "\"\"\"\n",
    "Filtramos uma lista para obter apenas números pares \n",
    "usando a função filter() junto com uma função lambda.\n",
    "\n",
    "Problema:\n",
    "Dada uma lista de números, filtre-a para obter apenas os números pares.\n",
    "\"\"\"\n",
    "\n",
    "# Lista original de números\n",
    "numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "# Usando filter() e lambda para obter apenas números pares\n",
    "numeros_pares = list(filter(lambda x: x % 2 == 0, numeros))\n",
    "\n",
    "\"\"\"\n",
    "    list(): A função list() é usada para converter um iterável em uma lista. No \n",
    "    contexto desta linha, ela está sendo usada para converter o iterador resultante \n",
    "    da função filter() de volta em uma lista.\n",
    "\n",
    "    filter(): A função filter() é uma função built-in do Python que filtra os itens \n",
    "    de um iterável (como uma lista) com base em uma função fornecida. Ela retorna um \n",
    "    iterador, razão pela qual usamos list() para converter de volta em uma lista.\n",
    "\n",
    "    lambda x: x % 2 == 0: Esta é uma função lambda. É uma pequena função anônima que pode \\\n",
    "    ter qualquer número de argumentos, mas só pode ter uma expressão. Esta expressão \n",
    "    específica retorna True se x for par e False caso contrário.\n",
    "    \n",
    "        x % 2 retorna o resto da divisão de x por 2.\n",
    "        x % 2 == 0 verifica se esse resto é zero (o que indica que x é um número par).\n",
    "\n",
    "    numeros: É a lista original de números que você deseja filtrar.\n",
    "\n",
    "Então, quando você combina tudo, esta linha de código está dizendo:\n",
    "\n",
    "    \"Quero filtrar a lista numeros.\"\n",
    "    \"Para cada número na lista, quero verificar se ele é par.\"\n",
    "    \"Se for par, inclua-o no resultado.\"\n",
    "    \"Finalmente, converta o resultado filtrado de volta em uma lista e armazene-o na variável numeros_pares.\"\n",
    "\n",
    "Assim, numeros_pares acabará sendo uma lista contendo apenas os números pares da lista original numeros.\n",
    "\"\"\"\n",
    "\n",
    "print(numeros_pares)  # Saída: [2, 4, 6, 8, 10]\n",
    "\n",
    "\"\"\"\n",
    "Explicação:\n",
    "A função lambda lambda x: x % 2 == 0 verifica se um número \n",
    "é par (ou seja, se ele é divisível por 2 sem deixar um resto). A função filter() então \n",
    "aplica essa função lambda a cada item da lista numeros. Os itens que retornam True são mantidos \n",
    "no resultado, que no final são os números pares.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f73e054",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0326a8ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', 'Anna', 'Alex']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Vamos criar um exemplo onde filtramos uma lista de strings \n",
    "para obter apenas aquelas que começam com a letra \"A\".\n",
    "\n",
    "Problema:\n",
    "\n",
    "Dada uma lista de nomes, filtre-a para obter apenas os nomes \n",
    "que começam com a letra \"A\".\n",
    "\"\"\"\n",
    "\n",
    "# Lista original de nomes\n",
    "nomes = [\"Alice\", \"Bob\", \"Anna\", \"Charlie\", \"Alex\", \"Tom\"]\n",
    "\n",
    "# Usando filter() e lambda para obter apenas nomes que começam com \"A\"\n",
    "nomes_com_A = list(filter(lambda nome: nome[0] == \"A\", nomes))\n",
    "\n",
    "\"\"\"\n",
    "    list(): Esta função é usada para converter um iterável em uma lista. \n",
    "    No contexto desta linha, ela está sendo usada para converter o resultado \n",
    "    do filter() de um iterador de volta para uma lista.\n",
    "\n",
    "    filter(): A função filter() é uma função built-in do Python que é usada \n",
    "    para filtrar os itens de um iterável (como uma lista) com base em uma função \n",
    "    fornecida. Ela irá retornar um iterador contendo todos os itens do iterável para \n",
    "    os quais a função aplicada retorna True.\n",
    "\n",
    "    lambda nome: nome[0] == \"A\": Esta é uma função lambda, que é uma pequena função anônima em Python.\n",
    "    \n",
    "        nome: é o argumento da função. Para cada string na lista nomes, a string \n",
    "        será passada para esta função lambda.\n",
    "        \n",
    "        nome[0]: obtém o primeiro caractere da string nome.\n",
    "        \n",
    "        nome[0] == \"A\": verifica se o primeiro caractere da string nome \n",
    "        é igual a \"A\". Se for, a função retorna True; caso contrário, retorna False.\n",
    "\n",
    "    nomes: É a lista original de nomes que você deseja filtrar.\n",
    "\n",
    "Quando juntamos tudo, a linha está fazendo o seguinte:\n",
    "\n",
    "    \"Quero filtrar a lista nomes.\"\n",
    "    \"Para cada nome na lista, quero verificar se ele começa com a letra 'A'.\"\n",
    "    \"Se começar, inclua-o no resultado.\"\n",
    "    \"Finalmente, converta o resultado filtrado de volta em uma lista.\"\n",
    "\n",
    "Como resultado, nomes_com_A será uma lista contendo apenas os nomes da \n",
    "lista original nomes que começam com a letra \"A\".\n",
    "\"\"\"\n",
    "\n",
    "print(nomes_com_A)  # Saída: ['Alice', 'Anna', 'Alex']\n",
    "\n",
    "\"\"\"\n",
    "Explicação:\n",
    "\n",
    "A função lambda lambda nome: nome[0] == \"A\" verifica se a \n",
    "primeira letra do nome é \"A\". A função filter() aplica essa função \n",
    "lambda a cada item da lista nomes. Os itens que retornam True (aqueles que \n",
    "começam com \"A\") são mantidos no resultado.\n",
    "\"\"\"\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53c7eb50",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b91300c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', 'Alice']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Suponhamos que queremos filtrar uma lista de nomes e obter \n",
    "apenas aqueles que são exatamente \"Alice\".\n",
    "\n",
    "Problema:\n",
    "Dada uma lista de nomes, filtre-a para obter apenas as entradas que são \"Alice\".\n",
    "\"\"\"\n",
    "\n",
    "# Lista original de nomes\n",
    "nomes = [\"Alice\", \"Bob\", \"Anna\", \"Charlie\", \"Alex\", \"Tom\", \"Alice\"]\n",
    "\n",
    "# Usando filter() e lambda para obter apenas as entradas que são \"Alice\"\n",
    "nomes_Alice = list(filter(lambda nome: nome == \"Alice\", nomes))\n",
    "\n",
    "print(nomes_Alice)  # Saída: ['Alice', 'Alice']\n",
    "\n",
    "\"\"\"\n",
    "Explicação:\n",
    "A função lambda lambda nome: nome == \"Alice\" compara cada entrada \n",
    "da lista nomes com a string \"Alice\". Se a entrada for exatamente igual \n",
    "a \"Alice\", a função retorna True; caso contrário, retorna False. A função \n",
    "filter() pega esses valores True e False e inclui apenas as entradas que \n",
    "retornam True no resultado final.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e79ff51",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a42d81c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "#Função lambda com map\n",
    "\"\"\"\n",
    "Vamos a um exemplo em que utilizaremos a função map() com uma \n",
    "função lambda para transformar uma lista de números, elevando cada número ao quadrado.\n",
    "\n",
    "Problema:\n",
    "Dada uma lista de números, retorne uma nova lista onde cada número é elevado ao quadrado.\n",
    "\"\"\"\n",
    "\n",
    "# Lista original de números\n",
    "numeros = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Usando map() e lambda para elevar cada número ao quadrado\n",
    "numeros_ao_quadrado = list(map(lambda x: x**2, numeros))\n",
    "\n",
    "\"\"\"\n",
    "    lambda x: x2:\n",
    "        Uma função lambda é uma pequena função anônima.\n",
    "        A função lambda pode ter qualquer número de argumentos, mas só pode ter uma expressão.\n",
    "        Aqui, a expressão lambda x: x**2 define uma função que aceita um argumento x e retorna x ao quadrado.\n",
    "\n",
    "    map():\n",
    "        A função map() aplica uma função a todos os itens de um objeto de entrada (como uma lista ou tupla).\n",
    "        No caso acima, map() aplica a função lambda definida anteriormente a cada item da lista numeros.\n",
    "\n",
    "    list():\n",
    "        A função list() converte o resultado de map() em uma lista. Isso é necessário porque \n",
    "        a função map() retorna um objeto iterável de tipo map, e se você deseja uma lista como \n",
    "        saída, você deve convertê-lo em uma lista.\n",
    "\n",
    "    Então, se você tiver a lista numeros = [1, 2, 3, 4, 5]:\n",
    "\n",
    "    A função map() aplica a função lambda a cada elemento da lista, resultando nos quadrados \n",
    "    de cada número: 1, 4, 9, 16 e 25.\n",
    "\n",
    "    Finalmente, a função list() converte esses resultados em uma lista, dando o resultado final \n",
    "    para numeros_ao_quadrado como [1, 4, 9, 16, 25].\n",
    "\"\"\"\n",
    "\n",
    "print(numeros_ao_quadrado)  # Saída: [1, 4, 9, 16, 25]\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Explicação:\n",
    "\n",
    "A função lambda lambda x: x**2 pega cada número x e retorna seu \n",
    "quadrado. A função map() aplica essa função lambda a cada item da lista \n",
    "numeros. \n",
    "\n",
    "O resultado é um iterador com os números elevados ao quadrado, então \n",
    "usamos list() para convertê-lo de volta em uma lista.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46389974",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3851d626",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 6, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Vamos criar um exemplo onde usaremos a função map() juntamente \n",
    "com uma função lambda para transformar uma lista de palavras em uma lista \n",
    "que contém o comprimento de cada palavra.\n",
    "\n",
    "Problema:\n",
    "\n",
    "Dada uma lista de palavras, retorne uma nova lista contendo o \n",
    "comprimento de cada palavra.\n",
    "\"\"\"\n",
    "\n",
    "# Lista original de palavras\n",
    "palavras = [\"maça\", \"banana\", \"arroz\", \"abacate\"]\n",
    "\n",
    "# Usando map() e lambda para obter o comprimento de cada palavra\n",
    "comprimentos = list(map(lambda palavra: len(palavra), palavras))\n",
    "\n",
    "\"\"\"\n",
    "    list(): Esta função é utilizada para converter um iterável (como o resultado \n",
    "    do map()) em uma lista. A função map(), por padrão, retorna um iterador, e ao envolvê-lo \n",
    "    com list(), estamos convertendo esse iterador em uma lista real.\n",
    "\n",
    "    map(): A função map() é uma função built-in do Python que aplica uma função a \n",
    "    todos os itens em um iterável (neste caso, a lista palavras). A ideia principal \n",
    "    aqui é transformar cada item da lista original (cada palavra) em um novo \n",
    "    valor (neste caso, o comprimento de cada palavra).\n",
    "\n",
    "    lambda palavra: len(palavra): Isso é uma função lambda (uma função anônima de uma única linha).\n",
    "\n",
    "        palavra: É a variável que recebe cada item da lista palavras um de cada vez.\n",
    "\n",
    "        len(palavra): Esta parte da função lambda retorna o comprimento da palavra \n",
    "        atual. len() é uma função built-in do Python que retorna o número de itens em um \n",
    "        objeto, neste contexto, o número de caracteres em uma string.\n",
    "\n",
    "    palavras: Este é o iterável original (a lista de palavras) que você deseja transformar.\n",
    "\n",
    "Quando você combina tudo, o que esta linha faz é:\n",
    "\n",
    "    Para cada palavra na lista palavras, obtenha o comprimento dessa palavra.\n",
    "    Crie uma nova lista, comprimentos, contendo os comprimentos de todas as palavras da lista original.\n",
    "\n",
    "Então, se a lista palavras contém [\"maça\", \"banana\"], a lista resultante \n",
    "comprimentos será [4, 6], porque \"arroz\" tem 5 letras e \"abacate\" tem 7 letras.\n",
    "\"\"\"\n",
    "\n",
    "print(comprimentos)  # Saída: [4, 6, 5, 7]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0f6adaef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Números ímpares: [5, 15, 23, 25]\n",
      "Quadrados dos números ímpares: [25, 225, 529, 625]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Filtrando e Transformando Dados com Lambda\n",
    "\n",
    "Objetivo: Familiarizar-se com o uso de funções lambda \n",
    "juntamente com funções built-in como filter e map.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Dada uma lista de números: numeros = [2, 5, 8, 10, 12, 15, 18, 20, 23, 25, 28].\n",
    "    \n",
    "    2. Use a função filter() e uma função lambda para criar uma nova \n",
    "    lista que contém apenas os números ímpares da lista original.\n",
    "    \n",
    "    3. Em seguida, use a função map() e uma função lambda para \n",
    "    criar uma nova lista que contém o quadrado de cada número da lista de números ímpares.\n",
    "    \n",
    "    4. Imprima ambas as listas.\n",
    "    \n",
    "    Dicas:\n",
    "\n",
    "    Use filter() para filtrar itens de uma lista.\n",
    "    Use map() para aplicar uma função a cada item de uma lista.\n",
    "\"\"\"\n",
    "\n",
    "# Lista inicial de números\n",
    "numeros = [2, 5, 8, 10, 12, 15, 18, 20, 23, 25, 28]\n",
    "\n",
    "# Filtrando números ímpares\n",
    "numeros_impares = list(filter(lambda x: x % 2 != 0, numeros))\n",
    "\n",
    "\"\"\"\n",
    "    filter(): É uma função built-in do Python que filtra os itens de \n",
    "    um iterável (como uma lista) com base em uma função fornecida. Retorna \n",
    "    um iterador, razão pela qual usamos list() para convertê-lo de volta em uma lista.\n",
    "\n",
    "    lambda x: x % 2 != 0: Esta é uma função lambda que verifica se um \n",
    "    número x é ímpar. Se o número x quando dividido por 2 tiver um \n",
    "    resto diferente de zero, então ele é ímpar.\n",
    "\n",
    "    numeros: É a lista original de números que você quer filtrar.\n",
    "\n",
    "O resultado dessa linha de código é uma nova lista, numeros_impares, que \n",
    "contém apenas os números ímpares da lista original numeros.\n",
    "\"\"\"\n",
    "\n",
    "# Obtendo o quadrado de cada número ímpar\n",
    "quadrados_impares = list(map(lambda x: x ** 2, numeros_impares))\n",
    "\n",
    "\"\"\"\n",
    "    map(): É outra função built-in do Python que aplica uma função \n",
    "    especificada a todos os itens de um iterável (novamente, como uma \n",
    "    lista). Assim como filter(), map() também retorna um iterador, e é por \n",
    "    isso que usamos list() para convertê-lo novamente em uma lista.\n",
    "\n",
    "    lambda x: x ** 2: Esta é uma função lambda que retorna o quadrado \n",
    "    de um número x.\n",
    "\n",
    "    numeros_impares: É a lista de números ímpares que obtivemos na \n",
    "    primeira linha de código que explicamos.\n",
    "\n",
    "O resultado dessa linha é uma nova lista, quadrados_impares, que contém \n",
    "o quadrado de cada número da lista numeros_impares.\n",
    "\n",
    "Ambas as linhas são exemplos de como as funções lambda podem ser \n",
    "usadas em conjunto com funções como filter() e map() para processar e \n",
    "transformar listas de maneira concisa.\n",
    "\"\"\"\n",
    "\n",
    "# Imprimindo os resultados\n",
    "print(f\"Números ímpares: {numeros_impares}\")\n",
    "print(f\"Quadrados dos números ímpares: {quadrados_impares}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22e41121",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "4eb052ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, Maria\n",
      "4\n",
      "Seu nome é Maria\n",
      "7\n",
      "5.6\n",
      "123\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Funções Internas (built-in)\n",
    "\n",
    "As funções internas (ou built-in functions, em inglês) são funções \n",
    "que já vêm embutidas na linguagem Python, ou seja, elas estão disponíveis sem a \n",
    "necessidade de importar nenhum módulo ou biblioteca adicional.\n",
    "\n",
    "o\tprint(), len(), input(), etc.\n",
    "o\tConversão de tipos: int(), float(), str(), etc.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#Funções Internas (built-in)\n",
    "\n",
    "#print(): Utilizada para imprimir valores no console.\n",
    "\n",
    "nome = \"Maria\"\n",
    "print(\"Olá,\", nome)  # Saída: Olá, Maria\n",
    "\n",
    "\n",
    "#len(): Retorna o número de itens em um objeto.\n",
    "lista = [1, 2, 3, 4]\n",
    "print(len(lista))  # Saída: 4\n",
    "\n",
    "#input(): Lê uma linha do input (entrada padrão).\n",
    "#nome = input(\"Digite seu nome: \")  \n",
    "\n",
    "# O usuário insere \"Carlos\" e pressiona enter\n",
    "print(\"Seu nome é\", nome)  # Saída: Seu nome é Carlos\n",
    "\n",
    "#Conversão de tipos\n",
    "\n",
    "#int(): Converte um valor para um inteiro.\n",
    "numero_decimal = \"7.9\"\n",
    "numero_inteiro = int(float(numero_decimal))  \n",
    "\n",
    "#Nota: Aqui, primeiramente converti a string para float, e depois \n",
    "#para int, porque diretamente não podemos converter a string \"7.9\" para int.\n",
    "\n",
    "print(numero_inteiro)  # Saída: 7\n",
    "\n",
    "#float(): Converte um valor para ponto flutuante (decimal).\n",
    "numero_str = \"5.6\"\n",
    "numero_float = float(numero_str)\n",
    "print(numero_float)  # Saída: 5.6\n",
    "\n",
    "#str() - Converte um valor para string\n",
    "numero = 123\n",
    "numero_str = str(numero)\n",
    "print(numero_str)\n",
    "\n",
    "\"\"\"\n",
    "Estes são exemplos simples e práticos de algumas funções built-in e \n",
    "funções de conversão de tipos em Python. Existem muitas outras funções built-in \n",
    "disponíveis no Python que oferecem uma variedade de funcionalidades úteis.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "775a3c59",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8799456c",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Recursão\n",
    "•\tFunções que chamam a si mesmas\n",
    "•\tProblemas clássicos, como o cálculo do fatorial\n",
    "•\tRiscos e limitações da recursão em Python\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#1. Funções que chamam a si mesmas:\n",
    "\n",
    "#Uma função recursiva é uma função que se chama a si mesma em sua definição.\n",
    "# Define uma função chamada contar_regressivamente\n",
    "def contar_regressivamente(n):\n",
    "                           \n",
    "    # Verifica se n é maior que 0\n",
    "    if n > 0:\n",
    "                           \n",
    "        # Imprime o valor atual de n\n",
    "        print(n)\n",
    "                           \n",
    "        # Chama a função contar_regressivamente passando n-1 como argumento (recursividade)\n",
    "        contar_regressivamente(n-1)\n",
    "\n",
    "# Chama a função contar_regressivamente com o valor inicial 5\n",
    "contar_regressivamente(5)\n",
    "\n",
    "\"\"\"\n",
    "No exemplo acima, a função contar_regressivamente imprime números de n até 1.\n",
    "\n",
    "2. Problemas clássicos:\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#Fatorial:\n",
    "#O fatorial de um número é o produto desse número por todos os seus \n",
    "#antecessores até 1. Por exemplo, 5! (lê-se \"5 fatorial\") é 5 × 4 × 3 × 2 × 1 = 120.\n",
    "# Define uma função chamada fatorial\n",
    "def fatorial(n):\n",
    "                           \n",
    "    # Se n for 0, o fatorial de 0 é definido como 1\n",
    "    if n == 0:\n",
    "        \n",
    "        return 1\n",
    "                           \n",
    "    else:\n",
    "        \n",
    "        # Caso contrário, o fatorial de n é n multiplicado pelo fatorial de n-1 (chamada recursiva)\n",
    "        return n * fatorial(n-1)\n",
    "\n",
    "# Imprime o fatorial de 5\n",
    "print(fatorial(5))  # Saída: 120\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "3. Riscos e limitações da recursão em Python:\n",
    "\n",
    "A recursão tem seus riscos e limitações. Uma delas é a \"RecursionError\", \n",
    "que ocorre quando a profundidade máxima da recursão é atingida. Por padrão, Python \n",
    "tem uma profundidade máxima de recursão de 1000 chamadas.\n",
    "\n",
    "Exemplo:\n",
    "\"\"\"\n",
    "\n",
    "def recursao_infinita(n):\n",
    "    \n",
    "    print(n)\n",
    "    \n",
    "    return recursao_infinita(n+1)\n",
    "\n",
    "# Descomente a linha abaixo para ver o erro, mas cuidado, vai gerar muitos prints!\n",
    "#recursao_infinita(1)\n",
    "\n",
    "\"\"\"\n",
    "Se você descomentar e executar o código acima, receberá uma \n",
    "\"RecursionError\" após 1000 chamadas recursivas.\n",
    "\n",
    "Nota: É importante utilizar recursão com cuidado e garantir que haja \n",
    "um caso base para interromper a recursão e evitar loops infinitos ou estouro da pilha.\n",
    "\"\"\"\n",
    "print()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c88f9af7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5971c922",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "\n",
      "    Função que retorna a soma de dois números.\n",
      "\n",
      "    Parâmetros:\n",
      "    a (int ou float): Primeiro número.\n",
      "    b (int ou float): Segundo número.\n",
      "\n",
      "    Retorna:\n",
      "    int ou float: A soma de a e b.\n",
      "    \n",
      "20\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Documentação e Anotações de Funções\n",
    "•\tDocstrings\n",
    "•\tAnotações de tipo (Type Hints)\n",
    "\n",
    "\n",
    "1. Docstrings:\n",
    "\n",
    "Docstrings são usadas para documentar especificamente o que uma função \n",
    "faz, seus parâmetros e o que ela retorna. Eles são colocados logo após \n",
    "a definição da função, antes do código da função começar, e são escritos entre três aspas duplas \"\"\"\n",
    "\n",
    "#Exemplo\n",
    "def somar(a, b):\n",
    "    \n",
    "    \"\"\"\n",
    "    Função que retorna a soma de dois números.\n",
    "\n",
    "    Parâmetros:\n",
    "    a (int ou float): Primeiro número.\n",
    "    b (int ou float): Segundo número.\n",
    "\n",
    "    Retorna:\n",
    "    int ou float: A soma de a e b.\n",
    "    \"\"\"\n",
    "    return a + b\n",
    "\n",
    "\n",
    "print(somar(2, 3))  # Saída: 5\n",
    "print(somar.__doc__)  # Isso imprimirá a docstring da função\n",
    "\n",
    "\n",
    "#2. Anotações de tipo (Type Hints)\n",
    "\"\"\"\n",
    "Anotações de tipo são usadas para indicar os tipos esperados dos \n",
    "argumentos e o tipo de retorno de uma função. Elas não causam nenhuma \n",
    "verificação de tipo em tempo de execução, mas são úteis para documentação e \n",
    "ferramentas de verificação estática de tipo como o mypy.\n",
    "\n",
    "Exemplo:\n",
    "\"\"\"\n",
    "def multiplicar(a: int, b: int) -> int:\n",
    "    \n",
    "    \"\"\"Função que retorna a multiplicação de dois números inteiros.\"\"\"\n",
    "    return a * b\n",
    "\n",
    "print(multiplicar(4, 5))  # Saída: 20\n",
    "\n",
    "\"\"\"\n",
    "No exemplo acima, as anotações a: int e b: int indicam que os parâmetros \n",
    "a e b devem ser inteiros. A anotação -> int indica que a função retorna um inteiro.\n",
    "\n",
    "A combinação de docstrings e anotações de tipo pode tornar o código \n",
    "Python mais legível e manutenível, pois fornece informações claras sobre a função, seus \n",
    "argumentos e retornos.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "529f6f90",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d44f37c0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "def8b118",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27578c77",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59405fdf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cb3c685",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ba20ab2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b4b9394",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a918fad5",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}