Arrays e cálculo com NumPy

Uma lista pode guardar objetos diferentes. Um array NumPy guarda elementos de um tipo comum e suporta operações sobre todos eles. Para calcular o total de cada venda, podemos multiplicar um array de quantidades por outro de preços.

Criar e inspecionar

import numpy as np

quantidades = np.array([2, 3, 4])
precos = np.array([1.5, 1.2, 2.0])

quantidades.ndim é 1, quantidades.shape é (3,) e quantidades.size é 3. dtype indica o tipo guardado. Ao criar np.array([1, 2.5]), os elementos passam a reais, para partilhar o mesmo tipo.

Um array de inteiros não passa automaticamente a reais quando lhe atribuis 2.5. Escolhe dtype=float quando o cálculo exige frações. A mistura com strings pode converter todos os elementos para texto e impedir a aritmética esperada.

np.zeros((2, 3)) cria duas linhas e três colunas preenchidas com zero. np.ones preenche com um. np.arange(1, 6, 2) produz 1, 3 e 5. np.linspace(0, 1, 5) produz cinco pontos igualmente espaçados, incluindo normalmente ambos os extremos. np.empty reserva espaço sem inicializar valores úteis; preenche-o antes de ler.

Tipo e memória

O número no nome int8, uint8, float32 ou float64 indica bits por elemento. int8 guarda inteiros de −128 a 127; uint8, sem sinal, guarda 0 a 255. float32 ocupa quatro bytes e float64 oito. complex64 ocupa oito bytes no total, com duas componentes reais de quatro bytes.

a.itemsize dá bytes por elemento e a.nbytes o total de bytes dos dados. Um array (2, 3) de float64 tem seis elementos e ocupa 48 bytes de dados. Isto não inclui todo o custo do objeto Python. .data expõe o buffer; usa índices para aceder aos valores.

a.astype(float) devolve normalmente outro array convertido. Escolhe um tipo que represente os valores e a precisão necessários: inteiros de tamanho fixo podem transbordar e converter reais para inteiros elimina a parte fracionária. np.iinfo(np.int8) mostra limites de um tipo inteiro. O tipo de np.array é inferido dos dados quando omites dtype; não é sempre float64.

Identidade e leitura de dados numéricos

np.eye(3) cria uma matriz identidade 3 × 3, com uns na diagonal e zeros fora dela. Para dados tabulares numéricos, genfromtxt lê um ficheiro ou objeto semelhante a ficheiro, permitindo indicar separador e linhas de cabeçalho.

from io import StringIO
import numpy as np

texto = StringIO("a;b\n2;3\n4;5\n")
a = np.genfromtxt(texto, delimiter=";", skip_header=1)
print(a.shape)       # (2, 2)
print(a.sum(axis=0)) # [6. 8.]

Aqui as colunas são numéricas. Para colunas de tipos diferentes, datas ou categorias, um DataFrame pandas costuma conservar melhor o significado da tabela. Confere a forma e os valores em falta após ler dados externos.

Operar elemento a elemento

import numpy as np
quantidades = np.array([2, 3, 4])
precos = np.array([1.5, 1.2, 2.0])
totais = quantidades * precos
print(totais.round(2))
print(round(totais.sum(), 2))
print(quantidades[quantidades >= 3])

Os totais são 3,00, 3,60 e 8,00 euros; a soma é 14,60 euros. A comparação cria uma máscara booleana com False, True, True. Aplicar a máscara seleciona as quantidades 3 e 4.

Com listas, [2, 3] * 2 repete a sequência. Com NumPy, np.array([2, 3]) * 2 multiplica os valores e dá 4 e 6. * não calcula um produto matricial; @ calcula esse produto quando as dimensões são compatíveis.

Duas dimensões e eixos

Vamos guardar duas lojas em linhas e três produtos em colunas:

import numpy as np
vendas = np.array([[2, 3, 4], [5, 1, 2]])
print(vendas.shape)
print(vendas[1, 0])
print(vendas[:, 1])
print(vendas.sum(axis=0))
print(vendas.sum(axis=1))

A forma é (2, 3). A célula de linha 1, coluna 0 contém 5. A coluna 1 contém 3 e 1. A soma com axis=0 elimina o eixo das linhas e dá os totais por coluna: 7, 4 e 6. Com axis=1, elimina o eixo das colunas e dá os totais por linha: 9 e 8.

O nome do eixo é o que percorres e reduzes. Para evitar trocar os dois, confere o tamanho do resultado: três produtos exigem três totais, duas lojas exigem dois.

reshape(3, 2) reorganiza seis elementos numa forma compatível. Não cria nem elimina elementos. reshape(-1, 2) pede ao NumPy que deduza o número de linhas. .T troca os eixos de um array 2D.

Broadcasting

Ao multiplicar a matriz (2, 3) por preços com forma (3,), NumPy usa o mesmo vetor de preços em cada linha. Este alargamento chama-se broadcasting. Compara as dimensões a partir da direita: devem ser iguais ou uma delas deve ser 1.

(2, 3) e (3,) são compatíveis. (2, 3) e (2,) não são. Para aplicar um desconto diferente por loja, usa um array com forma (2, 1).

Vistas e cópias

Um slice básico pode ser uma vista, que partilha os dados com o array original. Alterar parte = dados[:2] pode alterar dados. dados[:2].copy() cria dados independentes. Seleção por máscara booleana e índices avançados produz uma cópia; não uses essa distinção como substituto para tornar a alteração explícita.

Quando queres alterar o original, escreve dados[mascara] = novo_valor. Quando queres trabalhar à parte, usa .copy().

Estatísticas e acumulados de arrays

sum, mean, min, max, std e var reduzem valores. NumPy usa ddof=0 por defeito em std e var; indica ddof=1 para a convenção amostral. argmin e argmax devolvem posições, enquanto min e max devolvem valores. Sem eixo, a posição refere-se ao array achatado.

np.cumsum([2, 3, 1]) devolve 2, 5 e 6; np.cumprod devolve 2, 6 e 6. Num array 2D, indica axis para conservar a organização pretendida. Sem eixo, os acumulados usam uma sequência achatada. A presença de NaN pode propagar ausência; funções como np.nansum exprimem a decisão de ignorar NaN.

Gerar dados aleatórios reproduzíveis

Cria um gerador com rng = np.random.default_rng(12). A semente fixa o estado inicial. Na mesma versão e com a mesma sequência de chamadas, podes repetir a experiência; mudar a ordem das chamadas muda os valores seguintes.

Slides e programas antigos usam np.random.seed, rand, randint e randn. Correspondem à interface anterior: rand gera uniformes, randint inteiros e randn normais padrão. Para código novo, o gerador explícito evita partilhar estado aleatório global entre exemplos.

import numpy as np

def lancamentos(semente):
    rng = np.random.default_rng(semente)
    return rng.integers(1, 7, size=12)

a = lancamentos(12)
b = lancamentos(12)
print("repetiu:", np.array_equal(a, b))
print("entre 1 e 6:", bool(((a >= 1) & (a <= 6)).all()))
print("contagens:", np.bincount(a, minlength=7)[1:].tolist())

As contagens somam 12. Não devem ser iguais por face numa amostra pequena. Um gerador reproduz uma simulação; não transforma resultados aleatórios numa garantia de frequências exatas.