Skip to content

NumPy Folha de referência

Pacote fundamental para computação numérica com Python.

01

Primeiros Passos

O que é NumPy?

O poder do NumPy vem do ndarray: um array n-D homogêneo com memória contígua. Como cada um dos elementos compartilha um tipo e vivem num único bloco, as operações rodam em código C/Fortran compilado (vetorização), tornando-as 10-100x mais rápidas que loops Python equivalentes. Quase toda a pilha científica do Python (pandas, scikit-learn, PyTorch, TensorFlow) é construída sobre arrays NumPy.

numpy
# NumPy: the fundamental package for numerical computing in Python.
# Core data structure: the n-dimensional array (ndarray).

# Key advantages over pure Python lists:
# - Homogeneous, contiguous memory -> fast vectorized ops
# - Broadcasting: operate on arrays of different shapes
# - Rich set of math / linear algebra / FFT / random routines
# - C/Fortran backend -> orders of magnitude faster than Python loops

import numpy as np
print(np.__version__)   # e.g. 1.26.0

Instalação e Import

np é o apelido quase universal para NumPy — cada tutorial e biblioteca espera por ele, então mantenha-o. Se você precisa de um build otimizado para CPU específica, o conda costuma trazer NumPy linkado ao MKL, mais rápido para álgebra linear que o padrão do pip.

numpy
# Install NumPy
pip install numpy
# Or with conda
conda install numpy

# The universal convention is to alias as np
import numpy as np

a = np.array([1, 2, 3])
print(a)            # [1 2 3]
print(type(a))      # <class 'numpy.ndarray'>

Atributos do ndarray

Conhecer esses atributos é a base para depurar código NumPy. shape e dtype são os mais comuns: shape informa a estrutura, dtype informa o consumo de memória. itemsize * size = nbytes permite estimar o uso de memória antes de alocar arrays enormes.

numpy
import numpy as np

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

a.ndim      # 2          -> number of axes (dimensions)
a.shape     # (2, 3)     -> tuple of axis sizes
a.size      # 6          -> total elements = prod(shape)
a.dtype     # int64      -> element type
a.itemsize  # 8          -> bytes per element
a.nbytes    # 48         -> total bytes = size * itemsize
a.T         # shape (3, 2) transposed view
a.flat      # flat iterator over all elements

Tipos de Dados (dtype)

Escolher o dtype certo é crítico para memória e correção. float32 corta a memória pela metade vs float64 com pouca perda de precisão na maioria dos trabalhos de ML. int8/int16 podem estourar silenciosamente — np.array([200], dtype=np.int8) vira -56. Sempre escolha o menor dtype que armazena seu intervalo com segurança, especialmente para arrays grandes e implantações embarcadas/edge.

numpy
import numpy as np

# Specifying dtype at creation
a = np.array([1, 2, 3], dtype=np.float32)
b = np.array([1, 2, 3], dtype="float32")   # string form works too

# Integer types: int8 int16 int32 int64 (and unsigned uint*)
# Float types:   float16 float32 float64 (default)
# Complex:       complex64 complex128
# Others:        bool, string_, unicode_, object

# Cast an existing array
c = a.astype(np.int32)

# Default int/float match the platform
print(np.dtype(int).itemsize)        # 4 or 8
print(np.dtype(float).itemsize)      # 8

# Beware overflow:
small = np.array([200], dtype=np.int8)   # wraps around!

Array vs Lista Python

A versão com list comprehension roda no interpretador Python (um bytecode por elemento); a versão NumPy despacha para um único loop C sobre memória contígua. Para cargas numéricas, o NumPy costuma ser 20-100x mais rápido e usa muito menos memória (sem objeto Python por elemento). Use listas só quando precisar de tipos heterogêneos ou dados não numéricos.

numpy
import numpy as np
import time

# Python list: element-wise multiply needs a loop or comprehension
py_list = list(range(1_000_000))
start = time.perf_counter()
py_sq = [x * 2 for x in py_list]
print("list:", time.perf_counter() - start)

# NumPy: vectorized, runs in C
arr = np.arange(1_000_000)
start = time.perf_counter()
np_sq = arr * 2
print("numpy:", time.perf_counter() - start)

# NumPy is typically 20-100x faster for numeric workloads.
# Lists are heterogeneous & flexible; arrays are homogeneous & fast.
02

Criação de Arrays

A partir de Estruturas Python

np.array() converte listas/tuplas (ou qualquer iterável aninhado) num ndarray. A profundidade do aninhamento determina o número de dimensões. Especifique o dtype na criação para evitar uma cópia extra depois — np.array([1,2,3]) assume int64 na maioria das plataformas, então se você quer floats, passe dtype=float.

numpy
import numpy as np

# From a list (1-D)
a = np.array([1, 2, 3])

# From a list of lists (2-D)
b = np.array([[1, 2, 3],
              [4, 5, 6]])

# From nested lists (3-D)
c = np.array([[[1, 2], [3, 4]],
              [[5, 6], [7, 8]]])

# Specify dtype up front
d = np.array([1, 2, 3], dtype=np.float32)

# From any iterable
e = np.array(range(5))         # [0 1 2 3 4]
f = np.array((1, 2, 3))        # from a tuple

Intervalos e Grades Embutidos

Prefira linspace a arange para floats — o passo do arange pode produzir extremos errados por uma unidade, por arredondamento de ponto flutuante. meshgrid é a forma padrão de construir grades de coordenadas para gráficos 3D, processamento de imagem e cálculos de diferenças finitas. Use np.mgrid / np.ogrid para grades abertas (que economizam memória).

numpy
import numpy as np

# arange: like range but returns array (watch float edge!)
np.arange(0, 10, 2)         # [0 2 4 6 8]
np.arange(0, 1, 0.1)        # may or may not include 1.0 (float!)

# linspace: exactly num points, endpoints included by default
np.linspace(0, 1, 5)        # [0.   0.25 0.5  0.75 1.  ]

# logspace: 10**start .. 10**stop
np.logspace(0, 3, 4)        # [   1.   10.  100. 1000.]

# Meshgrids for evaluating functions on a grid
x = np.linspace(-2, 2, 5)
y = np.linspace(-2, 2, 5)
X, Y = np.meshgrid(x, y)
Z = X**2 + Y**2             # 5x5 grid of values

Zeros, Uns e Constantes

zeros/ones/full preenchem o buffer; empty pula o preenchimento, então é o mais rápido quando você vai sobrescrever cada um dos elementos de qualquer forma (ex.: como buffer de saída). eye(k=n) constrói a identidade; eye(k=1) desloca a diagonal para cima. Sempre passe dtype para zeros/ones — o padrão é float64, que desperdiça memória se você queria inteiros.

numpy
import numpy as np

np.zeros((2, 3))            # 2x3 of float64 zeros
np.zeros((2, 3), dtype=int) # 2x3 of int zeros
np.ones((3, 3))             # 3x3 of ones
np.full((2, 2), 7)          # 2x2 filled with 7
np.full((2, 2), np.pi)      # fill with any constant

# Identity & eye
np.eye(3)                   # 3x3 identity matrix
np.eye(3, k=1)              # identity shifted up by one diagonal
np.diag([1, 2, 3])          # diagonal matrix from a vector

# Empty: uninitialized memory (fastest, but garbage values)
np.empty((2, 2))            # allocate without filling

Arrays Aleatórios

Use np.random.default_rng(seed) — o Generator moderno é mais rápido, estatisticamente melhor e reproduzível. A API legada np.random.rand/randn/seed tem estado global e é desencorajada em código novo. Sempre passe uma seed explícita para reprodutibilidade em experimentos e testes; sem ela, os resultados diferem entre execuções.

numpy
import numpy as np

rng = np.random.default_rng(seed=42)   # modern Generator (NumPy >= 1.17)

rng.random((2, 3))           # uniform in [0, 1), shape (2, 3)
rng.standard_normal((2, 3))  # standard normal (mean 0, std 1)
rng.normal(100, 15, size=5)  # normal(mu=100, sigma=15)
rng.uniform(0, 10, size=5)   # uniform in [low, high)
rng.integers(0, 10, size=5)  # random ints in [low, high)

# Reproducibility: always pass a seed
rng2 = np.random.default_rng(42)
print(rng2.random(3))        # same every run

# Legacy API (still common but prefer default_rng)
# np.random.rand(2, 3)      # uniform [0,1)
# np.random.randn(2, 3)     # standard normal

Copiando Arrays Existentes

Slicing e .view() criam views que compartilham memória — editar uma altera a outra. Use .copy() quando precisar de um array independente. Reshape, ravel, transpose também retornam views quando possível, então sempre faça .copy() antes de mutar se precisar do original. Esquecer isso é um dos bugs de NumPy mais comuns.

numpy
import numpy as np
a = np.array([1, 2, 3])

# View (shares memory!) - shape change only
v = a.view()
v[0] = 99
print(a)   # [99  2  3]   <- a is mutated!

# Deep copy (independent)
b = a.copy()
b[0] = 0
print(a)   # [99  2  3]   <- a unchanged

# np.array defaults to copying
c = np.array(a)
c is a    # False

# Repeat / tile to expand arrays
np.repeat([1, 2, 3], 2)   # [1 1 2 2 3 3]
np.tile([1, 2, 3], 2)     # [1 2 3 1 2 3]
03

Indexação e Slicing

Slicing Básico

O slicing segue a convenção Python [start:stop:step], com stop excluído. Crucialmente, slices do NumPy são views — compartilham memória com a fonte, então mutar um slice muta o original. Isso é intencional (economiza memória), mas é fonte frequente de bugs. Use .copy() quando precisar de um array independente.

numpy
import numpy as np
a = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

a[0]          # 0      (scalar)
a[-1]         # 9      (last element)
a[2:5]        # [2 3 4]    start:stop (stop excluded)
a[:5]         # [0 1 2 3 4]
a[5:]         # [5 6 7 8 9]
a[::2]        # [0 2 4 6 8]   step=2
a[::-1]       # [9 8 7 6 5 4 3 2 1 0]  reversed
a[1:7:2]      # [1 3 5]       start:stop:step

# Slices return VIEWS (not copies) -> editing changes the original
b = a[2:5]
b[0] = 99
print(a[2])   # 99   <- a was modified!

Indexação Multidimensional

Use a[i, j] em vez de a[i][j] — a forma com vírgula é uma operação só e mais rápida. a[:, j] pega uma coluna inteira. Use ... (Ellipsis) ao trabalhar com arrays de 3+ dimensões para significar 'cada um dos eixos restantes', evitando escrever muitos dois-pontos. Cada slice retorna uma view.

numpy
import numpy as np
a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

a[1, 2]       # 6      (row 1, col 2) - equivalent to a[1][2] but faster
a[0]          # [1 2 3]   (row 0)
a[0, :]       # [1 2 3]   (row 0, all cols)
a[:, 1]       # [2 5 8]   (all rows, col 1)
a[1:3, 0:2]   # [[4 5]
              #  [7 8]]     rows 1-2, cols 0-1
a[-1]         # [7 8 9]    last row
a[:, -1]      # [3 6 9]    last column

# ... (ellipsis) selects any remaining full axes
b = np.zeros((2, 3, 4))
b[..., 0]     # shape (2, 3) - last axis indexed, others kept
b[1, ...]     # shape (3, 4) - first axis indexed

Indexação Booleana / Máscara

A indexação booleana sempre retorna uma CÓPIA, nunca uma view — seguro mutar livremente. Combine máscaras com & | ~ (NÃO com and/or — eles operam na veracidade do array e levantam erro). np.where retorna índices; np.where(cond, x, y) é um ternário vetorizado. É o cavalo de batalha para filtragem e lógica condicional.

numpy
import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])

# Build a boolean mask
mask = a > 3
# [False False False  True  True  True]

a[mask]            # [4 5 6]   (select elements where mask is True)
a[a > 3]           # same, in one expression
a[(a > 2) & (a < 6)]   # [3 4 5]   combine with & (and), | (or), ~ (not)

# Modify via mask
a[a > 3] = 0       # set all matching elements
a[a == 0] = -1     # conditional assignment

# Count matching elements
(a > 3).sum()      # 3   (True == 1)
np.count_nonzero(a > 3)

# np.where: positions where condition is True
np.where(a > 3)    # (array([3, 4, 5]),) indices

Indexação Fancy / Array de Inteiros

A indexação fancy (array de inteiros) também retorna uma cópia, nunca uma view. Ao indexar um array 2-D com dois arrays de índice b[rows, cols], os arrays são pareados elemento a elemento (dando pontos), NÃO um produto cartesiano. Para o produto cartesiano use np.ix_(rows, cols). Essa distinção é fonte comum de confusão.

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

# Index with a list/array of indices
a[[0, 2, 4]]         # [10 30 50]
a[np.array([0, 2, 4])]   # same

# Indices can repeat
a[[0, 0, 1]]         # [10 10 20]

# Negative indices work
a[[-1, -2]]          # [50 40]

# 2-D fancy indexing
b = np.arange(12).reshape(3, 4)
rows = np.array([0, 2])
cols = np.array([1, 3])
b[rows, cols]        # [1 11]   pairs (0,1) and (2,3)

# Mix a slice and an index array
b[1:, [0, 2]]        # rows 1-2, cols 0 and 2

# np.take: same as fancy indexing, more flexible
np.take(a, [0, 2])   # [10 30]

Atribuição por Índice e np.where

np.where(cond, x, y) é um if-else vetorizado — extremamente comum para construir arrays com base em condições. Com um único argumento, retorna os índices onde a condição é True. np.select trata múltiplas condições mutuamente exclusivas, e np.clip é uma forma limpa de limitar valores sem escrever máscaras explícitas.

numpy
import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])

# Conditional assignment with a mask
a[a % 2 == 0] = -1     # even -> -1: [1 -1 3 -1 5 -1]

# np.where(cond, x, y): vectorized ternary
b = np.where(a > 3, "big", "small")
# ['small' 'small' 'small' 'big' 'big' 'big']

# np.where with one argument -> indices of True
idx = np.where(a == -1)
# (array([1, 3, 5]),)

# np.select: multiple conditions, multiple choices
conds = [a < 3, a > 3, a == 3]
choices = ["low", "high", "mid"]
np.select(conds, choices, default="ok")

# np.clip: clamp values to a range
np.clip(a, 0, 4)       # values < 0 -> 0, > 4 -> 4
04

Remodelagem e Manipulação de Forma

reshape e Inferência com -1

reshape muda a forma, mas mantém o mesmo tamanho total. Use -1 para uma dimensão e o NumPy a infere pelo tamanho — só um -1 é permitido. reshape geralmente retorna uma view (sem cópia de dados), então mutar o array remodelado muta o original. O número total de elementos deve permanecer constante ou você recebe um ValueError.

numpy
import numpy as np
a = np.arange(12)        # [0 1 2 ... 11], shape (12,)

# reshape to (3, 4)
b = a.reshape(3, 4)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# Use -1 to infer one dimension
a.reshape(2, -1)         # (2, 6)  - -1 means "figure it out"
a.reshape(-1, 3)         # (4, 3)
a.reshape(2, -1, 2)      # (2, 3, 2)  only one -1 allowed

# Total size must match -> ValueError otherwise
# a.reshape(5, 3)        # 5*3 = 15 != 12

# reshape returns a view when possible (no copy)
b[0, 0] = 99
print(a[0])              # 99   <- a was modified

Flatten e Ravel

ravel() retorna uma view (rápida, compartilha memória) enquanto flatten() sempre retorna uma cópia (segura, mas mais lenta e usa 2x a memória). Use ravel quando só precisar iterar, flatten quando for mutar o resultado sem afetar o original. O argumento order importa ao interoperar com código Fortran ou MATLAB.

numpy
import numpy as np
a = np.array([[1, 2, 3],
              [4, 5, 6]])

# ravel: returns a VIEW (C order by default) - efficient
a.ravel()              # [1 2 3 4 5 6]
a.ravel(order='F')     # [1 4 2 5 3 6]   Fortran (column) order

# flatten: always returns a COPY - safe to mutate
flat = a.flatten()
flat[0] = 99
print(a[0, 0])         # 1   <- a unchanged

# Order conventions:
# 'C' (default): last axis varies fastest (row-major)
# 'F':           first axis varies fastest (column-major)
# 'A':           Fortran order if array is F-contiguous, else C
# 'K':           preserve memory order

Transpose e Swap Axes

Transpose é apenas uma view que reordena como a memória é lida — nenhum dado é copiado, o que o torna barato, mas significa que o resultado pode não ser contíguo. Para arrays 2-D, .T é tudo que você precisa; para 3+ dimensões, use transpose(ordem_dos_eixos), swapaxes ou moveaxis para controlar exatamente qual eixo vai onde. Operações em arrays não contíguos podem ser mais lentas, então np.ascontiguousarray pode ajudar em loops quentes.

numpy
import numpy as np
a = np.arange(12).reshape(3, 4)

a.T                 # shape (4, 3)   transpose (2-D)
a.transpose()       # same

# For 3+ dimensions, specify axis order
b = np.arange(24).reshape(2, 3, 4)
b.transpose(1, 0, 2)   # shape (3, 2, 4)  axes reordered
b.swapaxes(0, 1)       # shape (3, 2, 4)  swap two axes
b.T                   # shape (4, 3, 2)  reverse all axes

# Move axes to new positions
np.moveaxis(b, 0, -1)  # shape (3, 4, 2)

# All of these return VIEWS (no data copy)

Empilhando Arrays

stack adiciona um eixo NOVO (transforma dois arrays 1-D num 2-D); concatenate junta ao longo de um eixo EXISTENTE. vstack/hstack/dstack são wrappers de conveniência para arrays 1-D e 2-D. Para layouts complexos, np.block aceita listas aninhadas de arrays, como construir uma matriz a partir de sub-blocos. Todas as funções de empilhamento criam arrays novos (cópias).

numpy
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Stack along a NEW axis
np.stack([a, b])            # shape (2, 3)  - default axis=0
np.stack([a, b], axis=1)    # shape (3, 2)  column stack

# Concatenate along an EXISTING axis
np.concatenate([a, b])              # [1 2 3 4 5 6]
np.vstack([a, b])                  # shape (2, 3)  vertical
np.hstack([a, b])                  # [1 2 3 4 5 6] horizontal
np.dstack([a, b])                  # shape (1, 3, 2) depth

# 2-D arrays
A = np.ones((2, 2))
B = np.zeros((2, 2))
np.hstack([A, B])   # shape (2, 4)
np.vstack([A, B])   # shape (4, 2)

# np.block: build from nested blocks
np.block([[A, B], [B, A]])   # shape (4, 4)

Dividindo Arrays

split exige pedaços de tamanho igual (levanta ValueError caso contrário), enquanto array_split permite divisão desigual — prático quando N não divide exatamente. vsplit/hsplit/dsplit são helpers específicos por eixo, equivalentes a np.split(arr, n, axis=...). Todas retornam listas de views do array original, então são eficientes em memória.

numpy
import numpy as np
a = np.arange(12)

# Split into equal parts (must divide evenly)
np.split(a, 3)        # [array([0,1,2,3]), array([4,5,6,7]), array([8,9,10,11])]

# Split at specific indices
np.split(a, [3, 5])   # [array([0,1,2]), array([3,4]), array([5,6,7,8,9,10,11])]

# 2-D
b = np.arange(16).reshape(4, 4)
np.vsplit(b, 2)       # split along rows -> 2 arrays of shape (2, 4)
np.hsplit(b, 2)       # split along cols -> 2 arrays of shape (4, 2)

# array_split: allows uneven division
np.array_split(np.arange(10), 3)  # sizes [4, 3, 3] - no error

# dsplit: split along depth (axis 2)
c = np.arange(24).reshape(2, 2, 6)
np.dsplit(c, 3)       # 3 arrays of shape (2, 2, 2)
05

Broadcasting

Regras de Broadcasting

Broadcasting permite combinar arrays de formas diferentes expandindo virtualmente eixos de tamanho 1 — nenhum dado é realmente copiado. A regra: compare as formas da direita para a esquerda; cada eixo deve ser igual ou um deles deve ser 1 (ou ausente). É isso que torna o código NumPy conciso (sem loops explícitos), mas também fonte comum de bugs silenciosos de forma — sempre verifique shapes quando algo parecer errado.

numpy
import numpy as np

# Broadcasting: operate on arrays of different shapes without copying.
# Two shapes are compatible if, for each trailing axis, they are
# equal OR one of them is 1.

# Scalar broadcast to any array
a = np.array([1, 2, 3])
a + 10            # [11 12 13]   10 treated as shape ()

# 1-D with 2-D
A = np.ones((3, 4))
row = np.array([10, 20, 30, 40])
A + row           # row (4,) broadcast to (3, 4) -> added to each row

col = np.array([[100], [200], [300]])   # shape (3, 1)
A + col           # col broadcast across columns -> added to each column

# Incompatible shapes raise ValueError
# A + np.array([1, 2, 3])   # (3,4) vs (3,) -> error

Adicionando Eixos para Broadcasting

np.newaxis (apelido None) insere um eixo de tamanho 1, o truque padrão para remodelar arrays e fazê-los transmitir da forma que você quer. Adicionar um eixo de coluna (a[:, None]) e um eixo de linha (a[None, :]) permite calcular produtos externos, diferenças par a par e mais, sem escrever loops. np.expand_dims é o equivalente com função nomeada, por legibilidade.

numpy
import numpy as np
a = np.array([1, 2, 3])          # shape (3,)
b = np.array([10, 20, 30, 40])   # shape (4,)

# a + b would fail (3,) vs (4,)
# Insert a new axis so shapes become (3, 1) and (4,) -> broadcasts to (3, 4)

a_col = a[:, np.newaxis]   # shape (3, 1)  - same as a.reshape(-1, 1)
b_row = b[np.newaxis, :]   # shape (1, 4)

outer = a_col + b_row      # shape (3, 4)  outer sum
# [[11 21 31 41]
#  [12 22 32 42]
#  [13 23 33 43]]

# np.newaxis / None are equivalent
a[:, None]                 # same as a[:, np.newaxis]

# np.expand_dims is the explicit function form
np.expand_dims(a, axis=1)  # shape (3, 1)

Produtos Externos e Operações Par a Par

Adicionar um novo eixo para converter uma operação 1-D em um cálculo 2-D estilo externo é o idioma-chave do NumPy vetorizado. a[:, None] - b[None, :] calcula todas as diferenças par a par sem loops — muito mais rápido que loops Python aninhados. Esse padrão sustenta matrizes de distância, cálculos de kernel e operações de grade.

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

# Outer product (3,) x (4,) -> (3, 4)
np.outer(a, b)
# [[10 20 30 40]
#  [20 40 60 80]
#  [30 60 90 120]]

# Manual outer via broadcasting
a[:, None] * b[None, :]      # same as np.outer(a, b)

# Pairwise difference: (4,) - (3,) -> (4, 3) or (3, 4)?
diff = b[:, None] - a[None, :]   # shape (4, 3): diff[i, j] = b[i] - a[j]

# Pairwise equality (used in set ops, distance)
x = np.array([1, 2, 3, 4])
y = np.array([2, 4, 6])
x[:, None] == y[None, :]     # shape (4, 3) boolean matrix

# Add a constant vector to each row of a matrix
M = np.zeros((5, 3))
v = np.array([1, 2, 3])
M + v                        # broadcasts v to every row

Armadilhas Comuns de Broadcasting

Um array 1-D de forma (N,) transmite como LINHA contra um array 2-D — NÃO é um vetor coluna. Para torná-lo coluna, você precisa adicionar um eixo: a[:, None]. Cuidado com broadcasting não intencional ao adicionar novos eixos — dois arrays (1000, 1000) podem explodir num intermediário (1000, 1000, 1000) (8 GB) e derrubar o programa. Sempre verifique shapes com .shape antes de rodar cálculos grandes.

numpy
import numpy as np

# Pitfall 1: (N,) is NOT a row or column vector - it has no axis direction
a = np.array([1, 2, 3])
M = np.ones((3, 3))
M + a            # OK: (3,3) + (3,) -> a broadcast as a ROW
M + a[:, None]   # OK: a as a COLUMN

# Pitfall 2: accidentally broadcasting when you wanted element-wise
x = np.array([1, 2, 3])
y = np.array([10, 20, 30])
x + y            # [11 22 33]   element-wise (both (3,))
x[:, None] + y   # (3,3) matrix  - probably not what you wanted!

# Pitfall 3: shape (1,) vs () - both broadcast but mean different things
np.array([5]).shape   # (1,)
np.array(5).shape     # ()  - 0-D, broadcasts to ANYTHING

# Pitfall 4: memory blow-up from over-broadcasting
# Big arrays broadcast together can produce enormous intermediates
A = np.ones((1000, 1000))
B = np.ones((1000, 1000))
(A * B).sum()    # OK - intermediate is 8MB
# A[:, None, :] * B[None, :, :]   # (1000,1000,1000) = 8GB! crash

Broadcasting com np.broadcast_to

np.broadcast_to permite criar explicitamente uma view transmitida — útil quando uma API exige uma forma específica, mas você quer evitar o custo de memória de uma cópia completa. O resultado é somente leitura, porque os dados subjacentes são menores que a forma sugere. np.broadcast_arrays é prático quando você quer iterar sobre vários arrays como se tivessem a mesma forma.

numpy
import numpy as np

# np.broadcast_to: explicit view of an array broadcast to a new shape
a = np.array([1, 2, 3])            # shape (3,)
b = np.broadcast_to(a, (4, 3))     # shape (4, 3) - VIEW, no copy
# [[1 2 3]
#  [1 2 3]
#  [1 2 3]
#  [1 2 3]]
b[0, 0] = 99   # ERROR: broadcast_to returns read-only view

# np.broadcast_arrays: broadcast several arrays together (as views)
x = np.array([1, 2, 3])           # (3,)
y = np.array([[10], [20]])        # (2, 1)
bx, by = np.broadcast_arrays(x, y)
bx.shape   # (2, 3)
by.shape   # (2, 3)

# np.broadcast: low-level iterator object
b = np.broadcast(x, y)
b.shape    # (2, 3)
b.index    # current position in the iteration
b.iters    # list of iterators over each input
06

Operações Matemáticas

Aritmética Elemento a Elemento

Os operadores NumPy (+, *, **) mapeiam para ufuncs (np.add, np.multiply, np.power) e operam elemento a elemento. O operador * é elemento a elemento, NÃO multiplicação de matrizes — use @ ou np.dot para isso. Operadores in-place (+=, *=) economizam memória reutilizando o buffer do array; exigem dtype e forma compatíveis (após broadcasting).

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

a + b       # [11 22 33 44]
a - b       # [-9 -18 -27 -36]
a * b       # [10 40 90 160]   element-wise (NOT matrix product)
a / b       # [0.1 0.1 0.1 0.1]  always float
a // b      # [0 0 0 0]        floor division
a ** 2      # [1 4 9 16]       power
a % 2       # [1 0 1 0]        modulo
-a          # [-1 -2 -3 -4]    negation

# In-place ops (modify a, save memory)
a += 10
a *= 2

# Scalar ops broadcast
a + 100     # [102 104 106 108]

# Universal functions (ufuncs) - same operations as function form
np.add(a, b)
np.multiply(a, b)
np.power(a, 2)

Funções Universais (ufuncs)

ufuncs são funções vetorizadas que operam elemento a elemento e rodam em C compilado — muito mais rápido que aplicar o módulo math do Python num loop. np.maximum (máximo elemento a elemento de dois arrays) é diferente de np.max (máximo sobre um array). Use np.fmax para ignorar NaN nas comparações. Todas as ufuncs suportam out= para escrever num buffer pré-alocado, em loops quentes sem alocação.

numpy
import numpy as np
a = np.array([-1.5, 0.0, 1.5, 2.5])

# Math ufuncs
np.abs(a)         # [1.5 0.  1.5 2.5]
np.sqrt(np.abs(a))
np.exp(a)         # e^a
np.log(np.abs(a) + 1)
np.log2(a + 5)
np.log10(a + 5)

# Rounding
np.round(a)       # [-2.  0.  2.  2.]
np.floor(a)       # [-2.  0.  1.  2.]
np.ceil(a)        # [-1.  0.  2.  3.]
np.trunc(a)       # [-1.  0.  1.  2.]  truncate toward zero

# Trigonometry (radians)
np.sin(np.pi/2)   # 1.0
np.cos(0)         # 1.0
np.degrees(np.pi) # 180.0
np.radians(180)   # 3.14159...

# Comparison ufuncs
np.greater(a, 0)  # [False False True True]
np.maximum(a, 0)  # clip negatives to 0  (element-wise max)
np.minimum(a, 0)

Operações de Redução

Reduções (sum, mean, max, min, std) operam sobre o array inteiro por padrão, ou ao longo de um único eixo com axis=. axis=0 reduz linhas (colapsa para baixo), axis=1 reduz colunas (colapsa para o lado). Use keepdims=True para manter o eixo reduzido com tamanho 1 — essencial para transmitir o resultado de volta. Sempre passe dtype=np.float64 ao somar inteiros que podem estourar.

numpy
import numpy as np
a = np.array([[1, 2, 3],
              [4, 5, 6]])

# Global reductions
a.sum()         # 21
a.prod()        # 720
a.min(), a.max()
a.mean()        # 3.5
a.std(), a.var()
a.argmin(), a.argmax()   # indices of min/max (flattened)

# Axis-wise reductions
a.sum(axis=0)   # [5 7 9]   sum down each column
a.sum(axis=1)   # [6 15]    sum across each row
a.min(axis=1)   # [1 4]     min of each row
a.cumsum(axis=0)   # cumulative sum down columns
a.cumprod(axis=1)  # cumulative product across rows

# Keep dimensions
a.sum(axis=0, keepdims=True)   # shape (1, 3) - keeps the axis

# Specify dtype for accumulation (avoid overflow!)
a.sum(dtype=np.float64)

# NaN-aware versions
b = np.array([1.0, np.nan, 3.0])
np.nansum(b)    # 4.0   treats NaN as 0

Operações Cumulativas e de Varredura

cumsum / cumprod mantêm a mesma forma da entrada e retornam totais acumulados. diff é a derivada discreta e é o inverso do cumsum. Cuidado com overflow de inteiro no cumsum — acumular valores int32 pode dar a volta silenciosamente; promova para int64 ou float para segurança. A função .accumulate em qualquer ufunc (np.maximum.accumulate) dá uma redução cumulativa.

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

# Cumulative sum and product
np.cumsum(a)         # [ 1  3  6 10 15]
np.cumprod(a)        # [  1   2   6  24 120]

# 2-D: specify axis
b = np.array([[1, 2], [3, 4]])
np.cumsum(b, axis=0)   # [[1 2]
                       #  [4 6]]
np.cumsum(b, axis=1)   # [[1 3]
                       #  [3 7]]

# Differences (inverse of cumulative sum)
np.diff(a)            # [1 1 1 1]   a[i+1] - a[i]
np.diff(a, n=2)       # second-order diff [0 0 0]

# Edge: cumsum on integers can overflow silently
big = np.array([2**30, 2**30, 2**30], dtype=np.int32)
np.cumsum(big)        # wraps around - use int64 or float!

# Cumulative max / min
np.maximum.accumulate(a)   # [1 2 3 4 5]
np.minimum.accumulate(a)   # [1 1 1 1 1]

Operações de Comparação e Lógica

Use & | ~ em arrays booleanos (não and/or — eles exigem um único valor de verdade). np.any / np.all reduzem um array booleano a um único True/False, útil em asserções e condicionais. Nunca use == para floats — np.isclose ou np.allclose com tolerâncias apropriadas (atol/rtol) tratam o arredondamento de ponto flutuante. allclose é o padrão para comparar arrays de floats.

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

# Element-wise comparisons return boolean arrays
a > 3            # [False False False  True  True]
a == 3           # [False False  True False False]
a != 3
np.greater(a, 3)

# Logical ops on boolean arrays
b = (a > 2)
c = (a < 5)
np.logical_and(b, c)   # [False False  True  True False]
np.logical_or(b, c)
np.logical_not(b)
np.logical_xor(b, c)

# Array-level truth testing
np.any(a > 4)    # True
np.all(a > 0)    # True
np.all(a > 0, axis=0)  # per-axis
(a == 3).any()   # True

# np.isclose for float comparisons
np.isclose(0.1 + 0.2, 0.3)        # True  (handles float error)
np.allclose([0.1, 0.2], [0.1, 0.2 + 1e-9], atol=1e-8)  # True
07

Operações Estatísticas

Estatísticas Básicas

var/std assumem ddof=0 (populacional) por padrão, mas o pandas assume ddof=1 (amostral) — fonte frequente de divergência. Use ddof=1 para estatísticas amostrais. np.percentile recebe valores 0-100, np.quantile recebe 0.0-1.0. np.corrcoef retorna a matriz de correlação completa; indexe [0, 1] para o coeficiente escalar entre dois arrays.

numpy
import numpy as np
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

a.mean()          # 5.5    arithmetic mean
a.median() if hasattr(a, 'median') else np.median(a)  # 5.5
a.var()           # 8.25   variance (population, ddof=0)
a.std()           # 2.87   standard deviation
a.min(), a.max()  # 1, 10
a.ptp()           # 9      peak-to-peak = max - min

# Sample vs population variance
a.var(ddof=1)     # sample variance (divide by N-1, like pandas default)

# Percentiles & quantiles
np.percentile(a, 50)    # 5.5   median
np.percentile(a, [25, 50, 75])  # [3.25 5.5  7.75]  quartiles
np.quantile(a, 0.5)     # 5.5   same as percentile / 100

# Correlation
x = np.array([1, 2, 3, 4])
y = np.array([2, 4, 5, 4])
np.corrcoef(x, y)       # 2x2 correlation matrix

Histogramas e Bins

np.histogram retorna contagens e bordas (bordas tem um elemento a mais que bins). Use density=True para obter uma densidade de probabilidade (área = 1) em vez de contagens brutas. np.histogram2d constrói um histograma 2-D útil para mapas de calor e distribuições conjuntas. np.digitize mapeia valores para índices de bin; np.bincount é uma forma rápida de contar ocorrências de inteiros.

numpy
import numpy as np
data = np.random.default_rng(42).standard_normal(1000)

# 1-D histogram
counts, edges = np.histogram(data, bins=10)
# counts: array of element counts per bin
# edges: array of bin edge positions (length = bins + 1)

# Custom bin edges
np.histogram(data, bins=[-3, -1, 0, 1, 3])

# Density (integrates to 1) vs counts
np.histogram(data, bins=20, density=True)

# 2-D histogram (for heatmaps)
x = np.random.default_rng(1).standard_normal(1000)
y = np.random.default_rng(2).standard_normal(1000)
H, xedges, yedges = np.histogram2d(x, y, bins=20)

# Digitize: which bin does each value fall into?
bins = [-2, -1, 0, 1, 2]
indices = np.digitize(data, bins)   # array of bin indices (1-based)

# Bincount: count occurrences of each non-negative int
np.bincount(np.array([0, 1, 1, 3, 3, 3]))   # [1 2 0 3]

Ordenação e Estatísticas de Ordem

argsort é a chave para rankings: retorna os índices que ordenariam o array, permitindo reordenar outro array da mesma forma. np.partition é muito mais rápido que uma ordenação completa quando você só precisa dos top-k elementos (O(n) vs O(n log n)). np.unique retorna valores únicos ordenados; passe return_counts=True para um resumo tipo histograma.

numpy
import numpy as np
a = np.array([3, 1, 4, 1, 5, 9, 2, 6])

# Sorting
np.sort(a)             # [1 1 2 3 4 5 6 9]   returns a copy
a.sort()               # in-place sort (modifies a)
np.sort(a)[::-1]       # descending
np.argsort(a)          # indices that would sort a (no copy)

# 2-D sorting along axis
b = np.array([[3, 1, 2], [6, 5, 4]])
np.sort(b, axis=0)     # sort down each column
np.sort(b, axis=1)     # sort across each row (default)

# Partial sorting: top-k smallest (no full sort)
np.partition(a, 3)     # 3 smallest first (unordered), rest after
np.argpartition(a, 3)  # indices of partition

# k-th smallest element (selection algorithm)
np.partition(a, 2)[2]  # 3rd smallest (index 2)

# unique values (sorted)
np.unique([1, 2, 1, 3, 2])   # [1 2 3]
np.unique(a, return_counts=True)  # values and counts

Covariância e Correlação

np.cov trata cada LINHA como variável por padrão (rowvar=True) — o oposto do pandas, que usa colunas. Para casar com o comportamento do pandas, passe rowvar=False ou transpose seus dados. np.corrcoef retorna a matriz completa; indexe [0, 1] para obter o coeficiente escalar entre duas variáveis. A diagonal da matriz de covariância é a variância de cada variável.

numpy
import numpy as np
# Sample data: 3 variables, 5 observations
data = np.array([[1, 2, 3, 4, 5],
                 [2, 4, 1, 3, 5],
                 [5, 4, 3, 2, 1]], dtype=float)

# Covariance matrix (3x3)
# Each ROW is a variable, so set rowvar=False to treat COLUMNS as variables
cov = np.cov(data, rowvar=True)   # 3x3 covariance between rows
# Diagonal = variance of each variable
# Off-diagonal = covariance between pairs

# Correlation matrix
corr = np.corrcoef(data)   # 3x3, values in [-1, 1]

# Correlation between two specific variables
np.corrcoef(data[0], data[1])[0, 1]   # scalar

# Weighted covariance: compute manually
weights = np.array([1, 1, 1, 2, 2])
mean = np.average(data, axis=1, weights=weights, keepdims=True)
centered = data - mean
weighted_cov = (centered * weights) @ centered.T / weights.sum()

# Pearson correlation coefficient (manual)
def pearson(x, y):
    xm, ym = x - x.mean(), y - y.mean()
    return np.dot(xm, ym) / (np.sqrt((xm**2).sum()) * np.sqrt((ym**2).sum()))

Estatísticas Cientes de NaN

Reduções padrão propagam NaN (qualquer NaN contamina o resultado), o que raramente é o que você quer. Use as variantes nan* (nanmean, nansum, nanstd) para ignorar valores NaN. nan_to_num substitui NaN e infinitos por valores finitos — perfeito para limpar dados antes do cálculo. Para tratamento pesado de NaN, o pandas costuma ser mais ergonômico que NumPy puro.

numpy
import numpy as np
a = np.array([1.0, 2.0, np.nan, 4.0, 5.0])

# Standard functions propagate NaN
a.mean()      # nan
a.sum()       # nan

# NaN-aware equivalents
np.nanmean(a)     # 3.0   ignores NaN
np.nansum(a)      # 12.0
np.nanstd(a)
np.nanmedian(a)
np.nanvar(a)
np.nanmin(a), np.nanmax(a)
np.nanpercentile(a, 50)

# Count non-NaN elements
np.count_nonzero(~np.isnan(a))   # 4

# Find NaN positions
np.isnan(a)            # [False False  True False False]
np.where(np.isnan(a))  # (array([2]),)

# Replace NaN with a value (imputation)
np.nan_to_num(a, nan=0.0)              # replace NaN with 0
np.where(np.isnan(a), 0, a)            # same, more explicit
a_filled = np.copy(a)
a_filled[np.isnan(a)] = np.nanmean(a)  # fill with mean

# Check if any NaN
np.isnan(a).any()      # True
08

Álgebra Linear (numpy.linalg)

Multiplicação de Matrizes

Use @ para multiplicação de matrizes — é o operador moderno (Python 3.5+), mais claro que .dot() e funciona para operações em lote (N-D). O operador * é elemento a elemento (Hadamard), fonte comum de confusão para quem vem do MATLAB. np.matmul (@) difere de np.dot no tratamento 1-D e no comportamento de empilhamento para arrays N-D.

numpy
import numpy as np

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

# Matrix product (2-D)
A @ B                  # [[19 22]
                       #  [43 50]]    preferred operator (Py 3.5+)
A.dot(B)               # same, older method
np.dot(A, B)           # same for 2-D

# 1-D: dot is inner product
v = np.array([1, 2, 3])
w = np.array([4, 5, 6])
v @ w                  # 32   (1*4 + 2*5 + 3*6)
np.dot(v, w)           # 32

# Mixed 1-D and 2-D
v = np.array([1, 2])
A @ v                  # [5 11]   matrix-vector product

# Batched matmul (3-D)
X = np.random.rand(10, 3, 4)   # 10 matrices of shape (3, 4)
Y = np.random.rand(10, 4, 2)
(X @ Y).shape          # (10, 3, 2)

# Element-wise product (Hadamard) - NOT matrix product
A * B                  # [[5 12]
                       #  [21 32]]

Decomposições (LU, QR, SVD)

SVD é a decomposição mais estável e funciona para qualquer matriz — use-a em caso de dúvida. Decomposição em autovalores só funciona para matrizes quadradas e pode ser numericamente instável para matrizes defeituosas. Cholesky é a mais rápida para matrizes simétricas positivo-definidas (comuns em covariância e otimização). QR é útil para mínimos quadrados e ortogonalização.

numpy
import numpy as np
A = np.array([[4, 3],
              [6, 3]])

# SVD: A = U @ diag(s) @ Vt
U, s, Vt = np.linalg.svd(A)
# U: (2,2) left singular vectors
# s: (2,) singular values (sorted descending)
# Vt: (2,2) right singular vectors (already transposed)

# Reconstruct A from SVD
A_reconstructed = U @ np.diag(s) @ Vt
np.allclose(A, A_reconstructed)   # True

# QR decomposition: A = Q @ R
Q, R = np.linalg.qr(A)
# Q: orthonormal columns
# R: upper triangular

# Cholesky (for symmetric positive-definite matrices)
S = A @ A.T   # symmetric positive-definite
L = np.linalg.cholesky(S)
np.allclose(S, L @ L.T)   # True

# Eigen-decomposition (square matrices)
w, V = np.linalg.eig(A)
# w: eigenvalues
# V: eigenvectors as columns

# Eigenvalues only (faster)
np.linalg.eigvals(A)

Sistemas Lineares e Inversa

Sempre prefira np.linalg.solve a calcular a inversa — é mais rápido, numericamente mais estável e evita as armadilhas de matrizes quase singulares. A inversa raramente é necessária na prática; se você se pegar escrevendo inv(A) @ b, troque por solve(A, b). pinv trata matrizes retangulares e singulares via SVD. Verifique cond(A) — um número de condição grande (>1e10) significa que seu sistema está numericamente mal condicionado.

numpy
import numpy as np

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

# Solve Ax = b (preferred - no explicit inverse)
x = np.linalg.solve(A, b)        # [1.6 1.1]
np.allclose(A @ x, b)            # True

# Multiple right-hand sides
B = np.array([[7, 1], [6, 2]])   # 2x2
X = np.linalg.solve(A, B)        # 2x2 solution matrix

# Inverse (avoid if you only need to solve Ax=b)
A_inv = np.linalg.inv(A)
A_inv @ b    # same result as solve, but slower & less stable

# Pseudo-inverse (works for non-square / singular matrices)
A_pinv = np.linalg.pinv(A)       # Moore-Penrose pseudo-inverse

# Determinant
np.linalg.det(A)    # 10.0

# Matrix rank
np.linalg.matrix_rank(A)   # 2

# Condition number (large = ill-conditioned)
np.linalg.cond(A)   # ~1.9

Normas e Operações Vetoriais

norm assume L2 para vetores e Frobenius para matrizes — especifique ord explicitamente por clareza em código de produção. Use ord=1 para distância de Manhattan (táxi) e ord=np.inf para distância de Chebyshev (máximo-absoluto). Produto vetorial só funciona para vetores 3-D. Para distâncias par a par entre muitos pontos, scipy.spatial.distance.cdist é mais rápido que um loop Python sobre norm.

numpy
import numpy as np
v = np.array([3, 4])

# Vector norms
np.linalg.norm(v)         # 5.0    L2 (Euclidean) - default
np.linalg.norm(v, ord=1)  # 7.0    L1 (sum of |x|)
np.linalg.norm(v, ord=np.inf)  # 4.0  L-infinity (max |x|)

# Matrix norms
A = np.array([[1, 2], [3, 4]])
np.linalg.norm(A)         # Frobenius norm (default for matrices)
np.linalg.norm(A, ord='fro')
np.linalg.norm(A, ord=2)  # spectral norm (largest singular value)
np.linalg.norm(A, ord=np.inf)  # max row sum

# Normalizing a vector (unit vector)
v / np.linalg.norm(v)

# Distance between two vectors
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
np.linalg.norm(a - b)         # Euclidean distance
np.linalg.norm(a - b, ord=1)  # Manhattan distance

# Outer product, cross product
np.cross([1, 0, 0], [0, 1, 0])   # [0 0 1]   (3-D only)
np.outer([1, 2], [10, 20, 30])   # (2, 3)

Mínimos Quadrados e Regressão

np.linalg.lstsq resolve problemas de mínimos quadrados sem formar as equações normais (mais estável). Retorna a solução, os resíduos, o posto e os valores singulares — útil para diagnosticar problemas com posto deficiente. Para ajuste polinomial, polyfit + poly1d dão uma API conveniente, mas cuidado com polinômios de grau alto (instabilidade numérica). Use numpy.polynomial.Polynomial para melhor condicionamento numérico em trabalho sério.

numpy
import numpy as np

# Linear least squares: solve Ax = b for over-determined A (more rows than cols)
# Minimizes ||Ax - b||^2
A = np.array([[1, 1],
              [1, 2],
              [1, 3],
              [1, 4]])         # design matrix (4x2)
b = np.array([6, 5, 7, 10])    # observations

x, residuals, rank, sv = np.linalg.lstsq(A, b, rcond=None)
# x: best-fit parameters [intercept, slope] = [3.5, 1.4]
# residuals: sum of squared errors
# rank: effective rank of A
# sv: singular values of A

# Polynomial fitting (least squares under the hood)
x_data = np.array([0, 1, 2, 3, 4])
y_data = np.array([1, 3, 7, 13, 21])
coeffs = np.polyfit(x_data, y_data, deg=2)   # quadratic fit
# coeffs[0]*x^2 + coeffs[1]*x + coeffs[2]

# Evaluate polynomial
poly = np.poly1d(coeffs)
poly(2.5)   # predict y at x=2.5

# Polynomial roots (zeros)
np.roots([1, -3, 2])   # roots of x^2 - 3x + 2 = 0 -> [2, 1]
09

Números Aleatórios

Generator Moderno (default_rng)

np.random.default_rng é a API moderna e recomendada. É mais rápida que as funções legadas np.random.*, tem melhores propriedades estatísticas e usa objetos Generator explícitos (sem estado global oculto) — tornando reprodutibilidade e paralelismo muito mais fáceis. Sempre passe uma seed explícita para pesquisa e testes reproduzíveis.

numpy
import numpy as np

# Create a Generator with a seed (modern API, NumPy >= 1.17)
rng = np.random.default_rng(seed=42)

# Uniform [0, 1) floats
rng.random()              # scalar
rng.random(size=5)        # 1-D array of 5
rng.random((3, 4))        # 3x4 array

# Standard normal (mean 0, std 1)
rng.standard_normal(5)
rng.standard_normal((2, 3))

# Integers in [low, high)
rng.integers(0, 10, size=5)       # 5 random ints in [0, 10)
rng.integers(1, 7, size=(2, 3), endpoint=True)  # include 7

# Choice: sample from an array
rng.choice([10, 20, 30, 40], size=5)
rng.choice([10, 20, 30, 40], size=5, replace=True)   # default
rng.choice(range(100), size=10, replace=False)        # without replacement

# Why default_rng? Faster, better statistical properties, no global state.
# Legacy np.random.rand/randn/seed still works but is discouraged.

Distribuições Comuns

NumPy fornece dezenas de distribuições pela API Generator. Os parâmetros seguem convenções estatísticas (loc=média, scale=desvio para normal; lam=lambda para Poisson). multivariate_normal exige uma matriz de covariância e retorna amostras com a estrutura de correlação especificada. shuffle muta in-place enquanto permutation retorna um novo array.

numpy
import numpy as np
rng = np.random.default_rng(42)

# Continuous distributions
rng.uniform(0, 10, size=5)        # uniform in [low, high)
rng.normal(loc=100, scale=15, size=5)   # normal(mu, sigma)
rng.standard_normal(size=5)       # standard normal
rng.exponential(scale=2.0, size=5)   # exponential
rng.gamma(shape=2.0, scale=1.5, size=5)
rng.beta(a=2, b=5, size=5)
rng.lognormal(mean=0.0, sigma=1.0, size=5)
rng.chisquare(df=3, size=5)
rng.standard_t(df=10, size=5)

# Discrete distributions
rng.binomial(n=10, p=0.5, size=5)
rng.poisson(lam=3.0, size=5)
rng.geometric(p=0.1, size=5)
rng.negative_binomial(n=5, p=0.5, size=5)

# Multi-variate normal
mean = [0, 0]
cov = [[1, 0.5], [0.5, 1]]
rng.multivariate_normal(mean, cov, size=1000)   # shape (1000, 2)

# Shuffle & permutation (in-place / copy)
arr = np.arange(10)
rng.shuffle(arr)        # in-place shuffle
perm = rng.permutation(10)   # returns a new array

Reprodutibilidade e Seeds

Para experimentos reproduzíveis, fixe tanto a seed quanto a versão do NumPy — o fluxo de números aleatórios pode mudar entre releases do NumPy. Para computação paralela, use spawn() para criar fluxos filhos independentes; nunca apenas some o índice do worker à seed (colisões são mais prováveis do que se imagina). SeedSequence trata a divisão de entropia corretamente.

numpy
import numpy as np

# Same seed -> same sequence of random numbers
r1 = np.random.default_rng(42)
r2 = np.random.default_rng(42)
print(r1.random(3))    # [0.7739 0.4389 0.8586]
print(r2.random(3))    # same exact values

# Different seeds -> independent sequences
r3 = np.random.default_rng(123)
print(r3.random(3))    # different values

# Seed from entropy (non-reproducible) - default if seed omitted
r4 = np.random.default_rng()    # seeded from OS entropy

# Spawn independent child generators (for parallelism)
parent = np.default_rng(42)
children = parent.spawn(4)   # 4 independent Generators
# Each child produces an independent, reproducible stream

# SeedSequence for advanced control
ss = np.random.SeedSequence(42)
child_seeds = ss.spawn(4)
streams = [np.random.default_rng(s) for s in child_seeds]

# Reproducibility across versions: pin numpy version too!

Embaralhamento, Permutação e Amostragem

Use rng.permutation(indices) e depois indexe seus dados com fancy indexing — este é o padrão canônico para embaralhar conjuntos de dados antes do treino. choice com replace=False é amostragem sem reposição; com p= você amostra com probabilidades personalizadas. Para bootstrap, use rng.integers para amostrar com reposição (um valor pode aparecer várias vezes).

numpy
import numpy as np
rng = np.random.default_rng(42)

# Shuffle (in-place)
a = np.arange(10)
rng.shuffle(a)         # a is now shuffled

# Permutation (returns a new array, original untouched)
b = np.arange(10)
perm = rng.permutation(b)
# b is unchanged, perm is the shuffled version

# Permutation of indices (common pattern for shuffling a dataset)
idx = rng.permutation(100)
X_shuffled = X[idx]
y_shuffled = y[idx]

# Random choice
rng.choice(100, size=10, replace=False)   # 10 unique indices
rng.choice([1, 2, 3], size=10, p=[0.1, 0.3, 0.6])  # weighted

# Sample rows of a 2-D array
data = np.arange(20).reshape(10, 2)
row_idx = rng.choice(10, size=3, replace=False)
sample = data[row_idx]    # 3 random rows

# Bootstrap sampling (with replacement)
boot_idx = rng.integers(0, len(data), size=len(data))
boot_sample = data[boot_idx]

Definindo Estado Aleatório (API Legada)

A API legada np.random.seed/rand/randn usa estado global mutável — prática num REPL, mas frágil em bibliotecas e código paralelo. Se você precisar da API legada, crie um objeto RandomState explícito em vez de mutar o estado global. Para código novo, use sempre default_rng. As convenções de argumentos diferem um pouco (randint exclui high por padrão; integers inclui high só com endpoint=True).

numpy
import numpy as np

# Legacy global-state API (still common in old code)
np.random.seed(42)
a = np.random.rand(3)      # [0.3745 0.9507 0.7320]

np.random.seed(42)
b = np.random.rand(3)      # same as a - global state was reset

# Functions operate on the global RandomState
np.random.rand(2, 3)       # uniform [0, 1)
np.random.randn(2, 3)      # standard normal
np.random.randint(0, 10, 5)
np.random.choice([1, 2, 3], 2)
np.random.shuffle(arr)

# Create an independent RandomState (better than global)
rs = np.random.RandomState(42)
rs.rand(3)                 # independent of np.random's global state

# Migration: replace np.random.X(args) with rng.X(args)
# rng = np.random.default_rng(seed)
# rand()       -> random()
# randn()      -> standard_normal()
# randint(a,b) -> integers(a, b)   # note: endpoint differs
# seed(s)      -> default_rng(s)   # explicit Generator
10

Indexação Avançada

Detalhes da Indexação Fancy

Indexação fancy com arrays de inteiros seleciona elementos nas posições dadas e sempre retorna uma cópia. Ao indexar um array 2-D com dois arrays de índice, os arrays são pareados elemento a elemento (pontos), NÃO um produto cartesiano — use np.ix_ para o produto cartesiano (retângulo de linhas × colunas). Indexação fancy é a única forma de selecionar elementos não contíguos ou repetidos.

numpy
import numpy as np
a = np.arange(10, 20)   # [10 11 12 13 14 15 16 17 18 19]

# Index with integer arrays
indices = np.array([0, 3, 5, 8])
a[indices]              # [10 13 15 18]

# Negative indices
a[[-1, -2, -3]]         # [19 18 17]

# Index arrays can repeat (creates duplicates)
a[[0, 0, 1, 1]]         # [10 10 11 11]

# Assign through fancy indexing
a[[0, 3, 5]] = -1       # set those positions to -1
a[[1, 2]] = [100, 200]  # different value per position

# 2-D: pair (row, col) indices element-wise
b = np.arange(12).reshape(3, 4)
rows = np.array([0, 1, 2])
cols = np.array([1, 2, 3])
b[rows, cols]           # [1 6 11]  points (0,1), (1,2), (2,3)

# For a cross-product (rectangle) use np.ix_
b[np.ix_([0, 2], [1, 3])]
# [[ 1  3]
#  [ 9 11]]

Arrays Booleanos em Profundidade

A indexação booleana sempre retorna um array 1-D dos elementos que casam, independentemente da dimensionalidade da entrada — e sempre uma cópia. Combine condições com & | ~ (operadores bit a bit), NÃO and/or (que exigem valores booleanos únicos). Uma máscara booleana 1-D num array 2-D seleciona linhas inteiras. Conte valores True com .sum(), já que True == 1.

numpy
import numpy as np
a = np.array([5, 10, 15, 20, 25, 30])

# Boolean mask
mask = a > 15
a[mask]                  # [20 25 30]
a[a > 15]                # equivalent

# Multiple conditions: use & | ~ (NOT and/or)
a[(a > 10) & (a < 30)]   # [15 20 25]
a[(a < 10) | (a > 25)]   # [5 30]
a[~(a > 15)]             # [5 10 15]  negation

# Count True
mask.sum()               # 3   (True == 1)

# Boolean indexing returns a COPY (not a view)
b = a[a > 15]
b[0] = 999
print(a[3])              # 20  - a unchanged

# 2-D boolean mask (must match array shape)
M = np.arange(12).reshape(3, 4)
mask2d = M > 5
M[mask2d]                # 1-D array of matching values (flattened)

# Row selection with a 1-D boolean mask
row_mask = np.array([True, False, True])
M[row_mask]              # rows 0 and 2

np.where e np.choose

np.where é o condicional mais comum — com três argumentos é um if-else vetorizado, com um argumento retorna os índices dos valores True. Para múltiplas condições mutuamente exclusivas, np.select é mais limpo que chamadas np.where aninhadas. np.choose é menos comum, mas útil para selecionar de mais de dois arrays com base num índice inteiro.

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

# np.where(cond) -> indices where cond is True
np.where(a > 3)             # (array([3, 4]),)   tuple of index arrays

# np.where(cond, x, y) -> vectorized ternary
np.where(a > 3, "big", "small")
# ['small' 'small' 'small' 'big' 'big']

# np.where with arrays for x and y
np.where(a % 2 == 0, a * 10, a)   # double the evens, keep odds

# Multi-dim where
M = np.array([[1, 2], [3, 4]])
np.where(M > 2)             # (array([1, 1]), array([0, 1]))  (row, col) pairs

# np.choose: pick from multiple arrays based on integer index
choices = [[10, 20, 30], [100, 200, 300], [1000, 2000, 3000]]
np.choose([0, 2, 1], choices)   # [10 2000 300]

# np.select: multiple conditions
conds = [a < 3, a > 4, (a >= 3) & (a <= 4)]
choices = ["low", "high", "mid"]
np.select(conds, choices)   # ['low' 'mid' 'mid' 'mid' 'high']

Indexação com np.ix_

np.ix_ é essencial quando você quer um sub-bloco retangular selecionado por listas de índices de linha e coluna — sem ele, dois arrays de índice são pareados elemento a elemento (dando pontos em vez de uma grade). Esta é uma das pegadinhas mais comuns do NumPy. O mesmo truque funciona com máscaras booleanas para selecionar linhas e colunas simultaneamente.

numpy
import numpy as np
a = np.arange(20).reshape(4, 5)

# Select rows 0 and 2, columns 1 and 3 (cross product)
rows = [0, 2]
cols = [1, 3]
a[np.ix_(rows, cols)]
# [[ 1  3]
#  [11 13]]

# Without np.ix_, fancy indexing pairs the arrays element-wise:
a[np.array(rows), np.array(cols)]
# ERROR (or wrong result): pairs (0,1) and (2,3) - points, not rectangle

# Boolean masks also work with np.ix_
row_mask = np.array([True, False, True, False])
col_mask = np.array([False, True, False, True, False])
a[np.ix_(row_mask, col_mask)]   # rows where True, cols where True

# 3-D indexing with ix_
b = np.arange(24).reshape(2, 3, 4)
b[np.ix_([0], [0, 2], [1, 3])].shape   # (1, 2, 2)

# np.ix_ converts 1-D index arrays into broadcastable open grids
# so the result is a (Cartesian) rectangle, not points

Layout de Memória e Views

Slicing básico retorna views (compartilham memória); indexação fancy/booleana retorna cópias. Use np.shares_memory para verificar se dois arrays se sobrepõem — importante para operações in-place e para entender se uma mutação vai se propagar. Se você precisa de desempenho máximo num loop quente, np.ascontiguousarray garante memória contígua para que loops em nível C rodem sem indireção.

numpy
import numpy as np
a = np.arange(12).reshape(3, 4)

# Most slicing returns VIEWS (no data copy)
v = a[1:, 1:]   # view
v[0, 0] = 99
print(a[1, 1])  # 99   - a was modified

# Fancy and boolean indexing always return COPIES
b = a[[0, 1, 2]]
b[0] = -1
print(a[0, 0])  # 0   - a unchanged

# Check if two arrays share memory
np.shares_memory(a, v)   # True
np.shares_memory(a, b)   # False

# Force a copy with .copy()
independent = a[1:, 1:].copy()

# Memory layout flags
a.flags['C_CONTIGUOUS']    # True  - row-major (C order)
a.flags['F_CONTIGUOUS']    # False - column-major (Fortran)

# Convert to a guaranteed-contiguous array (sometimes speeds up ops)
a_contig = np.ascontiguousarray(a)
a_fortran = np.asfortranarray(a)

# may_share_memory: weaker, faster check
np.may_share_memory(a, v)  # True
11

E/S de Arrays

Salvar e Carregar .npy / .npz

.npy guarda um único array; .npz guarda múltiplos arrays nomeados num contêiner zip. savez_compressed produz arquivos menores ao custo de tempo de CPU. O NpzFile retornado por np.load é preguiçoso — os arrays são carregados no primeiro acesso, então use um bloco with para garantir que o handle do arquivo feche. Esses formatos binários preservam dtype e forma exatamente, diferentemente de CSV/texto.

numpy
import numpy as np
a = np.arange(12).reshape(3, 4)
b = np.array([1, 2, 3])

# Save a single array (binary .npy format)
np.save("a.npy", a)
loaded = np.load("a.npy")
np.array_equal(a, loaded)   # True

# Save multiple arrays (zipped .npz)
np.savez("data.npz", a=a, b=b, c=np.zeros(3))
data = np.load("data.npz")
print(data["a"])   # the saved array a
print(data["b"])   # array b
print(list(data.keys()))   # ['a', 'b', 'c']

# Compressed savez
np.savez_compressed("data.npz", a=a, b=b)   # smaller file, slower

# Loading returns a lazy NpzFile - arrays load on access
# Close it explicitly if you have many files open
with np.load("data.npz") as data:
    a = data["a"]
    b = data["b"]
# file handle auto-closed after the with block

Arquivos de Texto (CSV, TSV)

np.savetxt/loadtxt funcionam apenas para arrays 1-D e 2-D — para dimensões maiores use .npy/.npz. genfromtxt é mais tolerante a valores ausentes e tipos heterogêneos, mas lento em arquivos grandes. Para trabalho real com CSV, pandas.read_csv é muito mais rápido e cheio de recursos — converta para NumPy com .to_numpy() quando terminar a limpeza.

numpy
import numpy as np

# Save as plain text (1-D or 2-D only)
a = np.arange(12).reshape(3, 4)
np.savetxt("a.csv", a, delimiter=",", fmt="%d",
           header="col1,col2,col3,col4", comments="")

# Load text
loaded = np.loadtxt("a.csv", delimiter=",", skiprows=1, dtype=int)

# genfromtxt: handles missing values and irregular data
data = np.genfromtxt("data.csv", delimiter=",",
                     names=True,          # first row = field names
                     dtype=None,          # infer types per column
                     missing_values="",
                     filling_values=0)
# data is a structured array; access columns by name
print(data["age"])

# More flexible: pandas.read_csv, then convert to NumPy
import pandas as pd
df = pd.read_csv("data.csv")
arr = df.to_numpy()      # 2-D ndarray
ages = df["age"].to_numpy()   # 1-D

Arquivos Mapeados em Memória

np.memmap permite trabalhar com arrays maiores que a RAM mapeando um arquivo de disco na memória — só as páginas acessadas são carregadas. Essencial para conjuntos de dados de vários GB. Lembre de flush() após escrever e de del ou close no memmap para liberar o handle. Slicing lê só as páginas necessárias, mas indexação fancy pode forçar uma carga completa.

numpy
import numpy as np

# Create a large array on disk (without loading it all into RAM)
shape = (10000, 10000)
dtype = np.float64
mm = np.memmap("big.dat", dtype=dtype, mode="w+", shape=shape)

# Write to it as if it were a normal array
mm[:] = np.arange(shape[0])[:, None] + np.arange(shape[1])[None, :]
mm.flush()   # flush changes to disk

# Re-open for reading without loading the whole file
mm_read = np.memmap("big.dat", dtype=dtype, mode="r", shape=shape)
print(mm_read[0, 0])    # access a small slice -> only that page loads
print(mm_read[-1, -1])

# Mode: 'r' (read-only), 'r+' (read/write), 'w+' (create/overwrite)
# Slicing a memmap returns a normal ndarray (copy) or a memmap view
# depending on the operation.

# Useful for processing huge datasets that don't fit in RAM
# (e.g. iterating over chunks of a multi-GB array)

Interoperando com Outras Bibliotecas

A maioria das bibliotecas de ML compartilha memória com NumPy (zero-copy) — torch.from_numpy e tf.constant envolvem o mesmo buffer, então mutar um afeta o outro. Tensores GPU do PyTorch precisam ser movidos para CPU antes de .numpy(). Use tobytes / frombuffer para serialização quando precisar de bytes crus (ex.: enviar por socket). Sempre verifique shape e dtype após conversões.

numpy
import numpy as np
import pandas as pd

# NumPy <-> pandas
df = pd.DataFrame({"a": [1, 2, 3], "b": [4.0, 5.0, 6.0]})
arr = df.to_numpy()      # 2-D float array
col = df["a"].to_numpy() # 1-D int array
df2 = pd.DataFrame(arr, columns=["x", "y"])

# NumPy <-> PyTorch
import torch
t = torch.from_numpy(arr)     # shares memory (no copy)
back = t.numpy()              # only works for CPU tensors

# NumPy <-> TensorFlow
import tensorflow as tf
tensor = tf.constant(arr)
back = tensor.numpy()

# NumPy <-> JAX
import jax.numpy as jnp
j_arr = jnp.asarray(arr)      # JAX array (immutable)

# NumPy <-> bytes (for serialization / network)
buf = arr.tobytes()
restored = np.frombuffer(buf, dtype=arr.dtype).reshape(arr.shape)

# Convert list of arrays to a single array (must be same shape)
list_of_arrays = [np.array([1, 2]), np.array([3, 4])]
np.array(list_of_arrays)   # shape (2, 2)

E/S de Arrays Estruturados

Arrays estruturados permitem armazenar dados heterogêneos, tipo registro, num único array NumPy — útil quando pandas é exagero ou indisponível. O formato binário .npy preserva o dtype estruturado exatamente. Para trabalho tabular real, pandas quase sempre é a escolha melhor; use arrays estruturados para interop de baixo nível com código C/Fortran ou quando a memória for extremamente apertada.

numpy
import numpy as np

# Define a structured dtype
dt = np.dtype([("name", "U20"), ("age", "i4"), ("score", "f4")])
data = np.array([("Alice", 30, 9.5),
                 ("Bob", 25, 8.0),
                 ("Carol", 35, 9.8)], dtype=dt)

# Save / load (binary preserves structure)
np.save("people.npy", data)
loaded = np.load("people.npy")
print(loaded["name"])   # ['Alice' 'Bob' 'Carol']
print(loaded["age"].mean())   # 30.0

# CSV with mixed types: better to use pandas
import pandas as pd
df = pd.DataFrame(data)
df.to_csv("people.csv", index=False)

# Convert a structured array to a regular 2-D array
arr_2d = data.view([("age", "i4"), ("score", "f4")]).reshape(-1)  # view
# or just stack the numeric columns
numeric = np.column_stack([data["age"], data["score"]])

# Sort by a field
sorted_data = np.sort(data, order="score")   # ascending by score
sorted_data[-1]["name"]   # 'Carol'
12

Operações com Datas

Criando Arrays de Datetime

datetime64 do NumPy é um datetime de largura fixa (8 bytes) — muito mais eficiente que objetos datetime do Python. Especifique a precisão com um sufixo de unidade: [Y] ano, [M] mês, [D] dia, [h] hora, [m] minuto, [s] segundo, [ms] milissegundo. np.arange funciona com datetime64 para gerar intervalos de datas.

numpy
import numpy as np

# From ISO strings
dates = np.array(["2024-01-15", "2024-02-20", "2024-03-25"],
                 dtype="datetime64[D]")
# dtype [D] = day precision

# Different precisions
np.datetime64("2024-01-15")              # day precision
np.datetime64("2024-01-15T10:30")        # minute precision
np.datetime64("2024-01-15T10:30:45.123") # ms precision

# Array of datetimes
np.array(["2024-01", "2024-02", "2024-03"], dtype="datetime64[M]")

# Arange with datetime
np.arange("2024-01", "2024-06", dtype="datetime64[M]")
# ['2024-01' '2024-02' '2024-03' '2024-04' '2024-05']

# Today (UTC)
np.datetime64("today", "D")
np.datetime64("now", "s")

Aritmética com Timedelta

Subtrair dois arrays datetime64 dá um array timedelta64. NumPy trata corretamente a aritmética de meses e anos (comprimentos de mês variam). np.busday_offset e np.is_busday fornecem lógica de dias úteis (pulando fins de semana e, opcionalmente, feriados). Para suporte mais sofisticado a calendários comerciais, use o CustomBusinessDay do pandas.

numpy
import numpy as np

start = np.datetime64("2024-01-01")
end = np.datetime64("2024-12-31")

# Difference is a timedelta64
diff = end - start
print(diff, diff.dtype)   # 365 days, timedelta64[D]

# Add / subtract timedeltas
start + np.timedelta64(7, "D")       # 2024-01-08
start + np.timedelta64(1, "M")       # 2024-02-01 (month added)
start + np.timedelta64(2, "h")       # 2024-01-01T02:00

# Business day arithmetic
np.busday_offset("2024-01-15", 1)     # next business day
np.is_busday("2024-01-15")            # Monday -> True
np.is_busday("2024-01-13")            # Saturday -> False

# Count business days in a range
np.busday_count("2024-01-01", "2024-02-01")   # 23

# Array of business days
np.arange("2024-01-01", "2024-01-10", dtype="datetime64[D]")
# [Mon Tue Wed Thu Fri Sat Sun Mon Tue]

Intervalos de Datas e Reamostragem

datetime64 do NumPy suporta geração de intervalos e aritmética básica, mas para reamostragem, agrupamento e fuso horário, o pandas é muito mais poderoso. O padrão é: faça a manipulação pesada de datas no pandas e depois converta de volta para datetime64 do NumPy com .to_numpy() quando precisar de desempenho bruto. datetime64 do NumPy é sempre ingênuo de fuso (UTC).

numpy
import numpy as np

# Generate a range of dates
daily = np.arange("2024-01-01", "2024-02-01", dtype="datetime64[D]")
# 31 daily dates

monthly = np.arange("2024-01", "2025-01", dtype="datetime64[M]")
# 12 monthly dates

hourly = np.arange("2024-01-01T00", "2024-01-02T00", dtype="datetime64[h]")
# 24 hourly dates

# Resample daily to monthly: take last value of each month
# NumPy itself doesn't have a resample API - use pandas
import pandas as pd
ts = pd.Series(np.random.rand(31), index=daily)
monthly_mean = ts.resample("ME").mean()    # one value per month

# Compute the weekday of each date
weekdays = (daily.astype("datetime64[D]").view("int64") - 4) % 7
# 0 = Monday, ..., 6 = Sunday

# Or use pandas for richer datetime features
pd.DatetimeIndex(daily).day_name()   # ['Monday' 'Tuesday' ...]

Datetime e Interop Python

A conversão entre datetime64 do NumPy e datetime do Python é direta via astype. Cuidado com fusos horários — datetime64 do NumPy é sempre UTC e não tem informação de tz, então converter um Timestamp do pandas ciente de tz para NumPy descarta silenciosamente o tz. Para qualquer trabalho ciente de fuso, use Timestamps do pandas do começo ao fim.

numpy
import numpy as np
import datetime as dt

# NumPy datetime64 -> Python datetime
np_dt = np.datetime64("2024-01-15T10:30:00")
py_dt = np_dt.astype(dt.datetime)   # Python datetime object
# datetime.datetime(2024, 1, 15, 10, 30)

# Python datetime -> NumPy datetime64
np_again = np.datetime64(py_dt)

# Convert a NumPy datetime array to Python datetimes
arr = np.arange("2024-01-01", "2024-01-05", dtype="datetime64[D]")
py_list = arr.astype(dt.datetime).tolist()
# [datetime.date(2024, 1, 1), ...]

# Pandas Timestamp (most flexible)
import pandas as pd
ts = pd.Timestamp("2024-01-15 10:30:00", tz="US/Eastern")
ts.to_numpy()   # converts to UTC datetime64 (tz info dropped!)

# Unix timestamp interconversion
ts_unix = (np_dt - np.datetime64("1970-01-01", "s")) / np.timedelta64(1, "s")
# 1705314600.0   (seconds since Unix epoch)
back = np.datetime64(int(ts_unix), "s").astype("datetime64[s]") + \
       np.timedelta64(int((ts_unix % 1) * 1e9), "ns")

Datetime na Prática

Aritmética de datas no NumPy é rápida, mas limitada — para agrupamento, reamostragem e fuso horário, o pandas é a ferramenta certa. O exemplo que calcula o dia do ano mostra o tipo de ginástica de baixo nível que o NumPy te força a fazer; o DatetimeIndex.dayofyear do pandas faz isso numa chamada. Use datetime64 do NumPy para armazenamento e aritmética simples; recorra ao pandas para análise.

numpy
import numpy as np

# Compute age in years from birthdates
birthdays = np.array(["1990-05-15", "1985-11-20", "2000-03-10"],
                     dtype="datetime64[D]")
today = np.datetime64("today", "D")
ages_days = (today - birthdays).astype("timedelta64[D]")
ages_years = (ages_days / 365.25).astype(int)
# array([33, 38, 24]) approximately

# Find dates within a window
dates = np.arange("2024-01-01", "2024-06-01", dtype="datetime64[D]")
mask = (dates >= "2024-02-01") & (dates < "2024-03-01")
february = dates[mask]   # all February dates

# Compute day of year
jan1 = dates.astype("datetime64[Y]").astype("datetime64[D]")
# Hmm, this loses month/day; instead:
day_of_year = (dates - dates.astype("datetime64[M]") \
               .astype("datetime64[D]") + 1).astype(int)

# Group by month (manual; pandas is easier)
months = dates.astype("datetime64[M]")
unique_months = np.unique(months)
for m in unique_months:
    mask = months == m
    print(m, dates[mask].size, "days")
13

Operações com Strings

Operações de String Vetorizadas (np.char)

np.char fornece versões vetorizadas das funções de str do Python, operando elemento a elemento em arrays de strings. Elas retornam novos arrays (strings são imutáveis no NumPy). Para processamento de strings mais sofisticado (extração regex, lógica condicional), o acessador .str do pandas é muito mais capaz e ergonômico — prefira-o para trabalho real de tratamento de dados.

numpy
import numpy as np
names = np.array(["Alice", "Bob", "Carol", "dave"])

# np.char module: vectorized string operations
np.char.upper(names)      # ['ALICE' 'BOB' 'CAROL' 'DAVE']
np.char.lower(names)      # ['alice' 'bob' 'carol' 'dave']
np.char.title(names)      # ['Alice' 'Bob' 'Carol' 'Dave']
np.char.capitalize(names)
np.char.swapcase(names)

# Strip whitespace
s = np.array(["  hello  ", "world  "])
np.char.strip(s)          # ['hello' 'world']
np.char.lstrip(s)
np.char.rstrip(s)

# Splitting and joining
np.char.split(np.array(["a,b,c", "d,e,f"]), sep=",")
# [list(['a', 'b', 'c']) list(['d', 'e', 'f'])]

np.char.join("-", np.array(["abc", "def"]))
# ['a-b-c' 'd-e-f']

# Replace
np.char.replace(np.array(["foo bar", "baz foo"]), "foo", "XXX")
# ['XXX bar' 'baz XXX']

Comparação e Busca de Strings

np.char tem funções vetorizadas de comparação, busca e comprimento de strings. find retorna -1 quando não encontra (não False), então verifique >= 0. Para busca e extração com regex, use .str.contains/.str.extract do pandas com regex=True — o suporte a regex do np.char é limitado e inconsistente entre versões.

numpy
import numpy as np
words = np.array(["apple", "banana", "cherry", "date"])

# Element-wise comparison
np.char.equal(words, "apple")        # [ True False False False]
np.char.not_equal(words, "apple")

# Lexicographic comparison
np.char.greater(words, "c")          # [False False  True  True]

# Substring search
np.char.find(words, "a")             # index of 'a', -1 if not found
np.char.count(np.array(["banana", "apple"]), "a")
# [3 1]

# Startswith / endswith
np.char.startswith(words, "a")       # [ True False False False]
np.char.endswith(words, "e")         # [ True False False  True]

# Contains (regex-capable in newer versions)
np.char.find(words, "er") >= 0       # [False False  True False]

# String length
np.char.str_len(words)               # [5 6 6 4]

Concatenação e Formatação de Strings

Concatenação de strings no np.char é elemento a elemento e não tão ergonômica quanto o operador + do Python. Para juntar com separador, você precisa encadear chamadas np.char.add ou usar np.core.defchararray.add. Para a maioria dos trabalhos de formatação de string, uma list comprehension ou o .str.cat do pandas é mais claro que np.char. np.char.mod suporta formatação com % para geração de strings em lote.

numpy
import numpy as np
first = np.array(["Alice", "Bob", "Carol"])
last = np.array(["Smith", "Jones", "Brown"])

# Element-wise concatenation
np.char.add(first, last)              # ['AliceSmith' 'BobJones' 'CarolBrown']
np.char.add(first, " " + last)        # nope, this broadcasts weirdly

# Proper way to add a separator
np.char.add(np.char.add(first, " "), last)
# ['Alice Smith' 'Bob Jones' 'Carol Brown']

# Multiply (repeat)
np.char.multiply(np.array(["ab", "cd"]), 3)
# ['ababab' 'cdcdcd']

# Center / ljust / rjust with fill character
np.char.center(np.array(["hi", "yo"]), width=6, fillchar="-")
# ['--hi--' '--yo--']
np.char.rjust(np.array(["1", "12", "123"]), width=5, fillchar="0")
# ['00001' '00012' '00123']

# Format strings
np.char.mod("%05d", np.array([1, 23, 456]))
# ['00001' '00023' '00456']

# Modern Python f-strings don't vectorize - use np.char.mod or list comp
[f"{n:05d}" for n in [1, 23, 456]]   # Python alternative

Dtypes de String e Memória

Dtypes de string do NumPy usam largura fixa: 'U' = Unicode (4 bytes/char), 'S' = bytes ASCII (1 byte/char). Strings mais longas que a largura fixa são truncadas silenciosamente — fonte comum de perda de dados. Para strings de comprimento variável sem truncamento, use dtype=object (mais lento, mas guarda objetos str do Python). Escolha 'S' para dados ASCII e economize 4x a memória vs 'U'.

numpy
import numpy as np

# Fixed-length unicode strings (default)
s = np.array(["hello", "world"])
s.dtype    # dtype('<U5')   <- max length 5 unicode chars

# Fixed-width string dtype (saves memory for ASCII)
s_ascii = np.array(["hello", "world"], dtype="S5")
s_ascii.dtype   # dtype('|S5')  <- bytes, length 5

# If a string exceeds the fixed width, it's truncated
np.array(["abcdef"], dtype="U3")   # ['abc']
np.array(["abcdef"], dtype="S3")   # [b'abc']

# Object dtype for variable-length strings (no truncation, slower)
s_obj = np.array(["a" * 100, "b"], dtype=object)
s_obj.dtype   # dtype('O')

# Convert between unicode and bytes
np.char.encode(np.array(["hello"]), "utf-8")   # array([b'hello'])
np.char.decode(np.array([b"hello"]), "utf-8")  # array(['hello'])

# When loading text data, dtype=None infers per column
# but for strings use U/S for fixed-width or object for variable

Padrões Práticos de String

np.unique com return_inverse=True é a forma padrão de codificar strings categóricas como inteiros (label encoding). Para one-hot encoding, use pandas.get_dummies ou o OneHotEncoder do sklearn. Zerar números à esquerda como strings é o truque para tornar a ordenação de nomes de arquivo lexicográfica ('10' < '2' como strings, mas '010' > '002'). Encadear np.char.replace é a solução alternativa para múltiplas substituições.

numpy
import numpy as np

# Build a categorical label array
labels = np.array(["cat", "dog", "cat", "bird", "dog"])

# Encode strings to integers
unique, encoded = np.unique(labels, return_inverse=True)
print(unique)     # ['bird' 'cat' 'dog']
print(encoded)    # [1 2 1 0 2]   integer codes

# Decode integers back to strings
labels_back = unique[encoded]
# ['cat' 'dog' 'cat' 'bird' 'dog']

# Filter rows of a 2-D array by a string column
data = np.array([["Alice", "30"], ["Bob", "25"], ["Carol", "35"]])
mask = np.char.startswith(data[:, 0], "A")
data[mask]   # [['Alice' '30']]

# Pad numbers as zero-padded strings (for sorting filenames)
nums = np.array([1, 10, 100, 2])
padded = np.char.zfill(nums.astype(str), 3)
# ['001' '010' '100' '002']   now sorts lexicographically

# Compute a sorted argsort using string keys
keys = np.array(["banana", "apple", "cherry"])
order = np.argsort(keys)
keys[order]   # ['apple' 'banana' 'cherry']

# Replace multiple patterns (must chain - no vectorized replace-all)
arr = np.array(["a-b", "c_d", "e.f"])
for ch in ["-", "_", "."]:
    arr = np.char.replace(arr, ch, " ")
print(arr)   # ['a b' 'c d' 'e f']
14

Desempenho e Vetorização

Vetorização vs Loops

A regra de desempenho mais importante do NumPy: evite loops Python sobre elementos de arrays. Cada iteração incorre em custo do interpretador Python; operações NumPy vetorizadas rodam numa única chamada C sobre memória contígua. Acelerações de 50-100x são típicas. Antes de escrever um loop, pergunte: 'Existe uma ufunc, redução ou truque de broadcasting que faça isso?'

numpy
import numpy as np
import time

# BAD: Python loop (slow)
def slow_sum(arr):
    total = 0
    for x in arr:
        total += x
    return total

# GOOD: NumPy reduction (vectorized)
def fast_sum(arr):
    return arr.sum()

big = np.arange(10_000_000)

start = time.perf_counter()
slow_sum(big)
print("loop:", time.perf_counter() - start)   # ~0.6s

start = time.perf_counter()
fast_sum(big)
print("numpy:", time.perf_counter() - start)  # ~0.005s   ~100x faster

# Rule of thumb: if you're writing a for loop over array elements,
# there's probably a vectorized NumPy operation that's 50-100x faster.
# Look for: reductions (sum, mean, max), ufuncs, broadcasting, einsum.

np.einsum para Contrações de Tensores

einsum é a operação de tensor mais flexível do NumPy — uma única sintaxe cobre matmul, transpose, trace, diagonal, sum, produto externo, operações em lote e contrações arbitrárias. A string especifica eixos de entrada e saída; eixos somados são descartados. Use optimize=True para cadeias de contrações e evitar explosão de memória intermediária. A notação exige prática, mas compensa enormemente.

numpy
import numpy as np

# einsum: Einstein summation - the Swiss Army knife of tensor ops
A = np.random.rand(3, 4)
B = np.random.rand(4, 5)

# Matrix multiplication: C[i,k] = sum_j A[i,j] * B[j,k]
C = np.einsum("ij,jk->ik", A, B)   # same as A @ B

# Transpose
np.einsum("ij->ji", A)             # A.T

# Sum all elements
np.einsum("ij->", A)               # A.sum()

# Sum along an axis
np.einsum("ij->i", A)              # A.sum(axis=1)
np.einsum("ij->j", A)              # A.sum(axis=0)

# Row-wise dot product with a vector
v = np.random.rand(4)
np.einsum("ij,j->i", A, v)         # A @ v

# Outer product
a = np.random.rand(3)
b = np.random.rand(4)
np.einsum("i,j->ij", a, b)         # np.outer(a, b)

# Batched matrix multiply
X = np.random.rand(10, 3, 4)
Y = np.random.rand(10, 4, 5)
np.einsum("bij,bjk->bik", X, Y)    # batched matmul

# optimize=True lets einsum choose a better evaluation order
np.einsum("ij,jk,kl->il", A, B, A.T, optimize=True)

Evitando Cópias com out= e views

Pré-alocar buffers de saída com out= evita alocações repetidas em loops quentes — um grande ganho para operações repetidas. Operadores in-place (+=, *=) também evitam temporários. Reshape e transpose retornam views (sem cópia), mas indexação fancy e máscaras booleanas sempre copiam. ascontiguousarray copia só quando necessário, então é seguro chamá-lo preventivamente.

numpy
import numpy as np
import time

# Many ufuncs accept out= to write into an existing buffer (no allocation)
a = np.arange(1_000_000)
out = np.empty(1_000_000)

# Slow: creates a new array
start = time.perf_counter()
b = np.sin(a)
print("alloc:", time.perf_counter() - start)

# Fast: reuses the existing buffer
start = time.perf_counter()
np.sin(a, out=out)
print("reuse:", time.perf_counter() - start)   # faster, no allocation

# In-place operations also avoid copies
a += 10            # in-place add (no temp array)
a *= 2             # in-place multiply
np.sqrt(a, out=a)  # in-place sqrt

# Views vs copies
b = a.reshape(-1, 1000)        # view, no copy
c = a[a > 0.5]                  # copy (fancy indexing)
d = a.transpose()               # view (but maybe non-contiguous)

# ascontiguousarray: copy only if needed
e = np.ascontiguousarray(a)     # no copy if already C-contiguous

Layout de Memória e Eficiência de Cache

O layout de memória importa para desempenho: arrays em C-order guardam linhas de forma contígua, então operações ao longo do último eixo (ex.: sum(axis=1)) são amigáveis ao cache. Forçar o layout errado causa cache misses e pode retardar operações em 5-10x. Use np.ascontiguousarray quando uma operação precisa de dados contíguos em C e você não tem certeza do layout da entrada. .strides diz o passo em bytes por eixo.

numpy
import numpy as np
import time

# C order (row-major, default): last axis varies fastest
# F order (column-major): first axis varies fastest

# Iterating along the LAST axis is cache-friendly (C order)
a_c = np.zeros((1000, 1000), order="C")
a_f = np.zeros((1000, 1000), order="F")

# Sum along rows (axis 1): fast for C-order (contiguous in memory)
start = time.perf_counter()
a_c.sum(axis=1)
print("C order, axis=1:", time.perf_counter() - start)

start = time.perf_counter()
a_f.sum(axis=1)
print("F order, axis=1:", time.perf_counter() - start)   # slower

# Rule: for C-order arrays, the last axis is contiguous.
# Iterating a[..., i] is fast; iterating a[i, ...] is slow.

# Force a particular layout (copies only if necessary)
a_c2 = np.ascontiguousarray(a_f)   # now C-contiguous
a_f2 = np.asfortranarray(a_c)      # now F-contiguous

# Check layout
a_c.flags["C_CONTIGUOUS"]    # True
a_c.flags["F_CONTIGUOUS"]    # False

# Strides: bytes to step along each axis
a_c.strides    # (8000, 8)   - 8 bytes per float, 1000 per row
a_f.strides    # (8, 8000)   - first axis is contiguous

Profiling e Benchmarking

Para benchmarking, use timeit (ou %timeit no Jupyter) e pegue o mínimo de várias execuções para excluir ruído. Para códigos maiores, cProfile e line_profiler identificam o gargalo real — não chute. np.show_config revela se o NumPy usa MKL/OpenBLAS; para arrays pequenos, single-thread pode ser até mais rápido devido ao custo de lançar threads, então experimente com OMP_NUM_THREADS.

numpy
import numpy as np
import time

# Quick micro-benchmark
def bench(fn, *args, repeat=5):
    times = []
    for _ in range(repeat):
        start = time.perf_counter()
        fn(*args)
        times.append(time.perf_counter() - start)
    return min(times)

a = np.random.rand(1000, 1000)
print("sum axis=0:", bench(lambda x: x.sum(axis=0), a))
print("sum axis=1:", bench(lambda x: x.sum(axis=1), a))

# Memory profiling: check array size
print(f"size: {a.size} elements")
print(f"memory: {a.nbytes / 1e6:.1f} MB")

# Time individual lines with %timeit (in IPython/Jupyter)
# %timeit a.sum()
# %timeit np.einsum("ij->", a)
# %prun my_function()    # line-by-line profiling

# Find bottlenecks with cProfile
import cProfile
cProfile.run("a @ a", sort="cumtime")

# Check if BLAS is using multiple threads
np.show_config()    # shows BLAS/LAPACK info

# Control thread count (sometimes single-thread is faster for small arrays)
import os
os.environ["OMP_NUM_THREADS"] = "4"
os.environ["MKL_NUM_THREADS"] = "4"
15

FFT e Processamento de Sinais

Básico de FFT 1-D

np.fft.fft computa a Transformada Discreta de Fourier, convertendo um sinal do domínio do tempo para o da frequência. Para entrada real, o espectro é simétrico — só a primeira metade contém informação única. fftfreq retorna as frequências dos bins; para uma taxa de amostragem de 1/dt, a frequência de Nyquist é 1/(2*dt). A magnitude mostra a força de cada componente de frequência.

numpy
import numpy as np

# Generate a signal: two sine waves + noise
t = np.linspace(0, 1, 500, endpoint=False)
signal = np.sin(2 * np.pi * 5 * t) + 0.5 * np.sin(2 * np.pi * 20 * t)
signal += 0.2 * np.random.default_rng(42).standard_normal(500)

# Compute the FFT
fft_vals = np.fft.fft(signal)
# Complex array: magnitude = amplitude, phase = angle

# Frequencies corresponding to each FFT bin
freqs = np.fft.fftfreq(len(signal), d=t[1] - t[0])

# Magnitude spectrum (absolute value)
magnitude = np.abs(fft_vals)

# Power spectral density
power = magnitude ** 2

# Plot the spectrum (only positive frequencies for real signals)
import matplotlib.pyplot as plt
plt.plot(freqs[:len(freqs)//2], magnitude[:len(freqs)//2])
plt.xlabel("Frequency (Hz)")
plt.ylabel("Magnitude")

FFT Inversa e Reconstrução

ifft inverte fft — a ida e volta (fft e depois ifft) recupera o sinal original (até erro de ponto flutuante). Editar o espectro antes de inverter é a base da filtragem no domínio da frequência: zere os bins que quer remover (passa-baixa, passa-alta, passa-banda). Para sinais reais, rfft/irfft são mais eficientes, pois guardam só a metade não negativa do espectro.

numpy
import numpy as np

# Original signal
t = np.linspace(0, 1, 500, endpoint=False)
signal = np.sin(2 * np.pi * 5 * t) + 0.5 * np.sin(2 * np.pi * 20 * t)

# Forward FFT
fft_vals = np.fft.fft(signal)

# Inverse FFT reconstructs the original signal
reconstructed = np.fft.ifft(fft_vals)
np.allclose(signal, reconstructed.real)   # True

# Modify the spectrum (e.g. zero out high frequencies) then invert
fft_filtered = fft_vals.copy()
freqs = np.fft.fftfreq(len(signal), d=t[1] - t[0])
fft_filtered[np.abs(freqs) > 10] = 0   # low-pass filter

filtered_signal = np.fft.ifft(fft_filtered).real
# Now only the 5 Hz component remains; the 20 Hz is removed

# rfft / irfft: optimized for real input (half the storage)
rfft_vals = np.fft.rfft(signal)   # only non-negative frequencies
reconstructed2 = np.fft.irfft(rfft_vals, n=len(signal))

FFT 2-D (Processamento de Imagens)

fft2 / ifft2 são os equivalentes 2-D para processamento de imagens. fftshift move o componente de frequência zero para o centro do array (a convenção natural para visualização e filtragem). Uma máscara passa-baixa central no espectro deslocado desfoca a imagem; uma passa-alta (máscara invertida) realça as bordas. Convolução no domínio espacial equivale a multiplicação no domínio da frequência — um grande ganho para kernels grandes.

numpy
import numpy as np

# 2-D FFT for image processing
image = np.random.rand(64, 64)   # treat as a grayscale image

# Forward 2-D FFT
fft2d = np.fft.fft2(image)

# Shift zero frequency to the center (standard convention)
fft2d_shifted = np.fft.fftshift(fft2d)

# Magnitude spectrum (log-scaled for visualization)
magnitude = np.log(np.abs(fft2d_shifted) + 1)

# Inverse: unshift then ifft2
fft2d_unshifted = np.fft.ifftshift(fft2d_shifted)
reconstructed = np.fft.ifft2(fft2d_unshifted).real
np.allclose(image, reconstructed)   # True

# Low-pass filter: keep only central low frequencies
rows, cols = image.shape
crow, ccol = rows // 2, cols // 2
mask = np.zeros((rows, cols), dtype=bool)
mask[crow-10:crow+10, ccol-10:ccol+10] = True   # central 20x20 block
fft2d_shifted[~mask] = 0
blurred = np.fft.ifft2(np.fft.ifftshift(fft2d_shifted)).real

Funções de Janela e Vazamento Espectral

Tomar a FFT de um pedaço finito de sinal causa vazamento espectral — energia 'vaza' da frequência verdadeira para bins adjacentes. Funções de janela (Hann, Hamming, Blackman) atenuam o sinal suavemente até zero nas bordas, reduzindo o vazamento ao custo de picos de frequência um pouco mais largos. Para STFT (espectrogramas), a janela Hann com 50% de sobreposição satisfaz a propriedade COLA para reconstrução perfeita.

numpy
import numpy as np

# Applying a window reduces spectral leakage at the edges of the FFT
N = 1024
t = np.linspace(0, 1, N, endpoint=False)
signal = np.sin(2 * np.pi * 50 * t)

# Rectangular window (no window) - lots of leakage
rect_fft = np.abs(np.fft.fft(signal))

# Hann window - smooth taper to zero at both ends
hann = np.hanning(N)
signal_hann = signal * hann
hann_fft = np.abs(np.fft.fft(signal_hann))

# Other common windows
hamming = np.hamming(N)
blackman = np.blackman(N)
bartlett = np.bartlett(N)

# Compare spectral leakage: Hann has wider main lobe but lower sidelobes
# Trade-off: frequency resolution vs leakage

# For overlap-add processing, use windows that sum to 1 when overlapped:
# Hann at 50% overlap -> COLA (constant overlap-add) property

# Short-time Fourier transform (STFT) via windowed FFTs
def stft(signal, window_size=256, hop=128):
    n_frames = (len(signal) - window_size) // hop + 1
    window = np.hanning(window_size)
    frames = []
    for i in range(n_frames):
        start = i * hop
        frame = signal[start:start + window_size] * window
        frames.append(np.fft.rfft(frame))
    return np.array(frames).T   # shape (n_freqs, n_frames)

Convolução via FFT

Convolução baseada em FFT multiplica os espectros em vez de deslizar o kernel — muito mais rápida para sinais/kernels grandes (O(N log N) vs O(N*K)). O comprimento da convolução deve ser preenchido para pelo menos N+K-1 para evitar artefatos de convolução circular; arredondar para uma potência de 2 deixa a FFT mais rápida. scipy.signal.fftconvolve é a versão pronta para produção — use-a em vez de fazer a sua.

numpy
import numpy as np

# Convolution theorem: convolution in time = multiplication in frequency
# For large signals, FFT-based convolution is O(N log N) vs O(N^2) direct

signal = np.random.rand(10000)
kernel = np.random.rand(100)

# Method 1: np.convolve (direct, O(N*K))
direct_conv = np.convolve(signal, kernel, mode="same")

# Method 2: FFT-based convolution (fast for large kernels)
def fft_convolve(signal, kernel):
    n = len(signal) + len(kernel) - 1   # full convolution length
    n_fft = 1 << int(np.ceil(np.log2(n)))   # next power of 2 (faster FFT)
    fft_signal = np.fft.rfft(signal, n_fft)
    fft_kernel = np.fft.rfft(kernel, n_fft)
    fft_conv = fft_signal * fft_kernel
    conv = np.fft.irfft(fft_conv, n_fft)[:n]
    return conv

fft_result = fft_convolve(signal, kernel)
# Trim or pad to match 'same' mode if needed

# scipy.signal.fftconvolve is a production-ready version
from scipy.signal import fftconvolve
scipy_conv = fftconvolve(signal, kernel, mode="same")

# Cross-correlation (flip the kernel first)
xcorr = fftconvolve(signal, kernel[::-1], mode="same")

# Autocorrelation
autocorr = fftconvolve(signal, signal[::-1], mode="same")
16

Arrays Mascarados

Criando Arrays Mascarados

Arrays mascarados representam dados com entradas inválidas/ausentes sem poluir os dados em si (diferente de NaN, que força dtype float). A máscara é um array booleano paralelo — True significa 'inválido, ignore esta entrada'. masked_equal/masked_where são construtores comuns. .filled() converte de volta para um ndarray comum, substituindo as entradas mascaradas por um valor de preenchimento.

numpy
import numpy as np
import numpy.ma as ma

# A masked array = data + a boolean mask (True = invalid/missing)
data = np.array([1, 2, -999, 4, 5])
mask = np.array([False, False, True, False, False])
m = ma.masked_array(data, mask=mask)
# masked_array(data=[1, 2, --, 4, 5],
#              mask=[False, False,  True, False, False])

# Common constructors
ma.masked_equal(data, -999)        # mask all elements == -999
ma.masked_greater(data, 3)         # mask elements > 3
ma.masked_where(data > 3, data)    # general: mask where condition
ma.masked_invalid([1.0, np.nan, 3.0])   # mask NaN/inf

# Access components
m.data       # the underlying data (including masked values)
m.mask       # the boolean mask
m.filled(0)  # replace masked values with 0, return regular ndarray

# Check if any value is masked
m.mask.any()    # True

Operações em Arrays Mascarados

Operações em arrays mascarados propagam automaticamente a máscara — entradas mascaradas continuam mascaradas no resultado, e reduções as ignoram. Esta é a vantagem principal sobre usar valores sentinela como -999: você não precisa filtrar entradas inválidas manualmente em cada cálculo. .compressed() retorna um ndarray plano só com os valores válidos, quando você precisa de um array simples.

numpy
import numpy as np
import numpy.ma as ma

m = ma.masked_array([1, 2, 3, 4, 5],
                    mask=[False, False, True, False, False])

# Reductions ignore masked values
m.sum()      # 12   (skips the masked 3)
m.mean()     # 3.0  (mean of unmasked only)
m.max()      # 5
m.min()      # 1

# Arithmetic propagates the mask
m + 10       # [11 12 -- 14 15]
m * 2        # [2 4 -- 8 10]

# Combine masks from two masked arrays
m2 = ma.masked_array([10, 20, 30, 40, 50],
                     mask=[True, False, False, False, True])
m + m2       # [-- 22 -- 44 --]   union of masks

# Logical operations
m < 4        # masked_array, masked entries stay masked

# Compress: extract only the unmasked values (returns 1-D array)
m.compressed()   # [1 2 4 5]   (regular ndarray, no mask)

# Count valid entries
ma.count(m)      # 4
m.count()        # 4

Preenchimento e Conversão

filled() é a forma padrão de converter um array mascarado de volta para um ndarray comum — escolha o valor de preenchimento para o seu código seguinte (NaN para floats que serão plotados, 0 para arrays de inteiros, ou a média para imputação). Cuidado: np.asarray(array_mascarado) retorna os dados subjacentes INCLUINDO os valores mascarados — sempre chame .filled() primeiro para tornar a conversão explícita.

numpy
import numpy as np
import numpy.ma as ma

m = ma.masked_array([1.0, 2.0, 3.0, 4.0],
                    mask=[False, True, False, True])

# filled(): replace masked entries with a fill value
m.filled(0)         # [1. 0. 3. 0.]   - regular ndarray
m.filled(np.nan)    # [ 1. nan  3. nan]
m.filled(m.mean())  # fill with mean of unmasked

# The default fill value depends on dtype
m.fill_value    # 1e+20 for floats, 999999 for ints, etc.

# Set a custom fill value
m2 = ma.masked_array([1, 2, 3], mask=[0, 1, 0], fill_value=-1)

# Convert to a plain ndarray (loses mask info!)
arr = np.asarray(m)         # includes masked values! [1. 2. 3. 4.]
arr_filled = np.asarray(m.filled(np.nan))   # NaN where masked

# Convert a regular array with sentinel values to masked
data = np.array([1, -999, 3, -999, 5])
m3 = ma.masked_equal(data, -999)

# Convert masked back to array with NaN (for plotting)
arr_nan = ma.filled(m, np.nan)

Indexação de Arrays Mascarados

Indexar um array mascarado funciona como num ndarray comum, e a máscara é preservada no resultado. Atribua ma.masked a uma posição para mascará-la; atribua um valor normal para desmascarar. Definir .mask = ma.nomask limpa todas as máscaras. O atributo .data dá os valores crus subjacentes (incluindo os mascarados) — útil quando você precisa inspecionar o que está escondido.

numpy
import numpy as np
import numpy.ma as ma

m = ma.masked_array(np.arange(12).reshape(3, 4),
                    mask=[[0, 0, 1, 0],
                          [0, 1, 0, 0],
                          [1, 0, 0, 0]])

# Indexing works like regular arrays
m[0]            # first row (mask preserved)
m[1, 2]         # scalar value (or masked if masked)
m[:, 1]         # column 1

# Boolean mask on top of masked array
m[m.data > 5]   # values > 5 (mask still applied)

# Set values (and unmask)
m[0, 0] = 99
m[0, 0] = ma.masked   # re-mask a specific element

# Reset the mask entirely
m.mask = ma.nomask     # no values masked
m[1, 1] = ma.masked    # mask a single value

# Check element-wise
m[0, 2] is ma.masked   # True if that element is masked

# Logical operations keep the mask
(m > 5).data    # boolean array
(m > 5).mask    # propagated mask

# Iteration skips masked values (kind of)
list(m.compressed())   # all unmasked values, flattened

Quando Usar Arrays Mascarados

Arrays mascarados brilham quando (1) você tem valores sentinela como -999 que não pode converter para NaN porque o dtype é inteiro, (2) a máscara tem significado de domínio como 'terra vs oceano' ou 'medição de baixa qualidade', ou (3) você precisa acompanhar a validade separadamente dos valores. Para dados ausentes puramente baseados em NaN, arrays comuns com funções nan* são mais simples e rápidos.

numpy
import numpy as np
import numpy.ma as ma

# Scenario 1: Sentinel values in data (e.g. -999 for missing)
temps = np.array([23.5, -999, 24.0, -999, 22.5])
m = ma.masked_equal(temps, -999)
m.mean()   # 23.33...  (ignores -999 entries)

# Scenario 2: Quality flags / validity
values = np.array([10, 12, 8, 15, 11])
quality = np.array([1, 1, 0, 1, 0])   # 0 = bad
m = ma.masked_array(values, mask=(quality == 0))
m.mean()   # (10 + 12 + 15) / 3 = 12.33

# Scenario 3: Grid data with land/sea mask
sst = np.random.rand(5, 5) * 30   # sea surface temperature
land_mask = np.array([
    [1, 1, 0, 0, 0],
    [1, 0, 0, 0, 1],
    [0, 0, 1, 0, 0],
    [0, 1, 0, 0, 1],
    [1, 0, 0, 1, 1],
], dtype=bool)
sst_masked = ma.masked_array(sst, mask=land_mask)
sst_masked.mean()   # average over ocean only

# When NOT to use: if you just have NaN, regular arrays work fine
# (and np.nanmean etc. handle them). Use masked arrays when:
# - You need integer dtype (NaN forces float)
# - You have a non-NaN sentinel (-999, 0, etc.)
# - The mask has semantic meaning (quality flag, region)
17

Arrays Estruturados

Definindo Dtypes Estruturados

Dtypes estruturados permitem armazenar dados heterogêneos, tipo registro, num único array NumPy — como uma tabela de banco de dados. Os códigos de tipo seguem a forma <tipo><bytes>: i4 = int de 4 bytes, f8 = float de 8 bytes, U20 = Unicode de 20 caracteres, ? = bool. Cada elemento é um registro que você pode indexar pelo nome do campo. Use isto para interop de baixo nível com structs C ou quando o pandas não está disponível.

numpy
import numpy as np

# Define a structured dtype: list of (name, format) tuples
dt = np.dtype([("name", "U20"),
               ("age", "i4"),
               ("weight", "f8"),
               ("active", "?")])    # ? = bool

# Create an array with this dtype
people = np.array([("Alice", 30, 65.5, True),
                   ("Bob", 25, 80.0, False),
                   ("Carol", 35, 55.0, True)], dtype=dt)

print(people)
# [('Alice', 30, 65.5,  True) ('Bob', 25, 80. , False) ...]

# Each element is a record (tuple-like)
people[0]              # ('Alice', 30, 65.5, True)
people[0]["name"]      # 'Alice'

# Type codes: i1/i2/i4/i8 (ints), u1..u8 (unsigned),
#             f2/f4/f8 (floats), U/n (strings), ? (bool), M8 (datetime)

Acessando Campos

Acessar um campo pelo nome (data['age']) retorna uma VIEW sobre aquela coluna em cada um dos registros — sem cópia. Acesso a múltiplos campos (data[['name', 'age']]) retorna uma cópia em NumPy antigo e uma view em NumPy >= 1.16. Atribuição de campo funciona com escalares (transmite) ou arrays de comprimento correspondente. data.dtype.names dá a lista de nomes de campos para iteração.

numpy
import numpy as np
dt = np.dtype([("name", "U20"), ("age", "i4"), ("score", "f4")])
data = np.array([("Alice", 30, 9.5),
                 ("Bob", 25, 8.0),
                 ("Carol", 35, 9.8)], dtype=dt)

# Access a single field across all records (returns a view)
data["name"]    # ['Alice' 'Bob' 'Carol']
data["age"]     # [30 25 35]
data["age"].mean()   # 30.0

# Modify a field
data["age"] += 1    # increment everyone's age
data["score"] = 0   # set all scores to 0

# Access multiple fields at once
data[["name", "score"]]   # new structured array with just those fields

# Field assignment with another array
data["score"] = [9.5, 8.0, 9.8]

# Iterate records (each record is a tuple)
for rec in data:
    print(rec["name"], rec["age"])

# Iterate fields
for name in data.dtype.names:
    print(name, data[name]

Ordenando e Filtrando Arrays Estruturados

Arrays estruturados ordenam por campo com o argumento order= — passe uma string para um campo ou uma lista de strings para ordenação lexicográfica multi-chave. Filtragem funciona como nos arrays comuns: construa uma máscara booleana de uma comparação de campo e faça indexação fancy. A maioria das reduções funciona por campo. Para group-by / agregação mais sofisticados, o pandas é muito mais fácil — mas arrays estruturados podem ser uma alternativa leve para casos simples.

numpy
import numpy as np
dt = np.dtype([("name", "U20"), ("age", "i4"), ("score", "f4")])
data = np.array([("Alice", 30, 9.5),
                 ("Bob", 25, 8.0),
                 ("Carol", 35, 9.8),
                 ("Dave", 28, 7.5)], dtype=dt)

# Sort by a single field
np.sort(data, order="age")         # ascending by age
np.sort(data, order="score")[::-1] # descending by score

# Sort by multiple fields (lexicographic)
np.sort(data, order=["score", "age"])  # primary: score, secondary: age

# argsort with order
idx = np.argsort(data, order="score")
data[idx]   # records sorted by score

# Filter by a field
mask = data["age"] > 28
data[mask]   # Alice, Carol

# Complex conditions
mask = (data["score"] > 8) & (data["age"] < 35)
data[mask]   # Alice

# Find unique values of a field
np.unique(data["age"])   # [25 28 30 35]

# Aggregate per field
data["age"].mean()
data["score"].std()

Record Arrays (recarray)

Record arrays (recarray) fornecem acesso a campos estilo atributo (data.age em vez de data['age']) a um pequeno custo de desempenho. A conveniência é em grande parte cosmética — por baixo são iguais aos arrays estruturados. Para a maioria do código de produção, arrays estruturados simples são preferidos (mais rápidos, mais explícitos); recarray é prático para exploração interativa, em que digitar aspas irrita.

numpy
import numpy as np

# Record arrays: access fields as ATTRIBUTES (data.age vs data["age"])
dt = np.dtype([("name", "U20"), ("age", "i4"), ("score", "f4")])

# Method 1: view as recarray
data = np.array([("Alice", 30, 9.5),
                 ("Bob", 25, 8.0)], dtype=dt).view(np.recarray)

data.name    # ['Alice' 'Bob']   - attribute access!
data.age     # [30 25]
data.age.mean()

# Method 2: create directly with np.rec.array
recs = np.rec.array([("Alice", 30, 9.5),
                     ("Bob", 25, 8.0)],
                    dtype=[("name", "U20"), ("age", "i4"), ("score", "f4")])
recs.name    # attribute access
recs[0].name # 'Alice'

# Trade-off: recarray is slightly slower and uses a bit more memory
# than a plain structured array, but the syntax is cleaner.

# In practice, prefer plain structured arrays for performance,
# recarray only when you really want attribute access (e.g. in REPL).

Array Estruturado vs Pandas

Para quase toda análise de dados tabulares, o pandas é a escolha melhor — é construído sobre NumPy, mas adiciona groupby, joins, séries temporais, tratamento de dados ausentes e I/O rico. Arrays estruturados valem a pena conhecer para (1) situações de memória apertada (são 2-10x menores que um DataFrame), (2) interop com código C/Fortran que espera layouts de struct, e (3) ambientes em que o pandas não está disponível. Converta livremente com pd.DataFrame(arr) e df.to_records().

numpy
import numpy as np
import pandas as pd

# Same data as a structured array vs a pandas DataFrame
dt = np.dtype([("name", "U20"), ("age", "i4"), ("score", "f4")])
sa = np.array([("Alice", 30, 9.5),
               ("Bob", 25, 8.0),
               ("Carol", 35, 9.8)], dtype=dt)

df = pd.DataFrame(sa)   # easy conversion
#    name  age  score
# 0  Alice   30    9.5
# 1    Bob   25    8.0
# 2  Carol   35    9.8

# Conversion back
sa2 = df.to_records(index=False)

# When to use structured arrays (NumPy):
# - Memory is tight (no pandas overhead, ~2-10x smaller)
# - Interoperating with C/Fortran code that expects structs
# - Simple, fixed-schema numeric data
# - Embedded / scientific computing without pandas available

# When to use pandas:
# - Heterogeneous data with mixed types
# - Need groupby, join, resample, time series
# - Handling missing data (NaN handling is richer)
# - Reading/writing CSV, Excel, SQL, Parquet
# - Most data analysis workflows

# Pandas is built on top of NumPy - usually the better default.
# Structured arrays are a low-level escape hatch.
18

einsum Avançado e Truques de Stride

Guia Rápido de Padrões einsum

einsum cobre um leque enorme de operações com uma sintaxe consistente: multiplicação de matrizes, transpose, trace, diagonal, sum, produto externo, operações em lote e contrações arbitrárias de tensores. A regra: cada entrada recebe uma string de labels de eixos; a saída mantém os labels que você quer reter; qualquer label que aparece nas entradas mas não na saída é somado. Domine isto e você expressará a maioria da álgebra linear numa linha.

numpy
import numpy as np
A = np.random.rand(3, 4)
B = np.random.rand(4, 5)
v = np.random.rand(4)

# Matrix multiply
np.einsum("ij,jk->ik", A, B)   # = A @ B

# Matrix-vector multiply
np.einsum("ij,j->i", A, v)     # = A @ v

# Vector inner product (dot)
np.einsum("i,i->", v, v)       # = v @ v = sum(v**2)

# Outer product
np.einsum("i,j->ij", v, v)     # = np.outer(v, v)

# Trace
np.einsum("ii->", A) if A.shape[0] == A.shape[1] else None

# Diagonal
M = np.random.rand(5, 5)
np.einsum("ii->i", M)          # = np.diag(M)

# Transpose
np.einsum("ij->ji", A)         # = A.T

# Sum all elements
np.einsum("ij->", A)           # = A.sum()

# Sum along axis 0
np.einsum("ij->j", A)          # = A.sum(axis=0)

# Element-wise (Hadamard) product
np.einsum("ij,ij->ij", A, A)   # = A * A

# Batched matrix multiply
X = np.random.rand(10, 3, 4)
Y = np.random.rand(10, 4, 5)
np.einsum("bij,bjk->bik", X, Y)   # batched A @ B

Strides e as_strided

as_strided cria uma view com strides arbitrários — usada para implementar janelas deslizantes, estatísticas móveis e outros arrays 'virtuais' sem copiar dados. Isso é perigoso: strides incorretos podem ler memória fora dos limites (corrupção silenciosa ou travamentos). Prefira o seguro sliding_window_view (NumPy >= 1.20), que calcula os strides corretamente. Use as_strided só quando sliding_window_view não atender seu caso.

numpy
import numpy as np

# np.lib.stride_tricks.as_strided: create views with custom strides
# Extremely powerful but DANGEROUS - can read out-of-bounds memory

a = np.arange(10)
print(a.strides)   # (8,)   - 8 bytes per int64

# Create a sliding-window view WITHOUT copying data
from numpy.lib.stride_tricks import sliding_window_view, as_strided

# Modern, safe way (NumPy >= 1.20):
windows = sliding_window_view(a, 3)
# shape (8, 3): [[0,1,2], [1,2,3], ..., [7,8,9]]
# This is a VIEW - shares memory with a

# Compute moving average using sliding windows
data = np.random.rand(1000)
window = 5
ma = sliding_window_view(data, window).mean(axis=1)
# shape (996,) - moving average

# The low-level (DANGEROUS) as_strided
# shape = (8, 3), strides = (8, 8)  -> step 1 element along both axes
windows2 = as_strided(a, shape=(8, 3), strides=(8, 8))
# Same as sliding_window_view(a, 3) but you must compute shape/strides
# yourself - get it wrong and you read garbage or crash.

# ALWAYS prefer sliding_window_view - it computes strides safely.

Janelas Deslizantes e Operações Móveis

sliding_window_view cria um array virtual de janelas SEM copiar dados — extremamente eficiente em memória para cálculos móveis. Use .mean(axis=1) / .max(axis=1) para estatísticas móveis. Para imagens 2-D, a forma de janela (3, 3) produz patches de forma (..., 3, 3) no fim; reduza sobre os dois últimos eixos para efeitos de desfoque/convolução. Para janelas com passos, fatie o resultado [::stride].

numpy
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view

# 1-D rolling window
data = np.arange(10)
windows = sliding_window_view(data, 4)
# shape (7, 4): [[0,1,2,3], [1,2,3,4], ..., [6,7,8,9]]

# Rolling mean (window=4)
rolling_mean = windows.mean(axis=1)
# [1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5]

# Rolling max / min / sum
rolling_max = windows.max(axis=1)
rolling_min = windows.min(axis=1)
rolling_sum = windows.sum(axis=1)

# 2-D sliding window (e.g. for image processing)
img = np.random.rand(10, 10)
patches = sliding_window_view(img, (3, 3))
# shape (8, 8, 3, 3): each (i,j) is a 3x3 patch centered around (i+1, j+1)

# Compute patch-wise mean (blur effect)
blurred = patches.mean(axis=(-2, -1))
# shape (8, 8)

# Convolution-like operation (no padding, stride 1)
kernel = np.array([[1, 0, -1], [1, 0, -1], [1, 0, -1]])
convolved = (patches * kernel).sum(axis=(-2, -1))

# Window with step (downsample): slice the windows
windowed_stride2 = sliding_window_view(data, 4)[::2]
# shape (4, 4)

broadcast_arrays e Truques de Tile

broadcast_to e broadcast_arrays criam views transmitidas virtuais com zero cópia de dados — úteis para código eficiente em memória. ogrid produz vetores abertos (1-D) que transmitem para grades completas quando combinados, economizando memória vs meshgrid, que cria grades densas completas. Use ogrid para cálculos em grades grandes em que meshgrid explodiria a memória, e mgrid para o equivalente denso (prático para indexação).

numpy
import numpy as np
from numpy.lib.stride_tricks import broadcast_arrays, broadcast_to

# broadcast_to: view of an array broadcast to a new shape (read-only)
a = np.array([1, 2, 3])
b = np.broadcast_to(a, (4, 3))
# shape (4, 3), all rows = [1, 2, 3], no data copied
# b[0, 0] = 99   # ERROR - read-only

# broadcast_arrays: broadcast several arrays together (as views)
x = np.array([1, 2, 3])           # (3,)
y = np.array([[10], [20]])        # (2, 1)
bx, by = broadcast_arrays(x, y)
bx.shape   # (2, 3)
by.shape   # (2, 3)
# bx, by share memory with x, y (just with new strides)

# Use case: build coordinate grids without copying
xs = np.array([0, 1, 2])
ys = np.array([0, 1, 2, 3])
X, Y = np.meshgrid(xs, ys)        # creates copies
X2, Y2 = broadcast_arrays(xs, ys) # views - no copies!
# X2, Y2 are read-only views

# ogrid / mgrid: open / dense meshgrids
ox, oy = np.ogrid[0:3, 0:4]       # column + row vectors (views)
ox.shape   # (3, 1)
oy.shape   # (1, 4)
# Use for broadcasting computations: X = ox + oy  (shape (3, 4))

mx, my = np.mgrid[0:3, 0:4]       # dense (copies), shape (3, 4) each

Strides Personalizados para Views Eficientes

as_strided com stride 0 num eixo 'ladrilha' o array virtualmente ao longo desse eixo, sem copiar dados. O exemplo de distâncias par a par mostra o padrão: insira um eixo de tamanho 1 com as_strided para que o broadcasting produza a matriz completa de diferenças sem pré-copiar as entradas. Isso é avançado e arriscado — sempre verifique shapes/strides com cuidado, e prefira as_strided só quando a memória estiver realmente apertada.

numpy
import numpy as np
from numpy.lib.stride_tricks import as_strided

# Use case: compute pairwise distances without forming the full matrix
# (still O(N^2) compute, but at least no extra copy of the data)
points = np.random.rand(1000, 3)   # 1000 points in 3-D

# Method 1: explicit broadcasting (creates intermediates)
# diff = points[:, None, :] - points[None, :, :]   # (1000, 1000, 3) = 24MB
# dists = np.linalg.norm(diff, axis=-1)            # (1000, 1000)

# Method 2: use as_strided to view points as (1000, 1, 3) and (1, 1000, 3)
# without copying - same compute, less peak memory
n, d = points.shape
p1 = as_strided(points, shape=(n, 1, d),
                strides=(points.strides[0], 0, points.strides[1]))
p2 = as_strided(points, shape=(1, n, d),
                strides=(0, points.strides[0], points.strides[1]))
# p1 and p2 share memory with points (zero-copy broadcast views)
# diff = p1 - p2  still allocates (n, n, d), but the inputs didn't

# Compute a Gram matrix (X @ X.T) with as_strided
X = np.random.rand(100, 5)
gram = np.einsum("ij,ik->jk", X, X)   # = X.T @ X, shape (5, 5)

# Tile an array virtually (without copying)
a = np.array([1, 2, 3])
tiled_view = as_strided(a, shape=(4, 3),
                        strides=(0, a.strides[0]))
# Each row is [1, 2, 3], no data copied

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.