1. Agora, encapsule o código da questão acima, declarando uma rotina em Python chamada sigmoide, que tem um parâmetro \mathbf{x}. Chame sigmoide(-4) e sigmoide(4) e sigmoide(99999). A rotina deve imprimir o resultado com print.
    Ao declarar uma rotina, o que melhorou com relação ao exercício anterior? Qual a diferença entre a variável \mathbf{x} \in \circ parâmetro \mathbf{x} ?

Passo 1

O que o enunciado pede:
  • Encapsular o código numa rotina em Python chamada sigmoide que recebe um parâmetro \mathbf{x}.
  • Chamar sigmoide(-4), sigmoide(4) e sigmoide(99999).
  • A rotina deve imprimir o resultado com print.
  • Responder qualitativamente: o que melhorou ao declarar a rotina; e qual a diferença entre a variável \mathbf{x} e o parâmetro \mathbf{x}.
Informações relevantes dadas:
  • O nome da função deve ser sigmoide.
  • O parâmetro da função é \mathbf{x}.
  • Devemos mostrar/printar os valores para \mathbf{x}=-4, \mathbf{x}=4 e \mathbf{x}=99999.

Passo 2

Definição matemática da função sigmoide (para entendermos o que vamos implementar):
\text{sigmoide}(x)=\frac{1}{1+e^{-x}}.
Explicando a fórmula, devagar:
  • x é a entrada da função (número real).
  • e é a base dos logaritmos naturais, aproximadamente 2{,}71828.
  • A expressão e^{-x} significa "exponencial de -x".
  • A fração devolve um número entre 0 e 1: para x\to -\infty a sigmoide vai para 0; para x\to +\infty vai para 1.

Passo 3

Observação numérica importante (evitar surpresas no código):
  • Para valores muito grandes de x\) positivo, calcular \(e^{x}\) explode (overflow). Mas na forma \(\frac{1}{1+e^{-x}}\) usamos \(e^{-x}\), que para \(x\) grande positivo dá um número muito próximo de \(0\) (sem overflow). - Para \(x\) grande negativo, \(e^{-x}\) é enorme, mas existe uma forma numericamente estável que evita operações com números gigantes: \[\text{sigmoide}(x)= \begin{cases} \displaystyle \frac{1}{1+e^{-x}}, & x\ge 0,\\[6pt] \displaystyle \frac{e^{x}}{1+e^{x}}, & x<0. \end{cases}
Essa reescrita evita somar (1] a números muito grandes/pequenos de forma numericamente ruim. Vou usar a versão estável no código (é um pouquinho mais verbosa, mas segura).]

Passo 4

Código Python da rotina sigmoide que imprime o resultado. Comentarei linha a linha para você entender:
import math

def sigmoide(x):
    # x é o parâmetro local que a função recebe
    if x >= 0:
        # aqui usamos a fórmula direta quando x>=0: 1 / (1 + exp(-x))
        resultado = 1.0 / (1.0 + math.exp(-x))
    else:
        # para x<0 usamos a forma estável: exp(x) / (1 + exp(x))
        resultado = math.exp(x) / (1.0 + math.exp(x))
    print(resultado)

# chamadas pedidas
sigmoide(-4)
sigmoide(4)
sigmoide(99999)
Explicando as partes do código:
  • import math traz a função exp para calcular exponenciais.
  • def sigmoide(x): declara a rotina (função) chamada sigmoide com um parâmetro chamado x.
  • resultado é uma variável local que guarda o valor numérico da sigmoide calculada.
  • print(resultado) mostra o valor na tela como o enunciado pediu.
  • As três chamadas finais executam a função com os três valores solicitados.

Passo 5

Cálculo manual aproximado (para você entender os números que o print mostra):
  1. Para \mathbf{x}=-4:
\text{sigmoide}(-4)=\frac{1}{1+e^{4}}.
Calculando e^{4}\approx 54{,}5981500331. Então
\text{sigmoide}(-4)\approx\frac{1}{1+54{,}5981500331}=\frac{1}{55{,}5981500331}\approx 0{,}01798620996.
  1. Para \mathbf{x}=4:
\text{sigmoide}(4)=\frac{1}{1+e^{-4}}.
Calculando e^{-4}\approx 0{,}0183156388887. Então
\text{sigmoide}(4)\approx\frac{1}{1+0{,}0183156388887}=\frac{1}{1{,}0183156388887}\approx 0{,}98201379004.
  1. Para \mathbf{x}=99999:
\text{sigmoide}(99999)=\frac{1}{1+e^{-99999}}.
Aqui e^{-99999} é extraordinariamente pequeno (praticamente 0 dentro da precisão de qualquer computador). Portanto
\text{sigmoide}(99999)\approx 1{,}000000\ldots \approx 1.
Na prática, o print vai mostrar um valor muito próximo de 1; dependendo da implementação pode ser exatamente 1.0 ou 0.9999999\dots — com a forma usada, será 1.0.

Passo 6

Resposta à pergunta “Ao declarar uma rotina, o que melhorou com relação ao exercício anterior?”
  • Reuso: agora a lógica está escrita uma vez e posso chamar sigmoide com vários valores sem reescrever código.
  • Clareza e organização: o código fica mais legível — a função tem um nome que diz o que faz.
  • Manutenção: se eu quiser mudar a definição (por exemplo, trocar para uma versão mais estável), altero só dentro da função.
  • Testabilidade: fica fácil testar casos e automatizar verificações.
  • Escopo controlado: variáveis usadas dentro da função são locais e não “sujam” o resto do programa.
    Em resumo: declarar a rotina transforma um pedaço de código repetitivo num bloco reutilizável, legível e fácil de manter — vantagens enormes numa prova prática ou num projeto real.

Passo 7

Resposta à pergunta “Qual a diferença entre a variável \mathbf{x} e o parâmetro \mathbf{x}?”
  • Quando escrevemos matematicamente \mathbf{x} (por exemplo, na fórmula da sigmoide), estamos falando de uma variável matemática: um símbolo que representa um número qualquer da definição da função.
  • Quando declaramos def sigmoide(x):, esse x é um parâmetro da função: é um nome local que vai receber o valor passado na chamada (o argumento). Ou seja:
    • Parâmetro = nome usado na definição da função (marca o lugar onde o valor será recebido).
    • Argumento = valor efetivamente passado na chamada (por exemplo -4, 4, 99999).
  • Escopo: o parâmetro x dentro da função é uma variável local; se houver outra variável com nome x fora da função, elas são independentes.
  • Binding: ao chamar sigmoide(4), o parâmetro x é ligado (bind) ao argumento 4 dentro daquele corpo da função.
    Exemplo prático:
x = 10
sigmoide(4)  # aqui dentro da função, x vale 4; fora, x continua valendo 10
Isso ilustra que “variável” é um conceito geral; “parâmetro” é um uso específico (nome local que representa o valor recebido).

Resposta

sigmoide(-4) = 0{,}01798620996209156
sigmoide(4) = 0{,}9820137900379085
sigmoide(99999) = 1
Melhorias ao declarar a rotina: reuso, clareza, manutenção, testabilidade e controle de escopo (o código fica mais organizado e fácil de modificar).
Diferença entre variável \mathbf{x} e parâmetro \mathbf{x}: a variável é um símbolo matemático geral; o parâmetro é o nome local na definição da função que recebe o valor (argumento) quando a função é chamada — têm escopos e papéis diferentes (parâmetro é uma variável local vinculada ao argumento).

Exercícios relacionados