Pedro's dev blog

SymPy vs SciPy: Matemática Simbólica e Computação Científica em Python

Scypyxsympy.png
Published on
/9 mins read/---

Quando começamos a trabalhar com matemática computacional em Python, duas bibliotecas aparecem frequentemente: SymPy e SciPy.

Apesar dos nomes serem parecidos, elas possuem objetivos diferentes.

De forma simples:

SymPy trabalha principalmente com matemática simbólica. SciPy trabalha principalmente com computação científica numérica.

Essa diferença é importante para quem trabalha com Data Science, Machine Learning, Deep Learning, engenharia, física ou matemática aplicada.


1. SymPy vs SciPy

Podemos visualizar a diferença desta forma:

Uma maneira intuitiva de pensar:

SymPy:

f(x) = x² + 2x + 1
       ↓
   manipular a fórmula
       ↓
(x + 1)²

SciPy:

f(x) = x² + 2x + 1
       ↓
escolher x = 10
       ↓
121

2. Instalando as bibliotecas

Podemos instalar ambas utilizando pip:

pip install sympy scipy numpy jupyter

Ou, se você estiver utilizando um ambiente Conda:

conda install sympy scipy numpy jupyter

Depois podemos iniciar o Jupyter:

jupyter notebook

Ou:

jupyter lab

📝 Se tiver dúvidas sobre como isolar esse ambiente, veja os guias práticos: venv + pip, Conda e uv. O panorama completo está em As 4 Formas de Gerenciar Ambientes Python.


3. Usando SymPy

Primeiro importamos a biblioteca:

import sympy as sp

Agora podemos criar uma variável simbólica:

x = sp.Symbol("x")

Diferentemente de uma variável Python tradicional, x representa um símbolo matemático.

Podemos criar uma expressão:

expr = x**2 + 2*x + 1
 
expr

O SymPy consegue reconhecer a estrutura matemática da expressão.


4. Simplificação algébrica

Por exemplo:

expr = x**2 + 2*x + 1
 
sp.factor(expr)

Resultado:

(x + 1)²

Também podemos expandir:

sp.expand((x + 1)**2)

Resultado:

x² + 2x + 1

Podemos pensar no processo:


5. Resolvendo equações

O SymPy também pode resolver equações simbolicamente.

x = sp.Symbol("x")
 
equacao = x**2 - 4
 
sp.solve(equacao, x)

Resultado:

[-2, 2]

Ou seja:

x2−4=0x^2 - 4 = 0

possui as soluções:

x=−2x = -2

e

x=2x = 2

6. Derivadas

Essa é uma das funcionalidades mais interessantes para quem estuda Machine Learning e Deep Learning.

Considere:

f(x)=x3+2x2+xf(x) = x^3 + 2x^2 + x

Podemos calcular a derivada:

x = sp.Symbol("x")
 
f = x**3 + 2*x**2 + x
 
sp.diff(f, x)

Resultado:

3*x**2 + 4*x + 1

Matematicamente:

dfdx=3x2+4x+1\frac{df}{dx} = 3x^2 + 4x + 1

Podemos inclusive calcular derivadas de ordem superior:

sp.diff(f, x, 2)

Isso calcula:

d2fdx2\frac{d^2f}{dx^2}

7. Por que isso é importante para Deep Learning?

Redes neurais dependem fortemente de derivadas e gradientes.

Uma representação simplificada:

O processo de backpropagation depende da regra da cadeia.

Por exemplo:

L=(y−y^)2L = (y-\hat{y})^2

e:

y^=wx+b\hat{y}=wx+b

O SymPy pode nos ajudar a derivar matematicamente:

w, x, b, y = sp.symbols("w x b y")
 
y_hat = w*x + b
 
loss = (y - y_hat)**2
 
sp.diff(loss, w)

O resultado representa:

∂L∂w\frac{\partial L}{\partial w}

Isso é exatamente o tipo de matemática que está por trás da atualização dos pesos de uma rede neural.


8. Integrais com SymPy

O SymPy também possui suporte para integração simbólica.

Por exemplo:

x = sp.Symbol("x")
 
sp.integrate(sp.cos(x), x)

Resultado:

sin(x)

O material oficial do SymPy também demonstra a utilização de integrate() para integrais indefinidas e definidas.

Para uma integral definida:

sp.integrate(
    sp.exp(-x),
    (x, 0, sp.oo)
)

Resultado:

1

O sp.oo representa infinito no SymPy.


9. Limites

Também podemos calcular limites:

x = sp.Symbol("x")
 
sp.limit(sp.sin(x) / x, x, 0)

Resultado:

1

Ou seja:

lim⁡x→0sin⁡(x)x=1\lim_{x\rightarrow0}\frac{\sin(x)}{x}=1

O SymPy fornece uma função específica limit() para esse tipo de cálculo.


10. Séries de Taylor

Outra funcionalidade muito interessante é a expansão em séries.

Por exemplo:

x = sp.Symbol("x")
 
expr = sp.exp(sp.sin(x))
 
expr.series(x, 0, 4)

Podemos obter uma aproximação da função próxima de determinado ponto. O SymPy utiliza a notação de ordem O(...) para representar os termos que foram omitidos.

Isso é particularmente útil em:

  • análise matemática;
  • aproximações;
  • física;
  • métodos numéricos;
  • análise de algoritmos.

11. Diferenças finitas

O SymPy também possui ferramentas para trabalhar com diferenças finitas.

Por exemplo:

f = sp.Function("f")
 
dfdx = f(x).diff(x)
 
dfdx.as_finite_difference()

Isso gera uma aproximação da derivada utilizando valores discretos da função.

Essa ideia é importante em áreas como:

  • métodos numéricos;
  • simulação;
  • física computacional;
  • equações diferenciais;
  • engenharia.

12. E o SciPy?

Agora entramos no segundo componente do nosso conjunto de ferramentas.

import numpy as np
import scipy

O SciPy normalmente trabalha em conjunto com o NumPy.

Podemos visualizar a relação:


13. Integração numérica com SciPy

Considere:

∫0πsin⁡(x)dx\int_0^\pi \sin(x)dx

Podemos calcular numericamente:

import numpy as np
from scipy.integrate import quad
 
resultado, erro = quad(
    lambda x: np.sin(x),
    0,
    np.pi
)
 
print(resultado)

Resultado aproximado:

2.0

Aqui existe uma diferença conceitual importante.

Com SymPy podemos tentar obter a expressão matemática.

Com SciPy normalmente estamos interessados no resultado numérico.


14. Otimização

Uma das funcionalidades extremamente importantes do SciPy para Machine Learning é:

scipy.optimize

Por exemplo:

from scipy.optimize import minimize
 
def funcao(x):
    return (x - 3)**2
 
resultado = minimize(funcao, x0=0)
 
print(resultado.x)

O algoritmo procura o valor de x que minimiza a função.

Visualmente:

Esse conceito está diretamente relacionado a uma das ideias fundamentais de Machine Learning:

encontrar parâmetros que minimizem uma função de custo.


15. SymPy + SciPy + NumPy

As três bibliotecas podem trabalhar juntas.

Por exemplo:

Um fluxo possível:

import sympy as sp
import numpy as np
from scipy.optimize import minimize

Primeiro podemos utilizar SymPy para estudar a matemática.

Depois NumPy para trabalhar com arrays.

Finalmente SciPy para algoritmos científicos.


16. Convertendo SymPy para funções Python

Uma funcionalidade muito útil é lambdify().

Por exemplo:

x = sp.Symbol("x")
 
f = x**2 + 2*x + 1
 
f_numpy = sp.lambdify(x, f, "numpy")

Agora podemos utilizar a expressão com NumPy:

valores = np.array([0, 1, 2, 3, 4])
 
resultado = f_numpy(valores)
 
print(resultado)

Isso cria uma ponte interessante:


17. Quando usar cada biblioteca?

ProblemaBiblioteca
Resolver equações simbolicamenteSymPy
Derivar uma expressãoSymPy
Calcular uma integral simbólicaSymPy
Calcular limitesSymPy
Expandir sériesSymPy
Trabalhar com arraysNumPy
Otimização numéricaSciPy
Estatística científicaSciPy
Integração numéricaSciPy
Álgebra linear numéricaSciPy + NumPy
Processamento de sinaisSciPy
Deep LearningPyTorch / JAX / TensorFlow
Estudar a matemática do Deep LearningSymPy + NumPy

18. Exemplo completo no Jupyter Notebook

Podemos criar um pequeno notebook para estudar uma função.

Célula 1 — Imports

import sympy as sp
import numpy as np
import matplotlib.pyplot as plt

Célula 2 — Criar função simbólica

x = sp.Symbol("x")
 
f = x**3 - 3*x**2 + 2
f

Célula 3 — Derivada

df = sp.diff(f, x)
 
df

Célula 4 — Encontrar pontos críticos

sp.solve(df, x)

Célula 5 — Converter para NumPy

f_numpy = sp.lambdify(x, f, "numpy")

Célula 6 — Gerar dados

xs = np.linspace(-2, 5, 500)
 
ys = f_numpy(xs)

Célula 7 — Visualizar

plt.plot(xs, ys)
plt.xlabel("x")
plt.ylabel("f(x)")
plt.title("Função")
plt.show()

Esse é um excelente exemplo de integração entre:

SymPy
  ↓
Matemática simbólica
 
NumPy
  ↓
Computação numérica
 
Matplotlib
  ↓
Visualização

19. E no Deep Learning?

Para quem está estudando Deep Learning, uma arquitetura de aprendizado interessante seria:

O objetivo não é substituir PyTorch por SymPy ou SciPy.

Cada biblioteca possui uma função diferente.

SymPy ajuda a entender e manipular a matemática.

NumPy fornece computação numérica baseada em arrays.

SciPy fornece algoritmos científicos numéricos.

PyTorch/JAX adicionam autodiff, aceleradores e ferramentas para Machine Learning.


20. Resumo

A distinção fundamental é:

                 MATEMÁTICA COMPUTACIONAL
                          │
             ┌────────────┴────────────┐
             │                         │
        SIMBÓLICA                   NUMÉRICA
             │                         │
          SymPy                 NumPy / SciPy
             │                         │
       "Qual é a fórmula?"       "Qual é o valor?"
             │                         │
       Derivadas                    Arrays
       Integrais                    Otimização
       Limites                      Estatística
       Equações                     Integração
       Álgebra                      Sinais

Se você está entrando em Machine Learning/Deep Learning, uma combinação muito útil para estudar é:

SymPy
  +
NumPy
  +
SciPy
  +
Matplotlib
  +
PyTorch

Ela permite passar de matemática → implementação numérica → visualização → Machine Learning.

SymPy ajuda você a entender a matemática. NumPy ajuda você a representar os dados numericamente. SciPy fornece algoritmos científicos. PyTorch/JAX permitem transformar esses conceitos em modelos de Deep Learning.