Tutorial de array NumPy em Python

Instalar com Python Wheels

Primeiro, confirme que você tem Python instalado. Você pode consultar nosso guia de como instalar Python se ainda não fez isso :)

Se você está no Windows, certifique-se de ter adicionado o Python à variável de ambiente PATH. Depois, não esqueça de instalar um gerenciador de pacotes, como o pip, que garante o uso de bibliotecas open source do Python.

Versões recentes do Python 3 já vêm com o pip. Verifique se você tem o pip e, se tiver, atualize antes de instalar o NumPy:

pip install pip --upgrade
pip --version

pip install numpy-<version>-<architecture>.whl

import numpy

Instalar com a distribuição Anaconda

Para obter o NumPy, você também pode baixar a distribuição Anaconda. É simples e permite começar rapidinho! Se ainda não baixou, acesse a página oficial e faça o download. Siga as instruções de instalação e pronto!

Por que isso pode ser mais fácil?

O bom de usar essa distribuição é que você não precisa se preocupar em instalar separadamente o NumPy ou qualquer outro pacote importante que vai usar nas suas análises, como pandas, scikit-learn etc.

Especialmente se você é iniciante em Python, programação ou terminal, é um alívio saber que o Anaconda já inclui 100 dos pacotes mais populares de Python, R e Scala para ciência de dados. E mesmo para profissionais mais experientes, Anaconda é o caminho se você quer começar a resolver problemas rápido.

Além disso, o Anaconda inclui vários ambientes de desenvolvimento open source, como Jupyter e Spyder. Se quiser começar a trabalhar com Jupyter Notebook depois deste tutorial, confira nosso tutorial de Jupyter Notebook.

Resumindo, considere baixar o Anaconda para começar a trabalhar com numpy e outros pacotes relevantes para ciência de dados!

Como criar um array NumPy “vazio”

Quando as pessoas dizem que estão criando arrays “vazios”, geralmente querem usar placeholders iniciais, que podem ser preenchidos depois. Você pode inicializar arrays com uns (ones) ou zeros, mas também criar arrays preenchidos com valores igualmente espaçados, constantes ou aleatórios.

Ainda assim, também dá para criar um array totalmente vazio.

Felizmente, há várias funções para isso.

Teste tudo abaixo!

import numpy as np

# Create an array of ones
ones_array = np.ones((3, 4))
print("Ones Array:")
print(ones_array)
print()

# Create an array of zeros
zeros_array = np.zeros((2, 3, 4), dtype=np.int16)
print("Zeros Array:")
print(zeros_array)
print()

# Create an array with random values
random_array = np.random.random((2, 2))
print("Random Array:")
print(random_array)
print()

# Create an empty array
empty_array = np.empty((3, 2))
print("Empty Array:")
print(empty_array)
print()

# Create a full array
full_array = np.full((2, 2), 7)
print("Full Array:")
print(full_array)
print()

# Create an array of evenly-spaced values
arange_array = np.arange(10, 25, 5)
print("Arange Array:")
print(arange_array)
print()

# Create an array of evenly-spaced values
np.linspace(0,2,9)

Dica: brinque com as funções acima para entender como funcionam!

• Em algumas, como np.ones(), np.random.random(), np.empty(), np.full() ou np.zeros(), você só precisa passar o shape do array que deseja criar. Em np.ones() e np.zeros(), você também pode especificar o tipo de dado. Em np.full(), é preciso indicar o valor constante a ser inserido.
• Com np.linspace() e np.arange() você cria arrays de valores igualmente espaçados. A diferença é que o terceiro valor passado no código acima representa o passo em np.arange() ou o número de amostras em np.linspace(). No primeiro caso do exemplo, você quer um array com 9 valores entre 0 e 2. No segundo, você especifica que quer um array que comece em 10 e, de 5 em 5, gere valores para o array que está criando.

Lembre que o NumPy também permite criar uma matriz identidade com np.eye() e np.identity(). Uma matriz identidade é quadrada, com 1s na diagonal principal e 0s nos demais elementos. Ao multiplicar uma matriz por uma identidade, a matriz dada permanece inalterada.

Em outras palavras, ao multiplicar por uma matriz identidade, o produto resultante é a mesma matriz, pelas convenções padrão de multiplicação de matrizes.

Embora o foco aqui não seja demonstrar o funcionamento de matrizes identidade, vale dizer que elas são úteis quando você começa a fazer cálculos matriciais: simplificam equações e tornam as computações mais eficientes e robustas.

Como carregar arrays NumPy a partir de texto

Criar arrays com placeholders ou com dados de exemplo é ótimo para começar com o numpy. Mas, quando for fazer análise de dados, você vai precisar carregar dados de arquivos de texto.

Com o que vimos até agora, não dá para fazer muito. Use funções específicas para carregar dados dos seus arquivos, como loadtxt() ou genfromtxt().

Suponha que você tenha o arquivo de texto abaixo; copie e cole os valores comentados no código, salve como “data.txt” e use o código a seguir:

# This is your data in the text file
# Value1  Value2  Value3
# 0.2536  0.1008  0.3857
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  0.5929
# 0.1781  0.3049  0.8928
# 0.6253  0.3486  0.8791

# Import your data
x, y, z = np.loadtxt('data.txt',
                    skiprows=1,
                    unpack=True)

No código acima, você usa o loadtxt() para carregar os dados. O primeiro argumento é o arquivo data.txt. Em seguida, há argumentos específicos: no primeiro comando, você pula a primeira linha e retorna as colunas como arrays separados com unpack=TRUE. Isso significa que os valores da coluna Value1 vão para x, e assim por diante.

Se você tiver dados separados por vírgula ou quiser especificar o tipo de dado, há também os argumentos delimiter e dtype que podem ser adicionados ao loadtxt().

Fácil e direto, certo?

Vamos ver seu segundo arquivo de dados:

# Your data in the text file
# Value1  Value2  Value3
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  MISSING
# 0.1781  0.3049  0.8928
# MISSING 0.5801  0.2038
# 0.5993  0.4357  0.7410

my_array2 = np.genfromtxt('data2.txt',
                      skip_header=1,
                      filling_values=-999)

Aqui você recorre a genfromtxt() para carregar os dados. Neste caso, é preciso lidar com valores ausentes indicados pela string 'MISSING'.

Como genfromtxt() converte strings de caracteres em colunas numéricas para nan, você pode converter esses valores em outros especificando o argumento filling_values. Aqui, você escolhe definir -999 para os ausentes.

Se, por acaso, houver valores que não são convertidos para nan por genfromtxt(), use o argumento missing_values para especificar quais são exatamente os valores ausentes nos seus dados.

Mas não para por aí.

Dica: confira a página do numpy.genfromtxt para ver outros argumentos e importar seus dados com sucesso.

Você pode estar se perguntando qual a diferença entre essas duas funções.

Os exemplos sugerem isso implicitamente, mas, em geral, genfromtxt() dá um pouco mais de flexibilidade; é mais robusta que loadtxt().

De forma prática: loadtxt() só funciona quando cada linha do arquivo tem o mesmo número de valores, então, quando você precisa lidar com ausências com facilidade, costuma ser melhor usar genfromtxt().

E não é só por isso.

Um olhar rápido no número de argumentos de genfromtxt() mostra que dá para especificar muito mais coisas na importação, como o número máximo de linhas a ler ou a opção de remover automaticamente espaços em branco das variáveis.

Como salvar arrays NumPy

Depois de fazer o que precisa com seus arrays, você também pode salvá-los em um arquivo. Para salvar um array em um arquivo de texto, use a função savetxt():

import numpy as np
x = np.arange(0.0,5.0,1.0)
np.savetxt('test.out', x, delimiter=',')

Lembre que np.arange() cria um array de valores igualmente espaçados. O terceiro valor passado é o passo.

Claro, há outras formas de salvar arrays NumPy em arquivos de texto. Confira as funções na tabela abaixo se quiser gravar seus dados em binários ou arquivos compactados:

Para mais informações ou exemplos de uso dessas funções para salvar seus dados, veja esta página de referência do NumPy ou use as funções de ajuda do próprio NumPy!

Não tem certeza de quais são essas funções de ajuda?

Sem problemas! Você vai aprender mais sobre elas em uma das próximas seções!

Como inspecionar seus arrays NumPy

Além dos atributos citados acima — data, shape, dtype e strides — há outros que ajudam a conhecer melhor seus arrays. Os que podem ser úteis no começo são:

import numpy as np

# Create a numpy array with shape (2,4) and dtype int64
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the number of dimensions of `my_array`
print("Number of dimensions of my_array:")
print(my_array.ndim)
print()

# Print the number of elements in `my_array`
print("Number of elements in my_array:")
print(my_array.size)
print()

# Print information about the memory layout of `my_array`
print("Information about the memory layout of my_array:")
print(my_array.flags)
print()

# Print the length of one array element in bytes
print("Length of one array element in bytes:")
print(my_array.itemsize)
print()

# Print the total consumed bytes by `my_array`'s elements
print("Total consumed bytes by my_array's elements:")
print(my_array.nbytes)
print()

Estes são quase todos os atributos que um array pode ter.

Não se preocupe se nem todos parecerem úteis agora. É normal, porque, como dito antes, você só começa a se preocupar com memória quando trabalha com conjuntos de dados grandes.

Além dos atributos, há outras formas de obter informações e até ajustar seu array levemente:

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

# Print the length of `my_array`
print(len(my_array))

# Change the data type of `my_array`
my_array.astype(float)

Agora que você criou seu array, seja com np.array() ou com funções de placeholders, ou carregando dados com loadtxt() ou genfromtxt(), é hora de olhar com mais atenção para o segundo elemento-chave que define o NumPy: a computação científica.

Como transpor seus arrays

Transpor arrays significa permutar suas dimensões. Em outras palavras, você inverte o shape do array. Veja um exemplo para mostrar o efeito da transposição:

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

# Print `my_2d_array`
print(my_2d_array)

# Transpose `my_2d_array`
print(np.transpose(my_2d_array))

# Or use `T` to transpose `my_2d_array`
print(my_2d_array.T)

Dica: se a comparação visual entre o array e sua versão transposta não estiver clara, inspecione o shape dos dois para entender como as dimensões foram permutadas.

Existem duas formas de transpor. Ambas fazem a mesma coisa; a diferença é pequena. T é mais uma conveniência, e você tem mais flexibilidade com np.transpose(). Por isso, recomenda-se usar np.transpose() quando quiser passar mais argumentos.

Tudo certo ao transpor arrays com mais de uma dimensão, mas o que acontece com um array 1D? Haverá algum efeito?

Teste você mesmo no bloco abaixo. Seu array 1D já foi carregado:

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

# Print `my_2d_array
print(my_array)

# Transpose `my_2d_array
print(np.transpose(my_array))

# Or use `T` to transpose `my_2d_array
print(my_array.T)

Isso mesmo! Não há efeito ao transpor um array 1D!

Reshape versus resize

Você viu na seção de broadcasting que as dimensões dos arrays precisam ser compatíveis para operações aritméticas. Mas o que fazer quando não são?

Aqui vai a resposta!

Se os arrays não têm as mesmas dimensões, você pode redimensionar (resize) seu array. Isso retorna um novo array com o shape passado para np.resize(). Se você passar seu array original com as novas dimensões e se o novo array for maior que o original, ele será preenchido com cópias do array original repetidas quantas vezes forem necessárias.

Por outro lado, se você aplicar np.resize() diretamente e passar apenas o novo shape, o novo array será preenchido com zeros.

Vamos testar com um exemplo:

import numpy as np
x = np.ones((3,4))

# Print the shape of `x`
print(x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x`
print(x)

Além de redimensionar, você também pode fazer reshape no array. Isso significa dar um novo formato sem alterar os dados. A chave é garantir que o tamanho total do novo array permaneça o mesmo. Se tomarmos o array x acima, com tamanho 3 x 4 (12), o novo array também precisa ter tamanho 12.

Psst… Se quiser calcular o tamanho com código, use o atributo size: x.size ou x.reshape((2,6)).size:

import numpy as np

# Initialize array with shape (3,4) containing all ones
x = np.ones((3,4))

# Print the shape of `x`
print("Shape of x:", x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x` before and after resizing
print("Array before transposing:\n", x)
print("Shape of array before transposing:", x.shape)

# Transpose `x`
x = x.T

# Print out `x` after transposing
print("Array after transposing:\n", x)
print("Shape of array after transposing:", x.shape)

Saída: 

Shape of x: (3, 4)
Array before transposing:
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
Shape of array before transposing: (6, 4)
Array after transposing:
 [[1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]]
Shape of array after transposing: (4, 6)

Se nada der certo, você também pode anexar (append) um array ao original, ou inserir ou deletar elementos para ajustar as dimensões e torná-las compatíveis com o outro array das suas contas.

Outra operação útil ao alterar o shape é ravel(). Essa função “achata” arrays. Ou seja, se você tiver arrays 2D, 3D ou nD, pode usar ravel() para transformá-los em um array 1D.

Bem prático, né?

Como anexar arrays

Ao anexar arrays ao array original, eles são “colados” ao final. Se você quiser inserir em outra posição, considere usar insert. Vá para a próxima seção para saber mais.

Fazer append é bem simples com NumPy; basta usar np.append().

Veja como funciona no código abaixo. Lembre que você pode conferir os arrays carregados digitando, por exemplo, my_array no shell IPython e pressionando ENTER.

import numpy as np

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

# Print `my_array` before appending
print("my_array before appending:", my_array)

# Append a 1D array to `my_array`
new_array = np.append(my_array, [7, 8, 9, 10])

# Print `new_array`
print("new_array:", new_array)

# Print `my_array` after appending
print("my_array after appending:", my_array)

Saída:

my_array before appending: [1 2 3 4]
new_array: [ 1  2  3  4  7  8  9 10]
my_array after appending: [1 2 3 4]

Note que my_array permanece inalterado após o append porque np.append() retorna um novo array em vez de modificar o original.

Fazendo append em my_2d_array:

import numpy as np

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

# Print `my_2d_array` before appending
print("my_2d_array before appending:\n", my_2d_array)

# Append an extra column to `my_2d_array`
new_2d_array = np.append(my_2d_array, [[7], [8]], axis=1)

# Print `new_2d_array`
print("new_2d_array:\n", new_2d_array)

# Print `my_2d_array` after appending
print("my_2d_array after appending:\n", my_2d_array)

Saída: 

my_2d_array before appending:
 [[1 2 3 4]
  [5 6 7 8]]
new_2d_array:
 [[1 2 3 4 7]
  [5 6 7 8 8]]
my_2d_array after appending:
 [[1 2 3 4]
  [5 6 7 8]]

Note que, ao anexar uma coluna extra a my_2d_array, o eixo é especificado. Lembre que em arrays 2D o axis 1 indica colunas e o axis 0 indica linhas.

Como inserir e deletar elementos

Além de anexar, você pode inserir e deletar elementos. Como você deve imaginar, as funções para isso são np.insert() e np.delete():

import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Insert `5` at index 1
np.insert(my_array, 1, 5)

# Delete the value at index 1
np.delete(my_array,[1])

Como unir e dividir arrays

Você também pode “juntar” ou unir arrays. Há várias funções para isso e a maioria está listada abaixo.

Teste-as, e também confira o shape dos arrays no shell IPython. Os arrays carregados são x, my_array, my_resized_array e my_2d_array.

import numpy as np 
x = np.ones((4,))
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Concatentate `my_array` and `x`
print(np.concatenate((my_array,x)))

# Stack arrays row-wise
print(np.vstack((my_array, my_2d_array)))

# Stack arrays row-wise
print(np.r_[my_resized_array, my_2d_array])

# Stack arrays horizontally
print(np.hstack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.column_stack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.c_[my_resized_array, my_2d_array])

Você vai notar algumas coisas ao usar essas funções:

• O número de dimensões precisa ser o mesmo para concatenar dois arrays com np.concatenate(). Assim, se quiser concatenar algo com my_array, que é 1D, o outro também deve ser 1D.
• Com np.vstack(), você combina my_array com my_2d_array sem esforço. Basta garantir que, como está empilhando por linhas, o número de colunas seja o mesmo em ambos. Assim, você pode adicionar um array com shape (2,4) ou (3,4) a my_2d_array, desde que as colunas combinem. Em outras palavras, os arrays devem ter o mesmo shape em todos os eixos, exceto o primeiro. O mesmo vale para np.r[].
• Para np.hstack(), as dimensões precisam ser as mesmas e o número de linhas deve coincidir. Isso significa que você pode empilhar arrays como (2,3) ou (2,4) com my_2d_array, que tem shape (2,4). Tudo é possível desde que o número de linhas bata. Essa função ainda é suportada pelo NumPy, mas prefira np.concatenate() ou np.stack().
• Com np.column_stack(), os arrays de entrada devem ter a mesma primeira dimensão. Neste caso, os shapes são iguais, mas se my_resized_array fosse (2,1) ou (2,), ainda assim seriam empilhados.
• np.c_[] é outra forma de concatenar. Aqui também, a primeira dimensão de ambos deve coincidir.

Depois de unir arrays, você pode querer dividi-los. Assim como você empilha horizontalmente, também pode dividir horizontal ou verticalmente. Use np.hsplit() e np.vsplit(), respectivamente:

import numpy as np
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_stacked_array = np.hstack((my_resized_array, my_2d_array))

# Split `my_stacked_array` horizontally at the 2nd index
print(np.hsplit(my_stacked_array, 2))

# Split `my_stacked_array` vertically at the 2nd index
print(np.vsplit(my_stacked_array, 2))

Ao usar essas funções de split, tenha em mente o shape do seu array. No caso acima: my_stacked_array tem shape (2,8). Ao escolher o índice da divisão, considere o shape.

Com np.histogram()

Ao contrário do que o nome sugere, a função np.histogram() não desenha o histograma — ela calcula as ocorrências do array que caem em cada faixa (bin); isso determina a área de cada barra do histograma.

Você passa primeiro os dados de entrada (seu array). Ele será achatado (flattened) quando o histograma for calculado.

# Import `numpy` as `np`
import numpy as np

# Initialize your array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Pass the array to `np.histogram()`
print(np.histogram(my_3d_array))

# Specify the number of bins
print(np.histogram(my_3d_array, bins=range(0,13)))

Como resultado, o histograma é calculado: o primeiro array lista as frequências de todos os elementos e o segundo lista as faixas (bins) que seriam usadas se você não especificar nada.

Se você especificar o número de bins, o resultado muda: os floats somem e você verá apenas inteiros para os bins.

Há outros argumentos que influenciam o histograma. Você encontra todos aqui.

Mas qual o ponto de calcular o histograma sem visualizá-lo?

A visualização é simples com Matplotlib, e você nem precisa do np.histogram(): o plt.hist() faz o cálculo ao receber os dados (achatados) e os bins:

# Import numpy and matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Construct the histogram with a flattened 3d array and a range of bins
plt.hist(my_3d_array.ravel(), bins=range(0,13))

# Add a title to the plot
plt.title('Frequency of My 3D Array Elements')

# Show the plot
plt.show()

O código acima gera o seguinte histograma (básico):

Usando np.meshgrid()

Outra forma de (indiretamente) visualizar seu array é com np.meshgrid(). O desafio com arrays é que você precisa de arrays 2D de coordenadas x e y. Com essa função, você cria uma grade retangular a partir de um array de valores x e outro de valores y: np.meshgrid() recebe dois arrays 1D e produz duas matrizes 2D correspondentes a todos os pares (x, y) dos dois arrays. Depois, você pode usar essas matrizes para vários tipos de gráfico.

np.meshgrid() é particularmente útil para avaliar funções em uma grade, como mostra o código abaixo:

# Import NumPy and Matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Create an array
points = np.arange(-5, 5, 0.01)

# Make a meshgrid
xs, ys = np.meshgrid(points, points)
z = np.sqrt(xs ** 2 + ys ** 2)

# Display the image on the axes
plt.imshow(z, cmap=plt.cm.gray)

# Draw a color bar
plt.colorbar()

# Show the plot
plt.show()

O código acima gera o seguinte resultado: