Introdução ao NumPy Python — 2026

O NumPy (Numerical Python) é a biblioteca fundamental para computação numérica em Python. Praticamente todo o ecossistema brasileiro de dados — do Pandas ao scikit-learn, passando pelo Matplotlib — foi construído sobre os arrays do NumPy. Se você quer seguir carreira em ciência de dados, engenharia de dados ou machine learning, dominar o NumPy é o primeiro passo obrigatório.

Neste tutorial prático, você vai aprender do zero como criar arrays, indexar e fatiar dados, filtrar informações, usar broadcasting e calcular agregações — tudo com exemplos de código que rodam de verdade. Se você só quer uma definição rápida do que é a biblioteca, confira nossa entrada no glossário de NumPy; aqui o foco é colocar a mão na massa.

Instalação e importação

A forma mais simples de instalar o NumPy é com o pip:

pip install numpy

Quem usa gerenciadores de pacotes modernos como o uv pode instalar com uv add numpy, que é consideravelmente mais rápido. Depois de instalar, importe a biblioteca usando o alias np, que é a convenção adotada por toda a comunidade:

import numpy as np

print(np.__version__)

Usar np não é obrigatório, mas é um padrão tão forte que qualquer outro nome dificulta a leitura do seu código por outros desenvolvedores Python.

Criando arrays

O objeto central do NumPy é o ndarray, um array multidimensional que armazena dados do mesmo tipo em um bloco contíguo de memória. A forma mais direta de criar um é a partir de uma lista Python:

import numpy as np

# Array unidimensional (vetor)
notas = np.array([8.5, 7.0, 9.2, 6.8, 8.0])
print(notas)
print(type(notas))

# Array bidimensional (matriz)
matriz = np.array([[1, 2, 3],
                   [4, 5, 6]])
print(matriz)

O NumPy também oferece funções utilitárias para criar arrays comuns de forma rápida, sem precisar digitar todos os valores:

zeros = np.zeros(5)            # [0. 0. 0. 0. 0.]
uns = np.ones((2, 3))          # matriz 2x3 preenchida com 1.0
sequencia = np.arange(0, 10, 2)  # [0 2 4 6 8]
espacado = np.linspace(0, 1, 5)  # [0.   0.25 0.5  0.75 1.  ]
aleatorio = np.random.rand(3)  # 3 números aleatórios entre 0 e 1

Essas funções aparecem o tempo todo na inicialização de modelos, na criação de dados sintéticos para testes e na montagem de tensores. Vale memorizar arange (intervalo com passo) e linspace (n pontos igualmente espaçados) — eles evitam loops manuais.

Atributos essenciais: shape, ndim e dtype

Todo array carrega metadados que descrevem sua estrutura. Os três mais usados no dia a dia são shape (formato), ndim (número de dimensões) e dtype (tipo de dados):

matriz = np.array([[1, 2, 3],
                   [4, 5, 6]])

print(matriz.shape)  # (2, 3) — 2 linhas e 3 colunas
print(matriz.ndim)   # 2 — duas dimensões
print(matriz.dtype)  # int64
print(matriz.size)   # 6 — total de elementos

Saber ler o shape é indispensável: a maioria dos erros em código de dados vem de um array com formato diferente do esperado. Sempre que algo der errado em uma operação, imprima o .shape de cada array envolvido antes de procurar o problema em outro lugar.

Indexação e fatiamento

O fatiamento (slicing) do NumPy segue a mesma sintaxe das listas Python, mas estendida para múltiplas dimensões e sem copiar os dados — ele retorna uma view, o que é muito mais eficiente em memória:

dados = np.array([[10, 20, 30, 40],
                  [50, 60, 70, 80],
                  [90, 100, 110, 120]])

print(dados[0, 1])        # 20 — linha 0, coluna 1
print(dados[1])           # [50 60 70 80] — segunda linha inteira
print(dados[:, 2])        # [30 70 110] — terceira coluna de todas as linhas
print(dados[0:2, 1:3])    # submatriz das linhas 0-1 e colunas 1-2

A vírgula separa as dimensões: dados[linhas, colunas]. O símbolo : sozinho significa “todos os elementos dessa dimensão”. Esse padrão [:, coluna] é o que você usará o tempo todo para extrair uma feature específica de um conjunto de dados.

Filtragem com máscaras booleanas

Um dos recursos mais poderosos do NumPy é a indexação booleana: você cria uma “máscara” de Verdadeiro/Falso e a usa para selecionar apenas os elementos que atendem a uma condição.

salarios = np.array([3500, 5200, 4800, 7100, 2900, 6300])

mascara = salarios > 5000
print(mascara)                 # [False  True False  True False  True]
print(salarios[mascara])       # [5200 7100 6300]

# Combinando condições com & (e) e | (ou)
print(salarios[(salarios > 4000) & (salarios < 7000)])  # [5200 4800 6300]

Compare isso com um loop for manual: uma linha substitui dez. Essa abordagem vetorizada é o coração do estilo “pensar em arrays inteiros” que torna o código NumPy tão conciso e rápido.

Operações vetorizadas e broadcasting

Operações matemáticas em arrays NumPy são vetorizadas — aplicadas elemento a elemento em código C otimizado, sem loops Python visíveis. Isso é o que torna a biblioteca tão rápida:

a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])

print(a + b)    # [11 22 33 44]
print(a * 2)    # [2 4 6 8]
print(b ** 2)   # [100 400 900 1600]
print(np.sqrt(a))  # [1.   1.41 1.73 2.  ]

O broadcasting leva isso adiante: permite operar entre arrays de formatos diferentes, “expandindo” o menor para compatibilizar. O exemplo clássico é somar um vetor a uma matriz:

matriz = np.array([[1, 2, 3],
                   [4, 5, 6]])
vetor = np.array([100, 200, 300])

print(matriz + vetor)
# [[101 202 303]
#  [104 205 306]]

O NumPy “replicou” o vetor ao longo das duas linhas sem precisar criar cópias. Entender o broadcasting evita loops duplicados e deixa o código muito mais limpo — quando funcionar naturalmente, use; quando o formato não bater, lembre de usar reshape para ajustar.

Agregações e estatísticas

Calcular médias, somas, máximos e desvios-padrão é trivial. Por padrão, essas funções operam sobre todos os elementos, mas o argumento axis permite agregar por linha ou por coluna:

vendas = np.array([[120, 150, 80],
                   [200, 90, 110],
                   [60, 230, 175]])

print(vendas.sum())             # 1315 — total geral
print(vendas.sum(axis=0))       # [380 470 365] — soma por coluna (por produto)
print(vendas.sum(axis=1))       # [350 400 465] — soma por linha (por vendedor)
print(vendas.mean())            # 146.1 — média geral
print(vendas.max(axis=1))       # [150 200 230] — maior venda de cada vendedor
print(vendas.std())             # desvio-padrão de todos os valores

A regra de bolso: axis=0 “colapsa” as linhas (agrega por coluna) e axis=1 “colapsa” as colunas (agrega por linha). Se confundir os eixos é o erro mais comum de quem está começando — imprima o resultado e confira se o número de valores bate com a dimensão esperada.

Redimensionamento com reshape

O reshape muda o formato de um array sem copiar os dados, desde que o total de elementos seja preservado. É essencial para preparar dados antes de treinar modelos ou desenhar gráficos:

vetor = np.arange(1, 13)          # 12 elementos
matriz3x4 = vetor.reshape(3, 4)   # 3 linhas, 4 colunas
matriz2x6 = vetor.reshape(2, 6)   # 2 linhas, 6 colunas

# O valor -1 calcula a dimensão automaticamente
coluna = vetor.reshape(-1, 1)     # matriz 12x1 (uma coluna)

Usar -1 em uma das dimensões é um truque útil: ele pede ao NumPy que calcule aquela dimensão sozinho a partir do tamanho total. Aparece o tempo todo ao converter um vetor 1D em uma coluna 2D para alimentar algoritmos do scikit-learn.

Mini-projeto: análise de notas

Vamos juntar tudo em um exemplo realista — calcular estatísticas de notas de uma turma, filtrar quem passou e ordenar o resultado:

import numpy as np

# Notas de 6 alunos em 3 provas
notas = np.array([
    [7.5, 8.0, 6.5],
    [4.0, 5.5, 6.0],
    [9.0, 8.5, 9.5],
    [6.0, 6.5, 7.0],
    [3.5, 4.0, 5.0],
    [8.0, 7.5, 8.5],
])

# Média de cada aluno (média das 3 provas)
medias = notas.mean(axis=1)
print("Médias:", medias)

# Quem foi aprovado (média >= 7.0)?
aprovados = medias[medias >= 7.0]
print("Aprovados:", aprovados)
print("Taxa de aprovação:", len(aprovados) / len(medias))

# Média geral da turma e nota mais alta
print("Média geral:", notas.mean())
print("Maior nota:", notas.max())

# Ranking das médias, do maior para o menor
print("Ranking:", np.sort(medias)[::-1])

Repare em quantas análises foram feitas em poucas linhas, sem nenhum loop explícito. É esse poder de expressão que faz o NumPy ser a base de praticamente todo pipeline de dados em Python.

NumPy no ecossistema de dados

O NumPy raramente trabalha sozinho. As bibliotecas mais usadas no mercado brasileiro de dados são construídas diretamente sobre ele:

• Pandas — adiciona DataFrames e ferramentas de manipulação tabular; internamente, cada coluna é um array NumPy.
• Matplotlib — plota gráficos a partir de arrays NumPy.
• scikit-learn — consome arrays NumPy como entrada para treinar modelos de machine learning.

Por isso, aprender NumPy uma vez bem feito acelera o aprendizado de todas essas ferramentas. Para uma visão integrada de todo o stack, veja nosso guia de Python para ciência de dados. Se você trabalha com volumes gigantescos de dados tabulares e sente o Pandas lento, vale conhecer o Polars como alternativa ao Pandas, que também se integra bem ao NumPy.

Performance em outra escala: para cargas numéricas de altíssimo desempenho — processamento de imagens em tempo real, simulações científicas pesadas ou tensores de produção — vale conhecer o ecossistema Rust, com bibliotecas como ndarray e nalgebra, que entregam velocidade de memória contígua sem o overhead do interpretador Python.

Próximos passos

Para evoluir depois deste tutorial:

1. Pratique com dados reais — carregue um CSV com Pandas, converta colunas em arrays NumPy e calcule estatísticas.
2. Aprofunde em broadcasting — ele é o recurso que mais economiza código quando bem dominado.
3. Explore álgebra linear — funções como np.dot, np.linalg.inv e np.linalg.solve são a porta de entrada para machine learning.

O NumPy é dessas ferramentas que parecem simples no começo e revelam profundidade conforme você usa. Domine arrays, indexação e agregações, e você terá uma base sólida para qualquer carreira em dados com Python. Para acompanhar oportunidades do mercado, confira nossas vagas de Python e o guia de primeiro emprego como programador Python.