1. Transforme a rotina sigmoide em função sigmoide usando a palavra reservada return, no lugar de print.

Passo 1

O enunciado pede que a rotina chamada “sigmoide” que atualmente usa print seja transformada em uma função que use a palavra reservada return para devolver o valor calculado. Informações relevantes que temos (presumidas, pois é o caso padrão nesta tarefa):
  • A função deve receber um número x (um escalar real).
  • A função deve calcular a função sigmoide clássica.
  • Em vez de apenas imprimir o resultado na tela com print, a função deve retornar o valor com return (para que possamos usar esse valor em outras partes do código).

Passo 2

Antes de codificar, vamos lembrar a fórmula matemática da sigmoide. A função sigmoide é definida por:
\sigma(x)=\frac{1}{1+e^{-x}}
Explicando cada símbolo:
  • x é a entrada (um número real).
  • e é a base dos logaritmos naturais (aprox. 2,718…).
  • \sigma(x) é o valor de saída, que fica no intervalo (0,1).
Um valor prático famoso: para x=0,
\sigma(0)=\frac{1}{1+e^{0}}=\frac{1}{1+1}=\frac{1}{2}=0{,}5.

Passo 3

Agora vamos transformar essa fórmula em código Python. Estrutura básica de uma função em Python:
  • def nome_da_funcao(parametros): inicia a função.
  • return valor devolve o valor calculado para quem chamou a função.
Implementação direta (forma simples):
  • Usamos math.exp para calcular e^{\text{algo}}.
  • A função recebe x e devolve 1 / (1 + math.exp(-x)).
Exemplo de código (explicando cada parte):
  • import math importa funções matemáticas (como exp).
  • def sigmoide(x): define a função com parâmetro x.
  • return 1 / (1 + math.exp(-x)) calcula a fórmula e retorna o resultado.

Passo 4

Por que return e não print?
  • print(...) apenas escreve algo na saída padrão (tela). A função que usa print devolve None, logo você não pode armazenar ou reutilizar o resultado.
  • return ... faz a função devolver o valor calculado ao chamador. Assim você pode fazer y = sigmoide(0) e trabalhar com y.
Exemplo prático do problema com print (para comparar):
  • Se tivéssemos
    def sigmoide(x):
    print(1 / (1 + math.exp(-x)))
    então y = sigmoide(0) faria y ser None e apenas mostraria 0.5 na tela — isto é pouco útil em programas maiores.

Passo 5

Vamos testar mentalmente a função com alguns valores para ver como é o resultado (mostrando como calcular na prova):
  • Para x=0: \sigma(0)=\frac{1}{1+e^{0}}=\frac{1}{2}=0{,}5.
  • Para x=2: primeiro calcule e^{-2}. Sabemos que e^{-2}\approx 0{,}1353. Então \sigma(2)=\frac{1}{1+0{,}1353}\approx\frac{1}{1{,}1353}\approx0{,}8808.
Esses cálculos mostram como avaliar a função na prova sem depender só da implementação.

Passo 6

Observação sobre estabilidade numérica (útil em provas/implementações): para valores muito negativos de x o cálculo de \exp(-x) pode estourar (ficar muito grande). Uma implementação numericamente estável usa duas formas equivalentes dependendo do sinal de x:
  • Se x \ge 0: \sigma(x)=\frac{1}{1+e^{-x}}.
  • Se x < 0: usar a forma \sigma(x)=\frac{e^{x}}{1+e^{x}},que evita calcular e^{-x} grande. Em código, isso vira um if que melhora robustez para entradas grandes em módulo.

Passo 7

Também existe versão para arrays (vetores) usando NumPy, se precisar aplicar a sigmoide elemento a elemento em listas ou vetores. Exemplo simples:
  • import numpy as np
  • def sigmoide_np(x): return 1 / (1 + np.exp(-x))
    Essa versão aceita x como um array np.ndarray ou como escalar.

Passo 8

Resumo prático do que você precisa colocar na prova:
  • Declare a função com def sigmoide(x):.
  • Dentro da função, calcule a fórmula da sigmoide.
  • Use return para devolver o resultado, não print.
  • Se quiser ser cuidadoso com overflow, use a versão condicional mostrada no Passo 6.

Resposta

import math
def sigmoide(x):
return 1 / (1 + math.exp(-x))

Exercícios relacionados