Matrizes NumPy: uma introdução [com exemplos]

Olhando para começar com NumPy? Este guia ensinará os fundamentos dos arrays NumPy em Python.

Como primeiro passo, você aprenderá como as matrizes NumPy funcionam de maneira diferente das listas Python. Você aprenderá várias maneiras de criar matrizes NumPy e executar operações básicas nelas.

Vamos começar!

Noções básicas de matrizes NumPy

O NumPy é uma das bibliotecas Python mais populares para computação científica e análise de dados. As estruturas básicas de dados no NumPy são matrizes N-dimensionais (matrizes ND). Eles têm recursos de transmissão e nos permitem vetorizar operações para obter velocidade e usar funções matemáticas integradas para melhorar o desempenho.

Para começar a trabalhar com o NumPy, você deve primeiro instalar a biblioteca e importá-la para o seu ambiente de trabalho. Ele está disponível como um pacote PyPI instalável por meio do pip.

Para instalar o NumPy, abra seu terminal e execute o seguinte comando:

 pip3 install numpy

Depois de instalar o NumPy, você pode importá-lo para o seu ambiente de trabalho com um alias. O apelido usual é np .

 import numpy as np

Nota : Importar NumPy sob o pseudônimo np não é um requisito, mas uma convenção recomendada.

Listas Python vs. Arrays NumPy

Considere a seguinte lista de números Python:

 py_list = [1,2,3,4]

Você pode obter um array NumPy de uma lista existente chamando a função np.array() com a lista como argumento.

 np_arr1 = np.array(py_list) print(np_arr1) [1 2 3 4]

Para verificar o tipo de np_arr1 , você chama a função interna type() , verá que é ndarray , a estrutura de dados fundamental em NumPy.

 type(np_arr1) # numpy.ndarray

Embora a lista Python e a matriz NumPy possam parecer semelhantes, existem algumas diferenças:

• Uma lista Python pode conter objetos de diferentes tipos de dados, enquanto uma matriz NumPy contém elementos do mesmo tipo de dados. O tipo de dados padrão é float com uma precisão de 64 bits (float64).
• Os elementos de uma lista Python não são necessariamente armazenados em locais contíguos na memória. No entanto, os elementos de uma matriz NumPy são armazenados em um bloco contíguo na memória. Como resultado, é mais rápido procurar e acessar elementos.

Vamos examinar algumas outras diferenças.

Transmissão

Um recurso poderoso dos arrays NumPy é a transmissão. Suponha que gostaríamos de adicionar 2 a todos os elementos de np_arr1 e py_list .

Vamos tentar adicionar 2 a py_list e ver o que acontece:

 >>> py_list + 2

Vemos que recebemos um TypeError informando que só podemos concatenar duas listas e adicionar py_list + 2 dessa forma não é suportado.

 --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-5-c0f9974899df> in <module> ----> 1 py_list + 2 TypeError: can only concatenate list (not "int") to list

Vamos tentar a mesma operação no array, np_arr1 .

 >>> np_arr1 + 2

No resultado, vemos que 2 foi adicionado a cada elemento do array.

 array([3, 4, 5, 6])

Isso ocorre porque o NumPy transmitiu implicitamente o escalar 2 para uma matriz de formato compatível para produzir esse resultado.

vetorização

As matrizes NumPy oferecem suporte à vetorização para operações mais rápidas por elementos. Suponha que gostaríamos de encontrar a soma elementar das duas matrizes.

Usar uma simples operação + na lista retornaria a concatenação das duas listas (o que não é o que queremos!).

 >>> py_list + py_list # [1, 2, 3, 4, 1, 2, 3, 4]

Mas a mesma operação na matriz NumPy, np_arr1 , retorna a soma elementar de np_arr1 consigo mesma.

 >>> np_arr1 + np_arr1 # array([2, 4, 6, 8])

Da mesma forma, as listas aninhadas podem parecer semelhantes em estrutura a uma matriz NumPy N-dimensional. No entanto, as diferenças discutidas até agora se mantêm.

 nested_list = [[1,2],[3,4],[5,6]] np_arr2 = np.array(nested_list) print(np_arr2)

 [[1 2] [3 4] [5 6]]

Como criar matrizes NumPy

Você sempre pode criar matrizes NumPy a partir de listas Python existentes usando np.array(list-obj) . No entanto, esta não é a maneira mais eficiente.

Em vez disso, você pode usar várias funções internas que permitem criar matrizes de uma forma específica. A forma da matriz é uma tupla que denota o tamanho da matriz ao longo de cada dimensão. Por exemplo, a forma de uma matriz 2 × 2 com duas linhas e duas colunas é (2,2). Nesta seção, aprenderemos como usar algumas dessas funções integradas.

Criando matrizes de zeros e uns

Muitas vezes é útil criar uma matriz de dimensões específicas preenchidas com todos os zeros ou todos os uns. Em seguida, use-os e modifique-os nas etapas subsequentes do programa.

Podemos usar a função zeros() para criar uma matriz de zeros. Passe a forma da matriz necessária como uma tupla: np.zeros(shape) .

 array0 = np.zeros((3,3)) print(array0)

Aqui está a saída, uma matriz 2D de zeros:

 [[0. 0. 0.] [0. 0. 0.] [0. 0. 0.]]

Você pode acessar os atributos do array NumPy, chamar atributos como dtype e shape , usando a notação de ponto, conforme mostrado abaixo:

 print(array0.dtype) # float64 print(array0.shape) # (3, 3)

Para obter uma matriz de uns, você pode usar a função np.ones() .

 array1 = np.ones((3,3)) print(array1)

 [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]]

Criando uma Matriz de Identidade

A matriz identidade é amplamente utilizada em diversas aplicações em álgebra linear. E você pode usar a função np.eye() para criar uma matriz de identidade. A função np.eye() aceita apenas um argumento: a ordem da matriz ( n ).

 arrayi = np.eye(3) print(arrayi)

 [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]

Criando matrizes de números aleatórios

Você também pode criar matrizes de uma forma específica preenchida com números aleatórios extraídos de distribuições específicas. As distribuições de probabilidade comumente usadas são a distribuição uniforme e a distribuição normal padrão.

A função randn() , que faz parte do módulo random do NumPy, pode ser usada para gerar matrizes de números que são amostrados de uma distribuição normal padrão . A distribuição normal padrão é uma distribuição gaussiana com média zero e variância unitária.

 std_arr = np.random.randn(3,4) print(std_arr)

 [[-0.13604072 1.21884359 2.06850932 0.78212093] [ 0.44314719 -0.78084801 -0.70517138 1.17984949] [ 1.13214829 1.02339351 0.15317809 1.83191128]]

np.random.rand() retorna uma matriz de amostras de números de uma distribuição uniforme no intervalo [0,1).

 uniform_arr = np.random.rand(2,3) print(uniform_arr)

 [[0.90470384 0.18877441 0.10021817] [0.741 0.10657658 0.71334643]]

Você também pode criar uma matriz de números inteiros aleatórios usando a função randint() que faz parte do módulo aleatório do NumPy. np.random.randint(low, high, size) retorna uma matriz de inteiros. A forma da matriz é inferida a partir do argumento size e os inteiros assumem valores no intervalo [low,high) .

Aqui está um exemplo:

 int_arr = np.random.randint(1,100,(2,3)) print(int_arr)

 [[53 89 33] [24 85 33]]

Outras funções integradas úteis

Em seguida, vamos examinar algumas outras funções úteis para criar matrizes NumPy.

A função arange() retorna uma matriz de números entre um valor start e stop em etapas de um valor de step : start , start + step , start + 2*step up to, mas não incluindo stop . Os valores de start e step são opcionais . O tamanho do passo padrão é 1 e o valor inicial padrão é 0.

Neste exemplo, array_a é um array de números começando em 1 indo até, mas não incluindo 10 em passos de 0,5.

 array_a = np.arange(1,10,0.5) print(array_a)

 [1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5 8. 8.5 9. 9.5]

Você também pode criar arrays de números uniformemente espaçados usando np.linspace() . Use np.linspace(start, stop, num) para obter uma matriz de num números uniformemente espaçados entre os valores start e stop .

Aqui, arr_lin é uma matriz de 5 números igualmente espaçados no intervalo [1,10].

 array_lin = np.linspace(1,10,5) print(array_lin)

 [ 1. 3.25 5.5 7.75 10. ]

Da mesma forma, arr_lin2 é uma matriz de 10 números igualmente espaçados no intervalo [1,20].

 array_lin2 = np.linspace(1,20,10) print(array_lin2)

 [ 1. 3.11111111 5.22222222 7.33333333 9.44444444 11.55555556 13.66666667 15.77777778 17.88888889 20. ]

Ao contrário da função arange() , a função linspace() inclui o endpoint por padrão.

Operações básicas em matrizes NumPy

Em seguida, vamos examinar algumas das operações básicas nos arrays NumPy.

Encontrando os Elementos Mínimos e Máximos

Sempre que usarmos funções do módulo aleatório do NumPy para criar arrays, obteremos um resultado diferente cada vez que o código for executado. Para obter resultados reproduzíveis, devemos definir uma semente: np.random.seed(seed_value) .

No exemplo a seguir, defini a semente para reprodutibilidade, int_arr1 é uma matriz de sete números inteiros aleatórios no intervalo [1,100).

 np.random.seed(27) int_arr1 = np.random.randint(1,100,7) print(int_arr1) # [20 57 73 32 57 38 25]

• Para encontrar o elemento máximo no array, você pode chamar o método max() no objeto array, int_arr1 , e
• Para encontrar o elemento mínimo no array, você pode chamar o método min() no objeto array, int_arr1 .

 int_arr1.max() # 73 int_arr1.min() # 20

Encontrando o Índice dos Elementos Máximos e Mínimos

Às vezes, pode ser necessário encontrar o índice dos elementos máximo e mínimo. Para fazer isso, você pode chamar os argmax() e argmin() no objeto array.

Aqui, o elemento máximo 73 ocorre no índice 2.

 int_arr1.argmax() # 2

E o elemento mínimo 20 ocorre no índice 0.

 int_arr1.argmin() # 0

Você também pode usar np.argmax(array) e np.argmin(array) para encontrar os índices dos elementos máximo e mínimo, respectivamente. Saiba mais sobre a função NumPy argmax() .

Como concatenar matrizes NumPy

Outra operação comum que você pode querer fazer com arrays NumPy é a concatenação.

Concatenação vertical usando vstack

Você pode concatenar arrays verticalmente usando a função vstack() .

Aqui está um exemplo. arr1 é uma matriz de uns com duas linhas e três colunas e arr2 é uma matriz de zeros, duas linhas e três colunas.

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,3))

Podemos concatenar esses dois arrays verticalmente usando a função vstack() conforme mostrado:

 np.vstack((arr1,arr2))

 array([[1., 1., 1.], [1., 1., 1.], [0., 0., 0.], [0., 0., 0.]])

Como o empilhamento acontece verticalmente, os dois arrays devem ter o mesmo número de colunas .

Vamos mudar arr2 para ter a forma (2,2). Ele agora tem duas linhas e duas colunas.

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,2)) np.vstack((arr1,arr2))

Portanto, a concatenação vertical não é possível e obtemos um ValueError.

 --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-21-d5d3bf37fc21> in <module> ----> 1 np.vstack((arr1,arr2)) ValueError: all the input array dimensions for the concatenation axis must match exactly, but along dimension 1, the array at index 0 has size 3 and the array at index 1 has size 2

Concatenação horizontal usando hstack

Você pode concatenar matrizes NumPy horizontalmente usando a função hstack() , conforme mostrado abaixo.

 arr1 = np.ones((3,3)) arr2 = np.zeros((3,2))

 np.hstack((arr1,arr2))

Como o empilhamento ocorre horizontalmente, os arrays de entrada devem ter o mesmo número de linhas . Aqui, arr1 e arr2 têm três linhas.

 array([[1., 1., 1., 0., 0.], [1., 1., 1., 0., 0.], [1., 1., 1., 0., 0.]])

Usando concatenar

Você também pode usar matrizes NumPy concatenadas ao longo de um eixo específico usando a função concatenate() . Defina o argumento de axis opcional para o eixo que você gostaria de concatenar; o valor padrão do eixo é zero.

Aqui estão alguns exemplos:

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,3))

Quando não especificamos o eixo para concatenar, os arrays são concatenados ao longo do eixo 0. No array resultante, o segundo array arr2 é adicionado (como linhas) abaixo do primeiro array.

 np.concatenate((arr1,arr2))

 array([[1., 1., 1.], [1., 1., 1.], [0., 0., 0.], [0., 0., 0.]])

Quando especificamos axis = 1 , obtemos o seguinte resultado. arr2 é concatenado (como colunas) ao lado da primeira matriz, arr1 .

 np.concatenate((arr1,arr2),axis=1)

 array([[1., 1., 1., 0., 0., 0.], [1., 1., 1., 0., 0., 0.]])

Assim como nas hstack() e vstack() , as dimensões das matrizes ao longo do eixo de concatenação devem corresponder a .

Conclusão

Neste tutorial, você aprendeu as diferenças entre arrays NumPy e listas Python, com foco nas vantagens dos arrays N-dimensionais em termos de velocidade e eficiência.

Você também aprendeu várias funções úteis para criar arrays de uma dimensão específica e executar operações comuns, como encontrar o mínimo e o máximo de elementos, concatenar arrays e muito mais.

Em seguida, aprenda como remodelar arrays NumPy.