Tutorial de NumPy

NumPy (Numerical Python) é a biblioteca fundamental para computação numérica em Python. Ela introduz o ndarray — um array multidimensional rápido e de tipo fixo — e o combina com centenas de funções matemáticas que operam em arrays inteiros de uma só vez. Praticamente toda biblioteca científica de Python (Pandas, SciPy, Matplotlib, scikit-learn) é construída sobre o NumPy.

Este capítulo aborda:

• O que é o NumPy e por que é mais rápido do que listas simples em Python
• Como instalar o NumPy e a convenção padrão de importação
• Como criar arrays com np.array, np.zeros, np.ones, np.arange e np.linspace
• Indexação, fatiamento e mascaramento booleano
• Redimensionamento e transposição
• Broadcasting — operando em arrays com formas diferentes
• Funções de agregação (sum, mean, std, min, max)
• Matemática elemento a elemento e álgebra linear
• Funções utilitárias comuns (sort, unique, where, concatenate)

O que é NumPy?

NumPy é uma biblioteca Python de código aberto que oferece:

1. Um poderoso objeto array N-dimensional (ndarray).
2. Funções matemáticas elemento a elemento (ufuncs) que se aplicam a cada elemento de um array em código C compilado, em vez de um loop Python.
3. Rotinas de álgebra linear, transformadas de Fourier e geração de números aleatórios.

Por que o NumPy é mais rápido do que listas Python

Uma lista Python pode conter itens de qualquer tipo, portanto cada elemento armazena uma tag de tipo e um ponteiro para o valor real. Os arrays NumPy armazenam dados numéricos brutos em um bloco contíguo de memória — sem ponteiros, sem consultas de tipo. Combinado com loops C vetorizados (ufuncs), operações em um array NumPy de um milhão de elementos tipicamente são 10–100× mais rápidas do que o código equivalente com loop for em Python.

Instalando o NumPy

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

pip install numpy

Importando o NumPy

A convenção universal é importar NumPy como np:

import numpy as np

Todos os exemplos neste capítulo assumem que essa importação já está em escopo.

Criando Arrays

A partir de uma lista Python

Passe qualquer lista (ou lista de listas) para np.array():

[1 2 3 4 5]
int64
(5,)

Um array 2-D (matriz) usa uma lista de listas:

[[1 2 3]
 [4 5 6]
 [7 8 9]]
(3, 3)

Atalhos para criação de arrays

import numpy as np

print(np.zeros((2, 3)))
print(np.ones(4, dtype=int))
print(np.arange(0, 10, 2))
print(np.linspace(0, 1, 5))

[[0. 0. 0.]
 [0. 0. 0.]]
[1 1 1 1]
[0 2 4 6 8]
[0.   0.25 0.5  0.75 1.  ]

np.linspace é especialmente útil quando você precisa de um número preciso de pontos — por exemplo, ao preparar um eixo x para um gráfico. Consulte o capítulo Introdução ao Matplotlib para saber como combiná-lo com funções de plotagem.

Indexação e Fatiamento

Indexação e fatiamento 1-D

O NumPy usa a mesma sintaxe [start:stop:step] das listas Python, mas também suporta índices negativos e passos.

import numpy as np

a = np.array([10, 20, 30, 40, 50])

print(a[0])      # first element
print(a[-1])     # last element
print(a[1:4])    # elements at index 1, 2, 3
print(a[::2])    # every other element

10
50
[20 30 40]
[10 30 50]

Indexação 2-D

Para um array 2-D, forneça [linha, coluna]:

import numpy as np

b = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

print(b[1, 2])    # row 1, col 2 → 6
print(b[0, :])    # first row  → [1 2 3]
print(b[:, 1])    # second column → [2 5 8]
print(b[0:2, 1:3])  # sub-matrix

6
[1 2 3]
[2 5 8]
[[2 3]
 [5 6]]

Mascaramento booleano

Passe um array boolean como índice para selecionar apenas os elementos onde a condição é True:

import numpy as np

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

print(a[a > 3])        # elements greater than 3
print(a[a % 2 == 0])   # even elements

[4 5]
[2 4]

Máscaras booleanas são a substituição idiomática do NumPy para list comprehensions filtradas e são muitas vezes mais rápidas em arrays grandes.

Redimensionamento e Transposição

Redimensionamento

np.reshape() (ou o método .reshape()) retorna uma visão dos dados com uma nova forma. O número total de elementos deve permanecer o mesmo.

[[1 2 3]
 [4 5 6]]

Use -1 para uma dimensão que você quer que o NumPy infira automaticamente:

import numpy as np

a = np.arange(12)
print(a.reshape(3, -1))   # 3 rows, NumPy infers 4 columns

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

Transposição

.T ou np.transpose() troca os eixos (linhas ↔ colunas para arrays 2-D):

[[1 3 5]
 [2 4 6]]
(2, 3)

Adicionando e Removendo Elementos

Adicionando elementos

np.append() retorna um novo array plano — não modifica o original in-place (ao contrário de list.append).

[1 2 3 4 5 6]

Para adições repetidas dentro de um loop, construir uma lista Python e convertê-la uma única vez com np.array() no final é muito mais eficiente do que chamar np.append() repetidamente.

Removendo elementos

np.delete(arr, indices) retorna um novo array com os índices especificados removidos:

[1 2 5]

Concatenando arrays

np.concatenate() une dois ou mais arrays ao longo de um eixo existente:

import numpy as np

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

[1 2 3 4]

Broadcasting

Broadcasting é a regra do NumPy para aplicar operações entre arrays de formas diferentes — sem copiar dados. O exemplo clássico é adicionar um escalar a um array:

import numpy as np

a = np.array([1, 2, 3])
print(a + 10)    # 10 is broadcast across all elements

[11 12 13]

Um caso mais poderoso: adicionar um array 1-D a cada linha de um array 2-D:

import numpy as np

matrix = np.array([[1, 2, 3],
                   [4, 5, 6]])
row    = np.array([10, 20, 30])

print(matrix + row)

[[11 22 33]
 [14 25 36]]

O NumPy compara formas da direita para a esquerda: (2, 3) + (3,) é válido porque as dimensões finais coincidem; row é conceitualmente expandido para um array (2, 3) sem nenhuma alocação de memória.

Operações Matemáticas

Aritmética elemento a elemento

Todos os operadores padrão (+, -, *, /, **) funcionam elemento a elemento em arrays da mesma forma. As funções nomeadas equivalentes (np.add, np.subtract, np.multiply, np.divide) podem ser úteis ao passar operações como argumentos.

[5 7 9]
[ 4 10 18]
[1 4 9]

Funções matemáticas universais (ufuncs)

O NumPy fornece versões vetorizadas de todas as funções matemáticas padrão:

import numpy as np

a = np.array([0, 1, 4, 9, 16], dtype=float)

print(np.sqrt(a))
print(np.log(np.array([1, np.e, np.e**2])))   # natural log
print(np.sin(np.array([0, np.pi/2, np.pi])))

[0. 1. 2. 3. 4.]
[0. 1. 2.]
[ 0.000e+00  1.000e+00 -8.742e-08]

O valor minúsculo próximo de zero para sin(π) é um arredondamento normal de ponto flutuante — np.pi é uma aproximação de π.

Funções de Agregação

As funções de agregação reduzem um array (ou um eixo dele) a um único valor:

import numpy as np

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

print(np.sum(a))    # 15
print(np.mean(a))   # 3.0
print(np.std(a))    # 1.4142135623730951
print(np.min(a))    # 1
print(np.max(a))    # 5

15
3.0
1.4142135623730951
1
5

Para arrays 2-D, passe axis=0 para agregar ao longo das colunas ou axis=1 para agregar ao longo das linhas:

import numpy as np

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

print(np.sum(m, axis=0))   # column totals: [5 7 9]
print(np.sum(m, axis=1))   # row totals:    [6 15]

[5 7 9]
[ 6 15]

Álgebra Linear

np.dot() do NumPy calcula o produto escalar de dois vetores 1-D ou o produto matricial de dois arrays 2-D. Para multiplicação de matrizes, o operador @ (Python 3.5+) é a forma moderna e abreviada.

import numpy as np

a = np.array([1, 2])
b = np.array([3, 4])
print(np.dot(a, b))     # 1*3 + 2*4 = 11

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(A @ B)            # matrix product

11
[[19 22]
 [43 50]]

np.linalg contém operações mais avançadas:

Funções Utilitárias

Ordenação

import numpy as np

a = np.array([3, 1, 4, 1, 5, 9, 2, 6])
print(np.sort(a))         # returns a sorted copy
print(np.argsort(a))      # indices that would sort the array

[1 1 2 3 4 5 6 9]
[1 3 6 0 2 4 7 5]

Valores únicos

import numpy as np

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

[1 2 3]

Seleção condicional com np.where

np.where(condition, x, y) retorna x onde a condição é True e y nos demais casos:

import numpy as np

a = np.array([1, 2, 3, 4, 5])
print(np.where(a > 2, a, 0))

[0 0 3 4 5]

NumPy com Matplotlib

NumPy e Matplotlib foram projetados para trabalhar juntos. np.linspace gera os valores de x; os ufuncs do NumPy calculam y; o Matplotlib plota o resultado:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2 * np.pi, 200)
plt.plot(x, np.sin(x), label='sin')
plt.plot(x, np.cos(x), label='cos')
plt.legend()
plt.title('Sine and Cosine')
plt.show()

Este exemplo requer que o Matplotlib esteja instalado (pip install matplotlib) e um display ou um backend Agg para ambientes sem interface gráfica. Consulte o capítulo Introdução ao Matplotlib para um guia detalhado.

O que Aprender a Seguir

• Tutorial de SciPy — computação científica de nível mais alto (integração, otimização, processamento de sinais) construída sobre arrays NumPy.
• Introdução ao Matplotlib — visualize arrays NumPy como gráficos de linha, dispersão, histogramas e muito mais.
• Plotagem com Matplotlib — ajuste fino do layout de figuras, eixos e estilos.