Python SciPy statsmodels na prática: o código e os comandos que realmente importam

Python SciPy statsmodels : o essencial em um artigo — código real, diagramas e etapas concretas, trechos de um curso de 37 lições.

Python SciPy statsmodels na prática: o código e os comandos que realmente importam

Sem teoria interminável aqui: abra o terminal e pratique. Aqui está o essencial de Python SciPy statsmodels, extraído diretamente de um curso completo de 37 lições — com código real que você pode copiar e colar agora.

tl;dr
  • Introdução e Instalação
  • Revisão NumPy para SciPy
  • Descobrindo SciPy
  • Estatísticas descritivas com scipy.stats
  • Testes estatísticos com SciPy
~$ cat ./parcours.md # Python SciPy statsmodels — 10 capítulos
01
Introdução e Instalação
→ Apresentação do curso→ Instalar Python e as bibliotecas+ 1 mais lições
02
Revisão NumPy para SciPy
→ Os arrays NumPy, o bloco fundamental→ O que podemos fazer com um array NumPy+ 1 mais lições
03
Descobrindo SciPy
→ O que é SciPy e para que serve?→ Organização dos módulos scipy.stats+ 1 mais lições
04
Estatísticas descritivas com scipy.stats
→ Média, mediana e moda→ Variância, desvio padrão e dispersão+ 1 mais lições
05
Testes estatísticos com SciPy
→ Introdução aos testes estatísticos e ao valor-p→ Teste t de Student — comparar duas médias+ 2 mais lições
06
Introdução ao Statsmodels
→ O que é Statsmodels e em que difere do SciPy?→ Carregar dados e explorar os conjuntos integrados+ 1 mais lições
07
Regressão linear com Statsmodels
→ Teoria da regressão linear explicada de forma simples→ Regressão linear simples com Statsmodels+ 2 mais lições
08
Regressão logística com Statsmodels
→ Teoria da regressão logística→ Regressão logística na prática com Statsmodels+ 1 mais lições
🏁
Projeto final (+ 2 capítulos no caminho)
→ Você sai com um projeto concreto e demonstrável

Prevendo o futuro com ARIMA

NOTEO que você vai aprender — ARIMA é um modelo que aprende tendências do passado para prever o futuro. Vamos ver como funciona, como configurá-lo e como usá-lo para gerar uma previsão.

O que vamos ver nesta lição

O que é ARIMA, em termos simples?

ARIMA é um algoritmo de previsão. Ele observa os valores do passado e tenta deduzir o que vai acontecer no futuro.

TIPAnalogia — Imagine um meteorologista. Para prever a temperatura de amanhã, ele observa a temperatura dos últimos dias. Se os 3 últimos dias foram 18, 20, 22 graus (tendência de alta), ele provavelmente preverá 24 amanhã. ARIMA faz o mesmo, mas usando matemática precisa.

O nome completo é Auto-Regressive Integrated Moving Average. É um nome complicado, mas o conceito é simples: o modelo se baseia nos valores passados e nos erros de previsão passados para estimar o próximo valor.

Os 3 parâmetros do ARIMA: p, d, q

Escrevemos ARIMA(p, d, q). Cada letra tem um papel preciso.

ParâmetroSignificadoExemplo simples
p Quantos valores passados usamos para prever p=2 : observamos os 2 últimos meses
d Quantas vezes transformamos a série para estabilizá-la d=1 : na maioria das vezes, d=1 é suficiente
q Quantos erros passados usamos para corrigir a previsão q=1 : levamos em conta o último erro
TIPDica para iniciantes — Comece sempre com ARIMA(1, 1, 1). É a configuração básica que funciona bem na maioria dos casos. Você poderá testar outros valores depois, se necessário.
NOTEPara que serve o d? — A maioria das séries reais tem uma tendência (as vendas aumentam todo ano, por exemplo). O ARIMA precisa que a série seja « estável » (sem tendência) para funcionar. O parâmetro d transforma a série para torná-la estável. d=1 significa que calculamos as diferenças entre valores consecutivos.

Construindo o modelo ARIMA passo a passo

Retomamos nossa série de vendas mensais de 4 anos. Vamos usar os 38 primeiros meses para treinar o modelo e os 10 últimos meses para verificar se as previsões estão boas.

output
import pandas as pd
import numpy as np
from statsmodels.tsa.arima.model import ARIMA

# --- Recriar a série de vendas mensais ---
np.random.seed(42)
dates = pd.date_range(start="2020-01", periods=48, freq="ME")
tendance = np.arange(48) * 1.0
mois = dates.month
saisonnalite = 10 * np.sin(2 * np.pi * (mois - 3) / 12)
bruit = np.random.normal(0, 3, 48)
ventes = 100 + tendance + saisonnalite + bruit
serie = pd.Series(ventes, index=dates, name="Ventes")

# --- Dividir: 38 meses para aprender, 10 meses para testar ---
train = serie.iloc[:38]   # dados de treinamento
test  = serie.iloc[38:]   # dados de teste (o futuro conhecido)

print(f"Treinamento : {len(train)} meses")
print(f"Teste       : {len(test)} meses")
output
# --- Criar e ajustar o modelo ---
# order=(p, d, q) = (1, 1, 1) : configuração básica
modele = ARIMA(train, order=(1, 1, 1))
resultat = modele.fit()

# Exibir um resumo curto
print(f"AIC do modelo : {resultat.aic:.2f}")
print("Modelo ajustado com sucesso!")
TIPAIC = Akaike Information Criterion. É uma pontuação que mede a qualidade do modelo. Quanto menor, melhor. Usamos para comparar vários modelos ARIMA entre si.

Gerar uma previsão

Agora que treinamos o modelo, pedimos que preveja os próximos 10 meses.

output
# Gerar uma previsão para 10 meses
prevision = resultat.forecast(steps=10)

# Comparar previsão vs valores reais
comparaison = pd.DataFrame({
    "Real"     : test.values.round(1),
    "Previsao" : prevision.values.round(1),
    "Erro"     : (test.values - prevision.values).round(1)
}, index=test.index)

print(comparaison)
NOTEComo ler esta tabela?
  • Real : as vendas reais desses meses (o que escondemos do modelo durante o treinamento)
  • Previsao : o que o modelo ARIMA previu
  • Erro : a diferença. Um erro próximo de 0 é bom. Um erro grande significa que a previsão foi ruim.

Medir a qualidade da previsão

Para saber se nosso modelo prevê bem, calculamos o erro médio absoluto (MAE). É simplesmente a média dos erros, sem considerar o sinal (positivo ou negativo).

output
mae = np.abs(test.values - prevision.values).mean()
print(f"Erro médio absoluto (MAE) : {mae:.1f} unidades")
print(f"Média das vendas reais    : {test.mean():.1f} unidades")
print(f"Erro relativo             : {mae / test.mean() * 100:.1f}%")
TIPInterpretação — O modelo erra em média 9,1 unidades, em vendas médias de 141. Isso representa um erro de 6,4%. Para um modelo básico ARIMA(1,1,1), é aceitável. Poderíamos melhorar testando outros valores de p e q.

Prever o futuro além dos dados disponíveis

Na vida real, você não tem dados de teste para comparar. Quer apenas prever os próximos meses.

Primeiro script SciPy

NOTEObjetivo — Escrever e executar seu primeiro script usando SciPy. Você vai calcular estatísticas simples em um conjunto de dados fictício, ver como o SciPy é usado e garantir que tudo funcione antes de avançar.

Objetivos pedagógicos

TIPAo final deste módulo — Você terá executado seu primeiro script SciPy, entenderá a estrutura de um script de análise e estará à vontade para passar aos capítulos seguintes.

A estrutura de um script de análise típico

Todo script de análise de dados em Python segue um esquema semelhante. Aprender esse esquema agora vai ajudar em todos os capítulos seguintes.

Esquema geral

Cenário: analisar as notas de um curso

Você é professor. Tem as notas de 20 alunos em 100. Quer entender:

Etapa 1: os imports

A primeira coisa a fazer em todo script é importar as bibliotecas. Veja por que as importamos com aliases:

output
import numpy as np                   # np é mais curto de escrever que numpy
from scipy import stats              # importamos apenas o módulo stats do SciPy
import matplotlib.pyplot as plt      # plt é o alias padrão para plotar gráficos
NOTEPor que from scipy import stats e não import scipy? — O SciPy é dividido em submódulos. Importar apenas stats é mais eficiente porque carregamos apenas o que precisamos. Depois escrevemos stats.mean() em vez de scipy.stats.mean().

Etapa 2: criar os dados

output
notes = np.array([
    72, 85, 91, 63, 78, 55, 88, 94, 70, 82,
    66, 79, 87, 61, 90, 75, 83, 68, 77, 95
])

print("Número de alunos :", len(notes))
print("Notas            :", notes)
TIPnp.array() — Esta função cria um array NumPy a partir de uma lista Python. Um array NumPy se parece com uma lista Python, mas é muito mais poderoso para cálculos matemáticos. O SciPy sempre trabalha com arrays NumPy.

Etapa 3: calcular as estatísticas com scipy.stats

output
moyenne = np.mean(notes)
mediane = np.median(notes)
ecart_type = np.std(notes)
minimum = np.min(notes)
maximum = np.max(notes)

print(f"Média      : {moyenne:.2f}")
print(f"Mediana    : {mediane:.2f}")
print(f"Desvio-padrão : {ecart_type:.2f}")
print(f"Mínimo     : {minimum}")
print(f"Máximo     : {maximum}")

Etapa 4: usar scipy.stats para ir mais longe

O NumPy calcula as estatísticas básicas. O SciPy vai além adicionando medidas como a assimetria (skewness) e o achatamento (kurtosis), que indicam a forma da distribuição.

output
asymetrie = stats.skew(notes)
aplatissement = stats.kurtosis(notes)
description = stats.describe(notes)

print(f"Assimetria (skewness) : {asymetrie:.4f}")
print(f"Achatamento (kurt)    : {aplatissement:.4f}")
print()
print("Descrição completa por scipy.stats.describe() :")
print(description)

Etapa 5: interpretar os resultados

EstatísticaValorO que significa
Média77.95Em média, os alunos têm quase 78/100
Mediana78.50Metade dos alunos tem menos de 78,5 e a outra metade mais
Desvio-padrão11.32As notas variam cerca de 11 pontos em torno da média
Assimetria (-0.25)LeveA distribuição é quase simétrica (leve concentração nas notas altas)
Achatamento (-0.88)NegativoDistribuição um pouco mais plana que a normal (platykúrtica)
NOTEMédia vs mediana — A média (77,95) e a mediana (78,50) são muito próximas aqui. Isso indica que não há valores extremos que “puxam” a média para cima ou para baixo. Quando a média e a mediana são muito diferentes, isso frequentemente sinaliza valores aberrantes (outliers).

Etapa 6: visualizar (bônus)

output
plt.figure(figsize=(8, 4))
plt.hist(notes, bins=8, color='steelblue', edgecolor='white', alpha=0.8)
plt.axvline(moyenne, color='red', linestyle='--', label=f'Média ({moyenne:.1f})')
plt.axvline(mediane, color='orange', linestyle='-', label=f'Mediana ({mediane:.1f})')
plt.xlabel("Nota sobre 100")
plt.ylabel("Número de alunos")
plt.title("Distribuição das notas da turma")
plt.legend()
plt.tight_layout()
plt.show()
TIPplt.axvline() — Esta função traça uma linha vertical no gráfico. É útil para marcar a média ou a mediana em um histograma.

O que podemos fazer com um array NumPy

NOTEO que você vai aprender — Como ler um valor preciso em um array, como manter apenas certos valores e como fazer cálculos em todo um array de uma só vez.

O que vamos ver nesta lição

Ler um valor preciso em um array

Imagine que seu array é uma fileira de caixas numeradas. A primeira caixa é numerada 0, não 1. Essa é a convenção em Python. A segunda caixa é 1, a terceira é 2, e assim por diante.

TIPAnalogia — É como os andares de um prédio na Europa: o rés-do-chão é o andar 0. O primeiro andar é 1. Em Python, contamos da mesma forma.

Também podemos contar a partir do fim com números negativos. -1 dá o último elemento, -2 o penúltimo, etc.

output
import numpy as np

# Um array de 7 temperaturas da semana
temperatures = np.array([18.5, 22.1, 19.8, 25.3, 21.0, 17.2, 23.4])
#                          [0]   [1]   [2]   [3]   [4]   [5]   [6]

print( temperatures[0] )   # 18.5  -> segunda (1º valor)
print( temperatures[2] )   # 19.8  -> quarta (3º valor)
print( temperatures[-1] )  # 23.4  -> domingo (último valor)
print( temperatures[-2] )  # 17.2  -> sábado (penúltimo)

Selecionar vários valores seguidos

Se quiser pegar um pedaço do array, use a notação início:fim. Atenção: o valor de fim é excluído. Se escrever [1:4], obtém as caixas 1, 2 e 3, mas não a caixa 4.

TIPAnalogia — É como cortar um pão. Se disser « me dê do pedaço 1 ao pedaço 4 », o padeiro dá os pedaços 1, 2, 3. O pedaço 4 fica na loja.
output
temperatures = np.array([18.5, 22.1, 19.8, 25.3, 21.0, 17.2, 23.4])

# Os 3 primeiros dias (segunda, terça, quarta)
print( temperatures[:3] )     # início omitido = desde o início

# Da terça à sexta (índice 1 a 4, 4 excluído)
print( temperatures[1:4] )

# Os 2 últimos dias
print( temperatures[-2:] )    # fim omitido = até o fim

# Um dia sim, outro não (segunda, quarta, sexta, domingo)
print( temperatures[::2] )

Manter apenas os valores que satisfazem uma condição

Essa é uma das coisas mais poderosas do NumPy. Você pode dizer « me dê apenas as temperaturas superiores a 21 graus » e o NumPy faz a seleção automaticamente.

Veja como funciona em 2 etapas:

output
temperatures = np.array([18.5, 22.1, 19.8, 25.3, 21.0, 17.2, 23.4])

# Etapa 1: qual dia está acima de 21 graus?
masque = temperatures > 21
print("Máscara :", masque)
# True onde for superior a 21, False caso contrário

# Etapa 2: manter apenas esses valores
print("Dias > 21 graus :", temperatures[masque])

# Também podemos fazer as duas etapas em uma única linha:
print("Dias < 20 graus :", temperatures[temperatures < 20])
NOTEComo ler a máscara? — A máscara tem o mesmo tamanho do array. Para cada valor do array, ela diz True (sim, esse valor satisfaz a condição) ou False (não). O NumPy mantém apenas as posições marcadas como True.

Fazer cálculos matemáticos em todo o array

O NumPy oferece funções matemáticas que se aplicam a cada elemento ao mesmo tempo. Não precisa de loop. Você escreve uma única linha e o NumPy faz o cálculo em todos os valores.

output
data = np.array([4.0, 9.0, 16.0, 25.0])

# np.sqrt = raiz quadrada de cada valor
print("Raiz quadrada :", np.sqrt(data))

# np.log = logaritmo natural de cada valor
print("Logaritmo     :", np.round(np.log(data), 2))

# np.abs = valor absoluto (remove o sinal negativo)
nombres = np.array([-3, 5, -7, 2])
print("Valor absoluto:", np.abs(nombres))

Calcular estatísticas em todo o array

Essas funções resumem um array em um único número:

output
ventes = np.array([1200, 850, 1500, 970, 1100, 1350, 780])

print("Total da semana :", np.sum(ventes))
print("Média diária    :", np.mean(ventes).round(1))
print("Dia mais alto   :", np.max(ventes))
print("Dia mais baixo  :", np.min(ventes))

# cumsum : total cumulativo dia a dia
print("Acumulado dia a dia :", np.cumsum(ventes))
TIPPara que serve cumsum? — cumsum significa « soma cumulativa ». Cada valor exibido é o total desde o início. Aqui: segunda = 1200, segunda+terça = 2050, segunda+terça+quarta = 3550, etc. Útil para acompanhar um faturamento que se acumula.

Aplicar um cálculo em todas as valores ao mesmo tempo

Em Python normal, se quiser adicionar 10% a cada preço de uma lista, você escreve um loop. Com NumPy, não precisa. Escreve a operação uma única vez e ela se aplica a todos os valores. Isso se chama broadcasting.

TIPAnalogia — Imagine um ano de aumento de preços. Todos os preços da sua lista são aumentados em 20%. Com NumPy, você multiplica o array inteiro por 1,20 em uma única linha. Sem NumPy, teria de escrever um loop percorrendo cada preço individualmente.
va-plus-loin

Este artigo cobre os trechos mais úteis — o curso completo Python SciPy statsmodels (11 capítulos, 37 lições, exercícios corrigidos e projeto final) leva você até o fim.

./acceder-au-cours-complet curso gratuito : Dominando o Claude Code

FAQ

Quanto tempo para aprender Python SciPy statsmodels?
Com uma progressão estruturada (11 capítulos, 37 lições curtas e práticas), alcançamos um nível operacional em algumas semanas, dedicando 30 a 60 minutos por dia. O importante é praticar cada conceito imediatamente.
É preciso ter pré-requisitos?
Básicos de informática são suficientes. Se você sabe usar um terminal e ler código simples, está pronto.
Por onde começar concretamente?
Reproduza os comandos deste artigo e depois siga o curso completo Python SciPy statsmodels: ele encadeia as 37 lições em ordem, com exercícios e projeto final.

📬 Quer receber este tipo de guia toda semana? Inscreva-se gratuitamente — código real, zero enrolação.