NumPy Cheat Sheet: Folha de Consulta
Última atualização
Criar arrays
Um array guarda valores de um só tipo em uma grade com qualquer número de dimensões.
| Tarefa | Código |
|---|---|
| Importar NumPy | import numpy as np |
| A partir de uma lista | np.array([1, 2, 3]) |
| 2D a partir de listas aninhadas | np.array([[1, 2, 3], [4, 5, 6]]) |
| Zeros, uns, um valor fixo | np.zeros((2, 3)), np.ones(4), np.full((2, 2), 7) |
| Intervalo com passo (fim excluído) | np.arange(0, 10, 2) # [0 2 4 6 8] |
| n pontos igualmente espaçados (fim incluído) | np.linspace(0, 1, 5) # [0. 0.25 0.5 0.75 1.] |
| Matriz identidade | np.eye(3) |
| Mesmo shape de outro array | np.zeros_like(m), np.ones_like(m) |
| Escolher o tipo dos elementos | np.array([1, 2, 3], dtype=np.float32) |
| Grades de coordenadas | xx, yy = np.meshgrid(np.arange(3), np.arange(2)) |
Inspecionar um array
| Tarefa | Código |
|---|---|
| Shape: tamanho de cada dimensão | m.shape # (3, 4) |
| Número de dimensões | m.ndim # 2 |
| Número de elementos | m.size # 12 |
| Tipo dos elementos | m.dtype # int64 |
| Converter o tipo | m.astype(np.float64) |
| Tamanho da primeira dimensão | len(m) # 3 |
| Voltar para lista Python | m.tolist() |
| Imprimir menos casas decimais | np.set_printoptions(precision=3, suppress=True) |
Indexar e fatiar
Fatias são views: compartilham memória com o array original. Máscaras e listas de índices devolvem cópias.
| Tarefa | Código |
|---|---|
| Primeiro e último elemento | a[0], a[-1] |
| Fatia start:stop (stop excluído) | a[1:4] # [20 30 40] |
| Um elemento sim, outro não, invertido | a[::2], a[::-1] |
| Um elemento de um array 2D | m[1, 2] # 6 |
| Uma linha, uma coluna | m[0], m[:, 1] |
| Um bloco de linhas e colunas | m[:2, 1:3] |
| Elementos que atendem a uma condição | a[a > 25] # [30 40 50] |
| Combinar condições | a[(a > 15) & (a < 45)] |
| Escolher por lista de posições | a[[0, 2, 4]] |
| Posições que atendem à condição | np.flatnonzero(a > 25) # [2 3 4] |
| Escolher por elemento | np.where(a > 25, a, 0) |
| Copiar antes de alterar uma fatia | part = a[1:3].copy() |
| Atribuir valores com máscara | a[a > 40] = 0 |
Contas e broadcasting
Os operadores agem elemento a elemento. O broadcasting estica um escalar, uma linha ou uma coluna até o shape do outro array.
| Tarefa | Código |
|---|---|
| Aritmética elemento a elemento | x + y, x - y, x * y, x / y, x ** 2 |
| Com um escalar | x * 10 |
| Raiz quadrada, exponencial, log | np.sqrt(x), np.exp(x), np.log(x) |
| Valor absoluto, arredondamento | np.abs(x - 5), np.round(x / 3, 2) |
| Limitar valores a um intervalo | np.clip(x, 2, 8) |
| Máximo elemento a elemento | np.maximum(x, 3) |
| Produto escalar | x @ y # 37.0 |
| Centralizar cada coluna (broadcast de linha) | m - m.mean(axis=0) |
| Escalar cada linha (broadcast de coluna) | m / m.sum(axis=1, keepdims=True) |
| Comparar floats com segurança | np.isclose(0.1 + 0.2, 0.3) # True, np.allclose(x, y) |
| Trigonometria e pi | np.sin(np.pi / 2) # 1.0 |
Agregar ao longo de um eixo
axis=0 percorre as linhas para baixo e dá um resultado por coluna. axis=1 percorre as colunas e dá um resultado por linha.
| Tarefa | Código |
|---|---|
| Soma de todos os elementos | m.sum() # 21 |
| Um resultado por coluna | m.sum(axis=0) # [5 7 9] |
| Um resultado por linha | m.sum(axis=1) # [ 6 15] |
| Média e desvio padrão | m.mean(), m.std(), m.mean(axis=0) |
| Mínimo, máximo | m.min(), m.max(axis=1) |
| Posição do máximo | m.argmax(), m.argmax(axis=1) |
| Mediana e percentis | np.median(m), np.percentile(m, [25, 50, 75]) |
| Soma acumulada | np.cumsum(m, axis=1) |
| Produto de todos os elementos | m.prod() # 720 |
| Algum, todos, contagem | (m > 4).any(), (m > 0).all(), np.count_nonzero(m > 2) |
Remodelar e combinar
Um reshape mantém os elementos e muda o shape, então o tamanho total precisa continuar o mesmo.
| Tarefa | Código |
|---|---|
| Novo shape | a.reshape(2, 3) |
| Deixar o NumPy calcular um tamanho | a.reshape(3, -1), a.reshape(-1, 1) |
| Achatar para 1D | m.ravel(), m.flatten() |
| Transpor | m.T |
| Adicionar uma dimensão | a[:, np.newaxis], np.expand_dims(a, axis=0) |
| Remover dimensões de tamanho 1 | np.squeeze(np.ones((1, 3, 1))) |
| Juntar ao longo de um eixo existente | np.concatenate([a, a]) |
| Empilhar linhas ou colunas | np.vstack([m, m]), np.hstack([m, m]) |
| Arrays 1D como colunas | np.column_stack([a, a ** 2]) |
| Empilhar em um novo eixo | np.stack([a, a], axis=0) # shape (2, 6) |
| Dividir em pedaços | np.split(a, 3), np.array_split(a, 4) |
| Repetir ou ladrilhar | np.repeat([1, 2], 2) # [1 1 2 2], np.tile([1, 2], 2) # [1 2 1 2] |
Ordenar, buscar e valores únicos
| Tarefa | Código |
|---|---|
| Cópia ordenada | np.sort(a) |
| Maiores primeiro | np.sort(a)[::-1] |
| Posições que ordenariam | np.argsort(a) |
| Os três maiores valores | np.sort(a)[-3:] |
| Valores únicos e suas contagens | values, counts = np.unique(a, return_counts=True) |
Nomes do NumPy 2 (unique_values pode vir fora de ordem) | np.unique_values(a), np.unique_counts(a) |
| Cada elemento está numa lista? | np.isin(a, [1, 9]) |
| Posição de inserção num array ordenado | np.searchsorted([1, 3, 5, 7], 4) # 2 |
| Operações de conjunto | np.intersect1d(a, [1, 2, 10]), np.union1d(a, [10]), np.setdiff1d(a, [1]) |
| Ordenar linhas por uma coluna | m[m[:, 1].argsort()] |
Números aleatórios
Crie um único Generator com seed e tire tudo dele, para que os resultados se repitam a cada execução.
| Tarefa | Código |
|---|---|
| Gerador com seed | rng = np.random.default_rng(42) |
| Floats em [0, 1) | rng.random(3) |
| Inteiros, limite superior excluído | rng.integers(1, 7, size=10) |
| Distribuição normal | rng.normal(loc=0, scale=1, size=(2, 3)) |
| Floats uniformes num intervalo | rng.uniform(5, 10, size=4) |
| Sortear de uma lista | rng.choice(["a", "b", "c"], size=5) |
| Sortear sem repetição | rng.choice(10, size=3, replace=False) |
| Sortear com pesos | rng.choice(["H", "T"], size=10, p=[0.7, 0.3]) |
| Cópia embaralhada, embaralhar no lugar | rng.permutation(a), rng.shuffle(a) |
| Contagens binomial e Poisson | rng.binomial(10, 0.5, size=5), rng.poisson(3, size=5) |
Álgebra linear
| Tarefa | Código |
|---|---|
| Produto de matrizes | A @ A |
| Resolver Ax = b | np.linalg.solve(A, b) # [0.8 1.4] |
| Inversa e determinante | np.linalg.inv(A), np.linalg.det(A) |
| Norma de um vetor | np.linalg.norm(b) |
| Autovalores e autovetores | values, vectors = np.linalg.eig(A) |
| Ajustar uma reta | slope, intercept = np.polyfit(x, y, 1) |
| Produto externo | np.outer([1, 2], [3, 4]) |
| Diagonal e traço | np.diag(A), np.trace(A) |
Valores ausentes e especiais
np.nan marca um float ausente. Qualquer conta com ele dá nan, então use as funções nan ou uma máscara.
| Tarefa | Código |
|---|---|
| Valor ausente | np.nan |
| Encontrar valores ausentes | np.isnan(v), np.isnan(v).sum() |
| Remover valores ausentes | v[~np.isnan(v)] |
| Substituir ausentes e infinitos | np.nan_to_num(v, nan=0.0, posinf=0.0) |
| Testar infinito e finito | np.inf, np.isfinite(v) |
| Estatísticas que ignoram NaN | np.nanmean(v[:3]) # 2.0, np.nanmax(v) |
Salvar e carregar
| Tarefa | Código |
|---|---|
| Um array, arquivo binário | np.save("data.npy", m), m = np.load("data.npy") |
| Vários arrays num arquivo | np.savez("data.npz", x=x, y=y), np.load("data.npz")["x"] |
| Gravar texto CSV | np.savetxt("data.csv", m, delimiter=",", fmt="%d") |
| Ler texto CSV | np.loadtxt("data.csv", delimiter=",") |
NumPy 2: nomes antigos e o que escrever agora
O NumPy 2 removeu muitos aliases, então código copiado de tutoriais antigos pode falhar com um AttributeError.
| Tarefa | NumPy 2 | Forma antiga |
|---|---|---|
| Valor ausente | np.nan | np.NaN |
| Infinito | np.inf | np.Inf |
| Tipo float de 64 bits | np.float64 | np.float_ |
| Área sob uma curva | np.trapezoid(y, x) | np.trapz(y, x) |
| Cada elemento está em outro array? | np.isin(a, b) | np.in1d(a, b) |
| Empilhar linhas | np.vstack([a, a]) | np.row_stack([a, a]) |
| Produto | np.prod(a) | np.product(a) |
| Números aleatórios | rng = np.random.default_rng(0)
rng.random(3) | np.random.seed(0)
np.random.rand(3) |
As chamadas NumPy que sustentam o código de ciência de dados, organizadas por tarefa: criar arrays, inspecionar, indexar e fatiar, fazer contas elemento a elemento, agregar ao longo de um eixo, remodelar e combinar, ordenar e buscar, gerar números aleatórios e resolver álgebra linear. Cada linha traz um trecho curto para colar e uma frase sobre o que ele faz.
Tudo aqui foi escrito para o NumPy 2, a versão que a Coddy roda, e a última tabela lista os nomes que o NumPy 2 removeu, ao lado do que escrever no lugar. A maioria dos exemplos usa a = np.array([3, 1, 4, 1, 5, 9, 2, 6]) e m = np.arange(12).reshape(3, 4). Está começando em Python? Comece pela folha de consulta Python e pelo playground de Python, e deixe as folhas de consulta de pandas, Matplotlib e scikit-learn abertas ao lado desta.
Perguntas frequentes sobre a folha de consulta NumPy
Esta folha de consulta de NumPy é grátis?
Sim. Esta folha de consulta de NumPy é totalmente grátis, sem cadastro. Salve nos favoritos ou imprima em PDF pelo navegador, e volte sempre que precisar da chamada exata para um reshape, uma soma por eixo ou um sorteio aleatório.
Qual versão do NumPy esta folha de consulta cobre?
O NumPy 2. Todos os trechos rodam no NumPy 2.4, a versão que a Coddy roda. O NumPy 2 removeu aliases como
np.NaN, np.float_, np.trapz e np.in1d, então a última tabela mostra cada um ao lado do nome atual.O que significa axis=0 no NumPy?
O eixo é a dimensão que é colapsada. Num array 2D,
axis=0 percorre as linhas para baixo, então m.sum(axis=0) devolve um total por coluna. axis=1 percorre as colunas e devolve um total por linha. Sem eixo, a função usa todos os elementos.Qual é a diferença entre uma view e uma cópia?
Uma fatia como
a[1:3] é uma view: ela compartilha memória com a, então alterar a fatia altera a. Máscaras booleanas e listas de índices como a[a > 2] ou a[[0, 2]] devolvem cópias. Chame .copy() quando precisar de um array independente.Por que usar um array NumPy em vez de uma lista Python?
Arrays guardam um só tipo em um bloco único de memória, então contas no array inteiro rodam em código compilado e costumam ser muitas vezes mais rápidas que um loop Python.
a * 2 dobra cada elemento, enquanto [1, 2] * 2 repete a lista. O pandas e o scikit-learn são construídos sobre arrays NumPy.Devo usar np.random.seed ou default_rng?
Use
rng = np.random.default_rng(seed) e chame os métodos em rng, como rng.normal() ou rng.integers(). É a API recomendada, com fluxos aleatórios melhores e sem estado global escondido. np.random.seed e np.random.rand ainda funcionam, mas são a interface legada.Posso rodar código NumPy online?
Sim. O playground de Matplotlib grátis roda Python com NumPy, pandas, Matplotlib e scikit-learn no navegador, então você pode colar qualquer trecho desta folha de consulta e rodar sem instalar nada. O curso de Machine Learning da Coddy ensina NumPy passo a passo, trabalhando com dados reais.
Recursos relacionados
Mais folhas de consulta
