Arrays do NumPy e dtypes

Por que arrays, e o que é um array

Uma lista Python pode guardar qualquer coisa, o que a torna flexível mas lenta para números: cada elemento é um objeto separado. O NumPy acrescenta o ndarray, um bloco de memória com números de um único tipo, dispostos um após o outro. Operar sobre o bloco inteiro em código compilado costuma ser dezenas de vezes mais rápido que um laço Python e usa muito menos memória. Quase toda biblioteca quantitativa (pandas, SciPy, scikit-learn) é construída sobre ele. Por convenção importa-se com import numpy as np.

import numpy as np

# Create arrays
prices = np.array([184.25, 185.0, 183.2])
print(prices)                       # [184.25 185.   183.2 ]
print(np.zeros(3))                  # [0. 0. 0.]
print(np.arange(0, 10, 3))          # [0 3 6 9]
print(np.linspace(0, 1, 5))         # [0.   0.25 0.5  0.75 1.  ]

# An array knows its shape
table = np.array([[1, 2, 3], [4, 5, 6]])
print(table.shape, table.ndim, table.size)   # (2, 3) 2 6

Criar arrays

np.array(lista) converte uma lista (ou uma lista de listas para duas dimensões). np.zeros(n) e np.ones(n) criam arrays preenchidos, e np.zeros((linhas, colunas)) recebe uma tupla de formato. np.arange(início, fim, passo) funciona como range, mas aceita passos decimais e exclui fim; por causa do arredondamento, prefira np.linspace(início, fim, num), que dá exatamente num pontos igualmente espaçados e inclui os dois extremos. Todo array tem .shape (o tamanho em cada dimensão), .ndim (número de dimensões) e .size (número total de elementos).

import numpy as np

# arange with floats can surprise; linspace gives exactly the points you ask for
print(len(np.arange(0, 1, 0.1)))     # 10  (1.0 is excluded)
print(len(np.linspace(0, 1, 11)))    # 11  (both ends included)

# Shapes and sizes
grid = np.zeros((3, 4))
print(grid.shape, grid.ndim, grid.size)   # (3, 4) 2 12
print(np.ones(2) * 5)                      # [5. 5.]

dtypes: um só tipo para todo o array

Todo array tem um dtype: int64 (inteiros), float64 (decimais), bool e variantes menores ou maiores como float32 ou int8. O NumPy escolhe o dtype pelos dados: inteiros dão int64, um único decimal converte tudo em float64 e np.nan (not-a-number, a marca de valor ausente) é um float, então força float64. Escolha o dtype você mesmo com dtype=... ou converta com .astype(...), que devolve um array novo. Um dtype menor economiza memória (float32 ocupa metade de float64), ao custo de precisão.

import numpy as np

print(np.array([1, 2, 3]).dtype)            # int64
print(np.array([1, 2.5, 3]).dtype)          # float64  (one decimal upgrades everything)
print(np.array([True, False]).dtype)        # bool
print(np.array([1, 2, np.nan]))             # [ 1.  2. nan]  (nan is a float)

# astype returns a new array; smaller dtypes use less memory
prices = np.zeros(1000)
print(prices.nbytes)                        # 8000
print(prices.astype(np.float32).nbytes)     # 4000
print(np.array(["1.5", "2"], dtype=float))  # [1.5 2. ]  (text converted to numbers)

Armadilhas de conversão: truncamento e estouro

Converter decimais em inteiros com .astype(int) trunca em direção a zero, e os floats não representam exatamente a maioria dos decimais: 19.99 * 100 é 1998.9999999999998 e trunca para 1998, um centavo a menos. Para converter preços em centavos inteiros, arredonde primeiro: np.round(prices * 100).astype(np.int64). Os dtypes inteiros também têm faixa fixa e dão a volta em silêncio: um int8 vai de -128 a 127, então 100 * 2 vira -56. Use int64 para dinheiro e contagens, e lembre-se de que dividir inteiros com / sempre dá floats, enquanto // arredonda para baixo.

import numpy as np

# Truncation: astype(int) cuts the decimals off
print(np.array([1.9, -1.9]).astype(int))              # [ 1 -1]
print(19.99 * 100, int(19.99 * 100))                  # 1998.9999999999998 1998
print(np.round(np.array([19.99]) * 100).astype(np.int64))   # [1999]

# Overflow: an int8 wraps around silently
small = np.array([100, 50], dtype=np.int8)
print(small * 2)                                      # [-56 100]

# / always gives floats, // floors
counts = np.array([1, 2, 3])
print(counts / 2, counts // 2)                        # [0.5 1.  1.5] [0 1 1]

• np.array, zeros, ones, arange, linspace criam arrays; .shape, .ndim, .size os descrevem.
• Um dtype por array: int64, float64, bool; astype converte em um array novo.
• astype(int) trunca (arredonde antes); dtypes inteiros pequenos dão a volta em silêncio; nan força floats.

A seguir: indexação e fatiamento de arrays, para escolher linhas, colunas, janelas e valores que atendem a uma condição.

Lab: o que é avaliado

• Montar pontos igualmente espaçados com make_grid25 pts
• Transformar valores brutos mistos em floats com to_float_array25 pts
• Informar formato, tamanho e dtype com describe_array25 pts
• Converter preços em centavos inteiros com segurança usando to_cents25 pts