--- title: "Introdução ao NumPy Python — 2026" url: "https://python.dev.br/blog/introducao-ao-numpy/" markdown_url: "https://python.dev.br/blog/introducao-ao-numpy.MD" description: "Aprenda NumPy do zero com exemplos práticos: criar arrays, indexação, filtragem, broadcasting e agregações. Tutorial completo de NumPy em português." date: "2026-07-01" author: "Equipe Python Brasil" --- # Introdução ao NumPy Python — 2026 Aprenda NumPy do zero com exemplos práticos: criar arrays, indexação, filtragem, broadcasting e agregações. Tutorial completo de NumPy em português. O **NumPy** (Numerical Python) é a biblioteca fundamental para computação numérica em Python. Praticamente todo o ecossistema brasileiro de dados — do [Pandas](/blog/introducao-ao-pandas/) ao scikit-learn, passando pelo [Matplotlib](/blog/introducao-ao-matplotlib/) — foi construído sobre os arrays do NumPy. Se você quer seguir carreira em [ciência de dados](/blog/python-para-ciencia-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](/glossario/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`: ```bash pip install numpy ``` Quem usa [gerenciadores de pacotes modernos](/blog/gerenciadores-de-pacotes-python/) 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: ```python 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: ```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: ```python 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): ```python 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: ```python 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. ```python 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: ```python 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: ```python 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: ```python 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: ```python 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: ```python 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](/blog/introducao-ao-pandas/)** — adiciona DataFrames e ferramentas de manipulação tabular; internamente, cada coluna é um array NumPy. - **[Matplotlib](/blog/introducao-ao-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](/blog/python-para-ciencia-de-dados/). Se você trabalha com volumes gigantescos de dados tabulares e sente o Pandas lento, vale conhecer o [Polars como alternativa ao Pandas](/blog/polars-alternativa-pandas-python/), 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](/blog/introducao-ao-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](/vagas/) e o [guia de primeiro emprego como programador Python](/carreira/primeiro-emprego-python/).