Tutorial do SciPy — Computação Científica em Python

SciPy (Scientific Python) é uma biblioteca de código aberto que se baseia no NumPy e adiciona uma grande coleção de algoritmos para matemática, ciência e engenharia. Enquanto o NumPy fornece o ndarray e operações básicas, o SciPy oferece os solvers especializados: integração numérica, otimização, interpolação, processamento de sinais, estatísticas, algoritmos espaciais e muito mais.

Este capítulo abrange:

Instalação do SciPy e convenção de importação
Álgebra linear (scipy.linalg)
Integração e diferenciação numéricas (scipy.integrate)
Otimização — encontrando mínimos e raízes (scipy.optimize)
Interpolação (scipy.interpolate)
Estatísticas (scipy.stats)
Processamento de imagens N-dimensional (scipy.ndimage)

Instalando o SciPy

O SciPy está incluído na distribuição Anaconda. Para instalá-lo com pip:

pip install scipy

O SciPy depende do NumPy, que o pip instala automaticamente caso ainda não esteja presente.

Convenção de importação

O SciPy é organizado em sub-pacotes. Importe apenas os sub-pacotes necessários em vez de toda a biblioteca:

import numpy as np
from scipy import linalg, integrate, optimize, interpolate, stats, ndimage

Você também pode verificar a versão instalada:

import scipy
print(scipy.__version__)  # e.g. 1.13.0

Álgebra Linear

scipy.linalg estende as rotinas de álgebra linear do NumPy com decomposições e solvers adicionais. Todas as funções operam em arrays NumPy comuns.

Determinante e inversa

import numpy as np
from scipy import linalg

a = np.array([[1, 2],
              [3, 4]])

det = linalg.det(a)
print(det)          # -2.0

inv = linalg.inv(a)
print(inv)
# [[-2.   1. ]
#  [ 1.5 -0.5]]

det([[1,2],[3,4]]) = 1×4 − 2×3 = −2. A inversa satisfaz a @ inv == I.

Autovalores e autovetores

Os autovalores descrevem como uma matriz estica o espaço; os autovetores fornecem as direções que não sofrem rotação.

import numpy as np
from scipy import linalg

a = np.array([[1, 2],
              [3, 4]])

eigenvalues, eigenvectors = linalg.eig(a)
print(eigenvalues)
# [-0.37228132+0.j  5.37228132+0.j]
print(eigenvectors)
# [[-0.82456484 -0.41597356]
#  [ 0.56576746 -0.90937671]]

Cada coluna de eigenvectors corresponde ao autovalor correspondente. Os autovalores são retornados como números complexos mesmo quando a parte imaginária é zero.

Decomposição em Valores Singulares (SVD)

O SVD fatoriza uma matriz A em três matrizes U, s, Vt tal que A = U @ diag(s) @ Vt. É a base da análise de componentes principais (PCA) e de muitas técnicas de redução de dimensionalidade.

import numpy as np
from scipy import linalg

a = np.array([[1, 2],
              [3, 4]])

u, s, vt = linalg.svd(a)
print(u)
# [[-0.40455358 -0.9145143 ]
#  [-0.9145143   0.40455358]]
print(s)    # [5.4649857  0.36596619]
print(vt)
# [[-0.57604844 -0.81741556]
#  [ 0.81741556 -0.57604844]]

Resolução de um sistema linear

linalg.solve é a forma correta de resolver Ax = b. É mais rápido e numericamente mais estável do que calcular a inversa e multiplicar.

import numpy as np
from scipy import linalg

# Solve: 1x + 2y = 5
#        3x + 4y = 11
A = np.array([[1, 2],
              [3, 4]])
b = np.array([5, 11])

x = linalg.solve(A, b)
print(x)   # [1. 2.]

# Verify: A @ x should equal b
print(np.allclose(A @ x, b))  # True

Integração Numérica

scipy.integrate fornece rotinas para calcular integrais definidas quando uma solução analítica é impraticável.

Integração de variável única com `quad`

integrate.quad usa quadratura adaptativa para integrar uma função em um intervalo. Retorna o resultado e uma estimativa do erro absoluto.

import numpy as np
from scipy import integrate

# Integrate f(x) = x^2 + 2x + 1 from 0 to 1
# Analytical result: [x^3/3 + x^2 + x] from 0 to 1 = 1/3 + 1 + 1 = 7/3
def f(x):
    return x**2 + 2*x + 1

result, error = integrate.quad(f, 0, 1)
print(result)   # 2.3333333333333335
print(error)    # ~2.6e-14  (absolute error estimate)

Diferenciação numérica

approx_fprime do SciPy calcula um gradiente por diferenças finitas. Para funções escalares, a derivative por diferença central de scipy.misc é mais simples:

import numpy as np
from scipy.optimize import approx_fprime

# Derivative of sin(x) at x = 0 should be cos(0) = 1
result = approx_fprime([0.0], lambda x: np.sin(x[0]), 1e-8)
print(result[0])   # ~1.0

Otimização

scipy.optimize encontra mínimos, máximos (minimizando o negativo) e raízes de funções.

Minimizando uma função multivariada

optimize.minimize suporta muitos métodos (Nelder-Mead, BFGS, L-BFGS-B, …). O método padrão é escolhido automaticamente.

from scipy import optimize

# Minimize f(x) = x^2 + 2x + 1 = (x + 1)^2  — minimum at x = -1
def f(x):
    return x**2 + 2*x + 1

result = optimize.minimize(f, x0=0)   # x0 is the starting guess
print(result.success)   # True
print(result.x)         # [-1.00000001]  (near -1)
print(result.fun)       # ~0.0           (minimum value)

Minimizando uma função escalar em um intervalo limitado

optimize.minimize_scalar é mais simples para problemas de uma variável. Sempre forneça bounds com method='bounded' quando a função não tem mínimo global (ou seja, é ilimitada):

from scipy import optimize

# Minimize h(x) = x^2 - 4x + 3 over [0, 4]  — minimum at x = 2, h(2) = -1
def h(x):
    return x**2 - 4*x + 3

result = optimize.minimize_scalar(h, bounds=(0, 4), method='bounded')
print(result.x)     # ~2.0
print(result.fun)   # -1.0

Encontrando raízes

optimize.root_scalar encontra onde uma função cruza zero:

from scipy.optimize import root_scalar

# Solve x^2 - 4 = 0 in the interval [0, 3]  — root at x = 2
res = root_scalar(lambda x: x**2 - 4, bracket=[0, 3])
print(res.root)     # 2.0

Interpolação

scipy.interpolate ajusta uma curva suave através de pontos de dados para que você possa estimar valores entre eles.

Interpolação 1-D

interp1d cria uma função de interpolação chamável a partir de pares discretos (x, y). O parâmetro kind seleciona o método: 'linear' (padrão), 'quadratic' ou 'cubic'.

import numpy as np
from scipy.interpolate import interp1d

# Sample points from y = x^2
x = np.array([0, 1, 2, 3, 4])
y = np.array([0, 1, 4, 9, 16])

f_linear = interp1d(x, y)           # piecewise linear
f_cubic  = interp1d(x, y, kind='cubic')  # cubic spline

# Estimate y at x = 2.5  (exact value: 2.5^2 = 6.25)
print(float(f_linear(2.5)))   # 6.5   (linear — slightly off)
print(float(f_cubic(2.5)))    # 6.25  (cubic — matches exactly for polynomials)

A interpolação cúbica recupera o resultado exato porque os dados provêm de um polinômio quadrático, e o spline cúbico é flexível o suficiente para ajustá-lo perfeitamente.

Estatísticas

scipy.stats contém mais de 80 distribuições de probabilidade contínuas e discretas, além de uma coleção de testes estatísticos.

Estatísticas descritivas e distribuição normal

import numpy as np
from scipy.stats import norm

# Standard normal distribution (mean=0, std=1)
print(norm.pdf(0))     # 0.3989422804014327  — probability density at x = 0
print(norm.cdf(1.96))  # 0.9750021048517795  — P(X <= 1.96)
print(norm.ppf(0.975)) # 1.9599639845400536  — inverse CDF (quantile function)

# Fit a normal distribution to data
data = np.array([2.1, 3.3, 2.8, 3.1, 2.5, 3.0, 2.7])
mu, sigma = norm.fit(data)
print(f'Fitted mean: {mu:.4f}, std: {sigma:.4f}')

Testes de hipótese

scipy.stats inclui testes t, testes qui-quadrado, ANOVA, testes de Kolmogorov-Smirnov e muito mais.

import numpy as np
from scipy.stats import ttest_1samp, ttest_ind

# One-sample t-test: is the sample mean significantly different from 5?
sample = np.array([4.8, 5.1, 4.9, 5.3, 5.2, 4.7, 5.0])
t_stat, p_value = ttest_1samp(sample, popmean=5.0)
print(f't = {t_stat:.4f}, p = {p_value:.4f}')
# p > 0.05 → no significant difference from 5

# Two-sample t-test: are these two groups different?
group_a = np.array([5.1, 5.3, 4.9, 5.2, 5.0])
group_b = np.array([6.1, 6.3, 5.8, 6.0, 5.9])
t_stat2, p_value2 = ttest_ind(group_a, group_b)
print(f't = {t_stat2:.4f}, p = {p_value2:.6f}')
# Very small p → groups are significantly different

Variáveis aleatórias e amostragem

Cada distribuição em scipy.stats expõe a mesma interface: pdf, cdf, ppf, rvs (variáveis aleatórias) e fit.

from scipy.stats import norm, poisson

# Draw 5 samples from a normal distribution with mean=10, std=2
samples = norm.rvs(loc=10, scale=2, size=5, random_state=42)
print(samples.round(2))   # [10.99  9.72 11.3  13.05  9.53]

# Poisson distribution: P(X = k) for mean lambda=3
for k in range(6):
    print(f'P(X={k}) = {poisson.pmf(k, mu=3):.4f}')

Processamento de Imagens N-Dimensional

scipy.ndimage opera em arrays de qualquer dimensionalidade (imagens, volumes, cubos de séries temporais). Abaixo está um exemplo autocontido que usa um array 2-D sintético, sem necessidade de arquivo de imagem externo.

Desfoque gaussiano e rotulação de regiões conectadas

import numpy as np
from scipy import ndimage

# Create a synthetic 5x5 "image" with a bright spot in the centre
image = np.array([
    [0, 0, 0, 0, 0],
    [0, 1, 1, 1, 0],
    [0, 1, 5, 1, 0],
    [0, 1, 1, 1, 0],
    [0, 0, 0, 0, 0],
], dtype=float)

# Smooth the image with a Gaussian filter (sigma controls the blur radius)
blurred = ndimage.gaussian_filter(image, sigma=1)
print('Center value after blur:', round(blurred[2, 2], 4))
# 1.4166  — the bright peak is spread across neighbouring pixels

# Label connected non-zero regions (like counting distinct objects)
binary = image > 0
labeled, num_regions = ndimage.label(binary)
print('Number of connected regions:', num_regions)  # 1
print(labeled)
# [[0 0 0 0 0]
#  [0 1 1 1 0]
#  [0 1 1 1 0]
#  [0 1 1 1 0]
#  [0 0 0 0 0]]

Operações comuns do `ndimage`

Função	O que faz
`gaussian_filter(a, sigma)`	Suaviza com um kernel gaussiano
`sobel(a)`	Detecta bordas (gradiente de Sobel)
`label(a)`	Rotula regiões conectadas em um array binário
`binary_dilation(a)`	Expande regiões de primeiro plano
`zoom(a, factor)`	Redimensiona um array
`rotate(a, angle)`	Rotaciona um array (em graus)

Quando Usar SciPy vs. Outras Bibliotecas

Tarefa	Ferramenta preferida
Criação de arrays e matemática básica	NumPy
DataFrames, séries temporais, I/O	Pandas
Algoritmos científicos (integração, otimização)	SciPy
Aprendizado de máquina	scikit-learn (baseado em SciPy)
Visualização	Matplotlib

O SciPy não substitui o NumPy — ele depende do NumPy e o estende. Na prática, você importará ambos.

Referência Rápida

Sub-pacote	Funções principais
`scipy.linalg`	`det`, `inv`, `eig`, `svd`, `solve`
`scipy.integrate`	`quad`, `dblquad`, `solve_ivp`
`scipy.optimize`	`minimize`, `minimize_scalar`, `root_scalar`
`scipy.interpolate`	`interp1d`, `CubicSpline`, `griddata`
`scipy.stats`	`norm`, `ttest_1samp`, `ttest_ind`, `chi2_contingency`
`scipy.ndimage`	`gaussian_filter`, `label`, `sobel`, `zoom`
`scipy.signal`	`butter`, `lfilter`, `find_peaks`
`scipy.spatial`	`distance`, `KDTree`, `ConvexHull`