02/04/2025, 12:06 bissecao.

ipynb - Colab

Vamos analisar esse código Python linha por linha:

Linha 1: import math

import math : Esta linha importa o módulo math do Python. O módulo math fornece
acesso a uma ampla gama de funções matemáticas, como:

Funções trigonométricas (seno, cosseno, tangente, etc.)

Funções logarítmicas e exponenciais
Constantes matemáticas (pi, e)
Outras funções matemáticas úteis

Linha 2: import matplotlib.pyplot as plt

import matplotlib.pyplot as plt : Esta linha importa o submódulo pyplot da biblioteca

matplotlib . matplotlib é uma biblioteca de plotagem muito popular em Python, usada
para criar gráficos e visualizações de dados.

pyplot é uma coleção de funções que facilitam a criação de gráficos de forma

semelhante ao MATLAB.
as plt : Isso cria um alias plt para o submódulo matplotlib.pyplot . Isso significa
que, em vez de escrever matplotlib.pyplot.alguma_funcao() , você pode
simplesmente escrever plt.alguma_funcao() , tornando o código mais conciso.

Linha 3: import numpy as np

import numpy as np : Esta linha importa a biblioteca numpy . numpy é uma biblioteca
fundamental para computação numérica em Python. Ela fornece suporte para arrays e
matrizes multidimensionais, além de uma ampla gama de funções matemáticas para
operar nesses arrays.

as np : Assim como no caso do matplotlib , isso cria um alias np para a biblioteca

numpy , simplificando o uso de suas funções.

Em resumo:

Este código importa três bibliotecas essenciais para computação científica e visualização de
dados em Python:

math : Para funções matemáticas básicas.

matplotlib : Para criar gráficos e visualizações.
numpy : Para computação numérica eficiente com arrays.

Essas bibliotecas são frequentemente usadas juntas em projetos de análise de dados, ciência
de dados e engenharia.

# Requisitando as Bibliotecas
import math

https://colab.research.google.com/drive/1qakO3Icx5k0wtmQnIv0LDvAGKuKl7PoO#scrollTo=bJkTLhtE_kvv&printMode=true 1/10
02/04/2025, 12:06 bissecao.ipynb - Colab

import matplotlib.pyplot as plt

import numpy as np

Analise do código linha por linha:

Linha 1: funcao = input("Digite a função de x: ")

input("Digite a função de x: ") : Essa linha exibe a mensagem "Digite a função de x: "
no console e, em seguida, aguarda que o usuário digite algo e pressione Enter.
funcao = ... : O valor digitado pelo usuário é armazenado na variável funcao como uma
string.

Linha 2: f = lambda x: eval(funcao, {"x": x, "math": math, "np": np}) # Mais seguro

f = lambda x: ... : Essa parte define uma função anônima (lambda) que recebe um
argumento x . O resultado dessa função lambda é armazenado na variável f .
eval(funcao, {"x": x, "math": math, "np": np}) :

eval() : Essa é uma função do Python que avalia uma string como uma expressão
Python. É importante notar que eval() pode ser perigoso se você não confiar na
string que está sendo avaliada, pois ela pode executar código arbitrário.
funcao : Essa é a string que o usuário digitou, que representa a função que
queremos avaliar.
{"x": x, "math": math, "np": np} : Esse é um dicionário que fornece um
namespace para a função eval() . Ele define os valores das variáveis que podem
ser usadas dentro da expressão funcao .

"x": x : Isso mapeia a variável x dentro da expressão funcao para o valor do

argumento x passado para a função lambda.
"math": math : Isso disponibiliza o módulo math dentro da expressão funcao ,
permitindo que o usuário use funções matemáticas como math.sin() ,
math.cos() , etc.
"np": np : Isso disponibiliza o módulo numpy dentro da expressão funcao ,
permitindo que o usuário use funções numericas do numpy.

# Mais seguro : Este comentário indica que o uso do dicionário de namespace torna o
uso do eval() mais seguro, pois limita as variáveis e funções que a expressão funcao
pode acessar.

Em resumo:

Esse código permite que o usuário insira uma função matemática como uma string e, em
seguida, cria uma função Python que avalia essa string para um determinado valor de x . O uso
do dicionário de namespace no eval() ajuda a mitigar os riscos de segurança associados ao
uso dessa função.

Exemplo:

https://colab.research.google.com/drive/1qakO3Icx5k0wtmQnIv0LDvAGKuKl7PoO#scrollTo=bJkTLhtE_kvv&printMode=true 2/10
02/04/2025, 12:06 bissecao.ipynb - Colab

Se o usuário digitar "x**2 + math.sin(x)" como a função, a função f resultante calculará o valor
de x ao quadrado mais o seno de x para qualquer valor de x que for passado para ela.

# Solicita a função do usuário

funcao = input("Digite a função de x: ")
f = lambda x: eval(funcao, {"x": x, "math": math, "np": np}) # Mais seguro

Vamos analisar essa função Python f(x) :

Função f(x) :

def f(x):
return eval(funcao, {"x": x, "math": math, "np": np})

Explicação Detalhada:

1. def f(x): :

Esta linha define uma função chamada f que recebe um único argumento, x .

2. return eval(funcao, {"x": x, "math": math, "np": np}) :

return : Esta palavra-chave indica que a função f retornará o resultado da

expressão que segue.
eval(funcao, {"x": x, "math": math, "np": np}) :

eval(funcao, ...) : A função eval() é usada para avaliar uma string como
uma expressão Python.
funcao : Essa é uma variável que deve conter uma string representando uma
expressão Python válida. Essa string geralmente é fornecida pelo usuário e
representa a função matemática que queremos calcular.
{"x": x, "math": math, "np": np} : Esse é um dicionário que define o
namespace (o escopo) no qual a expressão funcao será avaliada.

"x": x : Isso mapeia a variável x dentro da expressão funcao para o

valor do argumento x passado para a função f . Isso permite que a
expressão funcao use o valor de x .
"math": math : Isso disponibiliza o módulo math dentro da expressão
funcao . Isso permite que o usuário use funções matemáticas do módulo
math (como math.sin() , math.cos() , math.sqrt() , etc.) dentro da
expressão funcao .
"np": np : Isso disponibiliza o módulo numpy dentro da expressão
funcao . Isso permite que o usuário use funções e constantes do módulo
numpy (como np.sin() , np.cos() , np.exp() , etc.) dentro da expressão
funcao .

Em resumo:

https://colab.research.google.com/drive/1qakO3Icx5k0wtmQnIv0LDvAGKuKl7PoO#scrollTo=bJkTLhtE_kvv&printMode=true 3/10
02/04/2025, 12:06 bissecao.ipynb - Colab

A função f(x) recebe um valor x como entrada e avalia a string armazenada na variável
funcao como uma expressão Python. O valor de x e os módulos math e numpy são
disponibilizados para a expressão funcao através do dicionário de namespace. A função
retorna o resultado da avaliação da expressão.

Exemplo:

Se a variável funcao contiver a string "x**2 + math.sin(x)" , e você chamar f(3) , a função
calculará 3**2 + math.sin(3) e retornará o resultado.

Importante:

O uso de eval() pode representar riscos de segurança se a string funcao for fornecida
por uma fonte não confiável, pois ela pode executar código arbitrário.
Uma alternativa mais segura seria usar a função ast.literal_eval() para avaliar apenas
literais seguros.

def f(x):
return eval(funcao, {"x": x, "math": math, "np": np})

O código solicita ao usuário que insira os limites inferior e superior do intervalo para o gráfico.
Ele usa a função input() para obter a entrada do usuário e a função int() para converter a
entrada (que é inicialmente uma string) em um número inteiro. Esses limites serão usados
posteriormente para definir o intervalo do eixo x do gráfico.

# Determinando a amplitude do gráfico

li = int(input('Digite o limite inferior do intervalo: '))
ls = int(input('Digite o limite superior do intervalo: '))

O código fornecido realiza as seguintes ações:

1. Gera valores para o gráfico: Cria um conjunto de valores x espaçados uniformemente

dentro do intervalo definido pelo usuário ( li e ls ). Calcula os valores correspondentes
de y usando a função f(x) definida anteriormente.
2. Plota a função: Usa a biblioteca matplotlib para criar um gráfico da função. Inclui a
função, o eixo x e uma grade para facilitar a leitura.
3. Encontra as raízes: Implementa um método numérico (bisseção) para aproximar as raízes
da função dentro do intervalo especificado. As raízes são os pontos onde a função cruza
o eixo x (ou seja, onde f(x) = 0).
4. Plota as raízes: Marca as raízes encontradas no gráfico com pontos vermelhos.
5. Exibe o gráfico: Mostra o gráfico completo com a função e as raízes.

Vou detalhar cada parte do código.

Explicação Detalhada:

https://colab.research.google.com/drive/1qakO3Icx5k0wtmQnIv0LDvAGKuKl7PoO#scrollTo=bJkTLhtE_kvv&printMode=true 4/10
02/04/2025, 12:06 bissecao.ipynb - Colab

1. Geração de Valores para o Gráfico:

xi = np.linspace(li, ls, 1000) :

np.linspace(li, ls, 1000) : Esta função do numpy cria um array de 1000

valores espaçados uniformemente entre li (limite inferior) e ls (limite
superior). Esses valores representam os pontos no eixo x para o gráfico.
xi = ... : O array de valores x é armazenado na variável xi .

yi = f(xi) :

f(xi) : Aqui, a função f (definida anteriormente usando eval ou

ast.literal_eval ) é chamada com o array xi como argumento. Isso calcula
os valores de y correspondentes para cada valor de x em xi .
yi = ... : Os valores de y calculados são armazenados na variável yi .

2. Plotagem da Função:

plt.plot(xi, yi, '-', label=f"f(x) = {funcao}") :

plt.plot(xi, yi, '-') : Esta função do matplotlib.pyplot plota os pontos

(xi, yi) no gráfico. O argumento '-' especifica que a linha deve ser contínua.
label=f"f(x) = {funcao}" : Define a legenda para a linha do gráfico, usando
uma f-string para incluir a expressão da função ( funcao ) no texto da legenda.

plt.axhline(0, color='#B33BFA', linewidth=0.8) :

plt.axhline(0, ...) : Desenha uma linha horizontal no gráfico na posição y =

0 (o eixo x).
color='#B33BFA' : Define a cor da linha como roxo.
linewidth=0.8 : Define a largura da linha.

plt.grid() :

plt.grid() : Adiciona uma grade ao gráfico para facilitar a leitura dos valores.

plt.legend() :

plt.legend() : Exibe a legenda do gráfico, que inclui o rótulo da função.

3. Encontrar as Raízes:

raizes = [] : Inicializa uma lista vazia chamada raizes para armazenar as raízes
encontradas.
for i in range(len(xi) - 1): : Inicia um loop que itera sobre os índices dos
valores de x, exceto o último.
if yi[i] * yi[i + 1] < 0: :

Verifica se há uma mudança de sinal nos valores de y entre dois pontos

consecutivos. Se o produto de yi[i] e yi[i + 1] for negativo, isso significa

https://colab.research.google.com/drive/1qakO3Icx5k0wtmQnIv0LDvAGKuKl7PoO#scrollTo=bJkTLhtE_kvv&printMode=true 5/10
02/04/2025, 12:06 bissecao.ipynb - Colab

que a função cruza o eixo x em algum lugar entre xi[i] e xi[i + 1] ,

indicando uma raiz.
a, b = xi[i], xi[i + 1] : Se houver uma mudança de sinal, define a e b como os
valores de x correspondentes aos pontos onde a mudança de sinal ocorreu.
for _ in range(10): : Inicia um loop interno que executa o método da bisseção 10
vezes para aproximar a raiz.

xm = (a + b) / 2 : Calcula o ponto médio xm entre a e b .

if f(a) * f(xm) < 0: :

Verifica se a raiz está entre a e xm . Se sim, atualiza b para xm .

else: :

Caso contrário, a raiz está entre xm e b , então atualiza a para xm .

raizes.append((a + b) / 2) : Após as 10 iterações do método da bisseção, calcula

uma aproximação da raiz como o ponto médio entre os valores finais de a e b e a
adiciona à lista raizes .

4. Plotagem das Raízes:

if raizes: : Verifica se a lista raizes não está vazia (ou seja, se alguma raiz foi
encontrada).
plt.scatter(raizes, [0] * len(raizes), color='red', zorder=3,
label="Raízes") :

plt.scatter(raizes, [0] * len(raizes), ...) : Plota as raízes encontradas

como pontos no gráfico.
raizes : As coordenadas x das raízes.
[0] * len(raizes) : Cria uma lista de zeros com o mesmo comprimento que
raizes , para que as raízes sejam plotadas no eixo x (y = 0).
color='red' : Define a cor dos pontos como vermelho.
zorder=3 : Define a ordem de plotagem dos pontos (para que fiquem na frente
de outros elementos do gráfico).
label="Raízes" : Define a legenda para os pontos das raízes.

5. Exibição do Gráfico:

plt.legend() : Exibe a legenda atualizada, que agora inclui o rótulo para as raízes.
plt.show() : Mostra o gráfico completo na tela.

Este código é uma ferramenta poderosa para visualizar funções e encontrar suas raízes
numericamente.

# Gera valores de x para o gráfico

xi = np.linspace(li, ls, 1000)
yi = f(xi)

https://colab.research.google.com/drive/1qakO3Icx5k0wtmQnIv0LDvAGKuKl7PoO#scrollTo=bJkTLhtE_kvv&printMode=true 6/10
02/04/2025, 12:06 bissecao.ipynb - Colab

# Plota a função
plt.plot(xi, yi, '-', label=f"f(x) = {funcao}")
plt.axhline(0, color='#B33BFA', linewidth=0.8) # Linha do eixo X
plt.grid()
plt.legend()

# --- Encontrar as raízes no gráfico usando mudança de sinal ---

raizes = []
for i in range(len(xi) - 1):
if yi[i] * yi[i + 1] < 0: # Se há mudança de sinal, há raiz no intervalo
a, b = xi[i], xi[i + 1]
for _ in range(10): # Método da Bisseção (10 iterações para precisão)
xm = (a + b) / 2
if f(a) * f(xm) < 0:
b = xm
else:
a = xm
raizes.append((a + b) / 2) # Salva a raiz aproximada

# Plota as raízes encontradas como pontos vermelhos

if raizes:
plt.scatter(raizes, [0] * len(raizes), color='red', zorder=3, label="Raízes")

plt.legend()
plt.show()

Este código Python implementa o método da bisseção para encontrar uma raiz aproximada de
uma função dentro de um intervalo especificado. Vamos analisar o código passo a passo:

1. Entrada de Dados:

O código solicita ao usuário que insira os limites inferior ( a ) e superior ( b ) do intervalo

onde a raiz será procurada.
Também solicita a tolerância ( tolerancia ), que define o erro máximo aceitável para a raiz
encontrada.
Por fim, solicita o número máximo de iterações ( nloop ) que o método da bisseção deve
executar.

2. Inicialização de Variáveis:

n : Inicializa o contador de iterações com 1.

fa : Calcula o valor da função f no limite inferior a .
fb : Calcula o valor da função f no limite superior b .
xm2 : Calcula o ponto médio do intervalo [a, b] .
fxm : Calcula o valor da função f no ponto médio xm2 .
v : Calcula o produto de fa e fxm . O sinal desse produto é usado para determinar em qual
subintervalo a raiz se encontra.
erro : Inicializa o erro com um valor maior que a tolerância para garantir que o loop while
seja executado.

https://colab.research.google.com/drive/1qakO3Icx5k0wtmQnIv0LDvAGKuKl7PoO#scrollTo=bJkTLhtE_kvv&printMode=true 7/10
02/04/2025, 12:06 bissecao.ipynb - Colab

3. Impressão do Cabeçalho da Tabela:

Imprime o cabeçalho da tabela que exibirá os valores das variáveis em cada iteração do
método da bisseção.

4. Impressão da Primeira Linha da Tabela:

Imprime os valores iniciais das variáveis na primeira linha da tabela.

5. Atualização do Intervalo:

Verifica o sinal de v para determinar em qual subintervalo a raiz se encontra.

Se v < 0 , a raiz está no intervalo [a, xm2] , então o limite superior b é atualizado
para xm2 .
Se v > 0 , a raiz está no intervalo [xm2, b] , então o limite inferior a é atualizado
para xm2 .
Se v == 0 , xm2 é a raiz exata, e o programa imprime o valor da raiz.

6. Loop Principal:

O loop while continua enquanto o erro for maior que a tolerância.

xm1 : Armazena o valor anterior de xm2 .

n : Incrementa o contador de iterações.
xm2 : Calcula o novo ponto médio do intervalo.
fxm : Calcula o valor da função f no novo ponto médio.
erro : Calcula o erro como o valor absoluto da diferença entre xm1 e xm2 .
v : Calcula o produto de fa e fxm .
Atualiza o intervalo [a, b] com base no sinal de v .
Imprime os valores das variáveis na linha atual da tabela.
Verifica se o número máximo de iterações foi atingido. Se sim, o loop é
interrompido.

7. Impressão da Raiz Aproximada e Mensagem de Saída:

Imprime a raiz aproximada encontrada.

Imprime uma mensagem indicando que o loop foi interrompido após o número máximo
de iterações.

Em resumo:

Este código implementa o método da bisseção para encontrar uma raiz aproximada de uma
função dentro de um intervalo especificado. O método da bisseção é um método iterativo que
divide repetidamente o intervalo ao meio e seleciona o subintervalo onde a raiz se encontra. O
código continua iterando até que o erro seja menor que a tolerância ou o número máximo de
iterações seja atingido.

a=int(input('Digite o limite inferior do intervalo: '))

b=int(input('Digite o limite superior do intervalo: '))

https://colab.research.google.com/drive/1qakO3Icx5k0wtmQnIv0LDvAGKuKl7PoO#scrollTo=bJkTLhtE_kvv&printMode=true 8/10
02/04/2025, 12:06 bissecao.ipynb - Colab

tolerancia= float(input('Digite o erro aceitável para a Raiz: '))

nloop= int(input('Digite o número máximo de iterações: '))

n = 1
fa = f(a)
fb = f(b)
xm2 = (a + b)/2
fxm = f(xm2)
v = fa*fxm
erro = 10

print("Método da Bisseção")
print(" n a b x f(a) f(x) f(b) f(a)*f(x) erro")

print("%2d"%n, "%8.4f"%a, "%8.4f"%b, "%8.4f"%xm2, "%8.4f"%fa,"%8.4f"%fb, "%8.4f"%fxm, "%8

if v < 0: b = xm2
if v > 0: a = xm2
if v == 0: print("o valor da raiz é %4.4f" %xm2)

while(erro > tolerancia):

xm1 = xm2
n = n + 1.
xm2 = (a + b)/2
fxm = f(xm2)
erro = math.fabs(xm1 - xm2)
v = fa*fxm
if v < 0: b = xm2
if v > 0: a = xm2
print("%2d"%n, "%8.4f"%a, "%8.4f"%b, "%8.4f"%xm2, "%8.4f"%fa,"%8.4f"%fb, "%8.4f"%fxm, "
if(n == nloop):
break

print("\nA raiz aproximada é %4.4f" %xm2)

print('Loop para com no máximo ',nloop,' iterações')

https://colab.research.google.com/drive/1qakO3Icx5k0wtmQnIv0LDvAGKuKl7PoO#scrollTo=bJkTLhtE_kvv&printMode=true 9/10
02/04/2025, 12:06 bissecao.ipynb - Colab

https://colab.research.google.com/drive/1qakO3Icx5k0wtmQnIv0LDvAGKuKl7PoO#scrollTo=bJkTLhtE_kvv&printMode=true 10/10