1 - Introdução ao Numpy

A string da versão é armazenada no __version__ atributo.

import numpy as np

print(np.__version__)

1.26.1

Dimensões em matrizes são os seus níveis de profundidade (matrizes aninhadas).

Matrizes aninhadas são aquelas que possuem outras matrizes como seus elementos.

Matrizes 0-D

Matrizes 0-D, ou escalares, são os elementos em uma matriz. Cada valor em uma matriz é uma matriz 0-D.

Crie uma matriz 0-D com valor 42

import numpy as np

matriz = np.array(42)

print(matriz)

42

Matrizes 1-D

Uma matriz que tem matrizes 0-D como seus elementos é chamado de matriz unidimensional ou 1-D.

Esses são as matrizes mais comuns e básicos.

Crie uma matriz 1-D contendo os valores 1,2,3,4,5:

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

[1 2 3 4 5]

Matrizes 2-D

Uma matriz que tem matrizes 1-D como seus elementos é chamado de matriz 2-D.

Estes são frequentemente usados ​​para representar matrizes ou tensores de 2ª ordem.

O Numpy tem um submódulo inteiro dedicado a operações de matriz chamado numpy.mat

Crie uma matriz 2-D contendo dois matrizes com os valores 1,2,3 e 4,5,6:

import numpy as np
matriz = np.array([[1, 2, 3], [4, 5, 6]])
print(matriz)

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

Matrizes 3-D

Uma matriz que tem matrizes 2-D (matrizes) como seus elementos é chamado de matriz 3-D.

Estes são frequentemente usados ​​para representar um tensor de 3ª ordem.

Crie uma matriz 3D com dois matrizes 2D, ambos contendo dois matrizes com os valores 1,2,3 e 4,5,6.

import numpy as np

matriz = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])

print(matriz)

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

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

Número de dimensões

Matrizes Numpy fornecem o atributo ndim que retorna um inteiro que nos diz quantas dimensões o matriz possui.

Verifique quantas dimensões as matrizes têm.

import numpy as np

a = np.array(42)
b = np.array([1, 2, 3, 4, 5])
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])

print(a.ndim)
print(b.ndim)
print(c.ndim)
print(d.ndim)

0
1
2
3

Dimensão desconhecida

Você tem permissão para ter uma dimensão "desconhecida".

Isso significa que você não precisa especificar um número exato para uma das dimensões no método de remodelação.

Passe -1 como o valor e o Numpy calculará esse número para você.

Converter matriz 1D com 8 elementos para matriz 3D com 2x2 elementos:

import numpy as np

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

nova_matriz = matriz.reshape(2, 2, -1)

print(nova_matriz)

[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]

Nota: Não podemos passar -1 para mais de uma dimensão.

Matrizes Dimensionais Superiores

Uma matriz pode ter qualquer número de dimensões.

Quando a matriz é criada, você pode definir o número de dimensões usando o argumento ndmin.

Crie uma matriz com 5 dimensões e verifique se ela possui 5 dimensões:

import numpy as np

matriz = np.array([1, 2, 3, 4], ndmin=5)

print(matriz)
print('Número de dimensões:', matriz.ndim)

[[[[[1 2 3 4]]]]]
Número de dimensões: 5

Nesta matriz a dimensão mais interna (5º dim) tem 4 elementos, o 4º dim tem 1 elemento que é o vetor, o 3º dim tem 1 elemento que é a matriz com o vetor, o 2º dim tem 1 elemento que é matriz 3D e 1st dim tem 1 elemento que é uma matriz 4D.

A indexação de matriz é o mesmo que acessar um elemento de matriz.

Você pode acessar um elemento de matriz referindo-se ao seu número de índice.

Os índices nas matrizes Numpy começam com 0, o que significa que o primeiro elemento tem índice 0 e o segundo tem índice 1 etc.

Obtenha o primeiro elemento da seguinte matriz:

import numpy as np

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

print(matriz[0])

1

Obtenha o segundo elemento da matriz a seguir.

import numpy as np

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

print(matriz[1])

2

Obtenha o terceiro e o quarto elementos da matriz a seguir e adicione-os.

import numpy as np

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

print(matriz[2] + matriz[3])

7

Indexação negativa

Use a indexação negativa para acessar uma matriz a partir do final.

Imprima o último elemento da segunda dimensão:

import numpy as np

matriz = np.array([[1,2,3,4,5], [6,7,8,9,10]])

print('Last element from 2nd dim: ', matriz[1, -1])

Last element from 2nd dim:  10

Para acessar elementos de matrizes 2-D podemos usar inteiros separados por vírgulas representando a dimensão e o índice do elemento.

Pense em matrizes 2D como uma tabela com linhas e colunas, onde a linha representa a dimensão e o índice representa a coluna.

Acesse o elemento na primeira linha, segunda coluna:

import numpy as np

matriz = np.array([[1,2,3,4,5], [6,7,8,9,10]])

print('Segundo elemento na primeira linha: ', matriz[0, 1])

Segundo elemento na primeira linha:  2

Acesse o elemento na 2ª linha, 5ª coluna:

import numpy as np

matriz = np.array([[1,2,3,4,5], [6,7,8,9,10]])

print('Quinto elento d segunda linha: ', matriz[1, 4])

Quinto elento d segunda linha:  10

Acesse o terceiro elemento do segundo matriz do primeiro matriz:

import numpy as np

matriz = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

val = matriz[0, 1, 2]
print(f"Valor e tipo: {val}: {type(val)}")

Valor e tipo: 6: <class 'numpy.int32'>

import numpy as np

matriz = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

val = matriz[0, 1, 2]
print(f"Valor e tipo: {val}: {type(val)}")

Valor e tipo: 6: <class 'numpy.int32'>

Explicação: matriz[0, 1, 2] imprime o valor 6.

• O primeiro número representa a primeira dimensão, que contém duas matrizes: [[1, 2, 3], [4, 5, 6]] e [[7, 8, 9], [10, 11, 12]]. Selecionamos o índice 0, ficamos com a matriz na posição: [[1, 2, 3], [4, 5, 6]].
• O segundo número representa a segunda dimensão, que uma matriz: [[1, 2, 3], [4, 5, 6]]. Como selecionamos 1, ficamos com o valor da posição do índice 1: [4, 5, 6].
• O terceiro número representa a terceira dimensão, que uma matriz: [4, 5, 6]. Como selecionamos 2, ficamos com o valor da posição do índice 2: 6.

Fatiar em python significa levar elementos de um determinado índice para outro determinado índice.

Passamos slice em vez de index assim: .[start:end]

Também podemos definir o passo, assim: .[start:end:step]

Se não passarmos start é considerado 0

Se não passarmos o comprimento considerado da matriz nessa dimensão

Se não passarmos o passo é considerado 1

Fatie os elementos do índice 1 ao índice 5 da seguinte matriz:

import numpy as np

matriz = np.array([1, 2, 3, 4, 5, 6, 7])

print(matriz[1:5])

[2 3 4 5]

Nota: O resultado inclui o índice inicial, mas exclui o índice final.

Fatie os elementos do índice 4 até o final da matriz:

import numpy as np

matriz = np.array([1, 2, 3, 4, 5, 6, 7])

print(matriz[4:])

[5 6 7]

Fatiar elementos do início ao índice 4 (não incluído):

import numpy as np

matriz = np.array([1, 2, 3, 4, 5, 6, 7])

print(matriz[:4])

[1 2 3 4]

Como mencionado acima, as cópias são proprietárias dos dados e as visualizações não possuem os dados, mas como podemos verificar isso?

Todo matriz Numpy tem o atributo base que retorna None se o matriz possui os dados.

Caso contrário, o base atributo se refere ao objeto original.

Imprima o valor do atributo base para verificar se uma matriz possui seus dados ou não:

import numpy as np

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

x = matriz.copy()
y = matriz.view()

print(x.base)
print(y.base)

None
[1 2 3 4 5]

A cópia retorna None.

A exibição retorna a matriz original.

A principal diferença entre uma cópia e uma visão de uma matriz é que a cópia é uma novo matriz, e a visão é apenas uma visão da matriz original.

A cópia possui os dados e quaisquer alterações feitas na cópia não afetarão a matriz original, e quaisquer alterações feitas na matriz original não afetarão a cópia.

A exibição não possui os dados e quaisquer alterações feitas na exibição afetarão a matriz original, e quaisquer alterações feitas na matriz original afetarão a exibição.

No caso da cópia de uma variável de matriz em outra, alterações na matriz de uma das variáveis não reflete na matriz da outra variável.

import numpy as np

matriz = np.array([1, 2, 3, 4, 5])
x = matriz.copy()
matriz[0] = 42

print(matriz)
print(x)

[42  2  3  4  5]
[1 2 3 4 5]

No caso da atribuição simples de uma variável de matriz em outra, alterações na matriz de uma das variáveis refletem em ambas variáveis.

import numpy as np

matriz = np.array([1, 2, 3, 4, 5])
x = matriz.view()
matriz[0] = 42

print(matriz)
print(x)

[42  2  3  4  5]
[42  2  3  4  5]

Agora realizando alterações na variável atribuida.

import numpy as np

matriz = np.array([1, 2, 3, 4, 5])
x = matriz.view()
x[0] = 31

print(matriz)
print(x)

[31  2  3  4  5]
[31  2  3  4  5]

A forma de uma matriz é o número de elementos em cada dimensão.

Obteção da forma de uma matriz

As matrizes Numpy têm um atributo chamado shape que retorna uma tupla com cada índice com o número de elementos correspondentes.

Imprima a forma de uma matriz 2-D:

import numpy as np

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

print(matriz.shape)

(2, 4)

O exemplo acima retorna (2, 4), o que significa que o matriz tem 2 dimensões, onde a primeira dimensão tem 2 elementos e a segunda tem 4.

Crie uma matriz com 5 dimensões usando ndminum vetor com valores 1,2,3,4 e verifique se a última dimensão tem valor 4.

import numpy as np

matriz = np.array([1, 2, 3, 4], ndmin=5)

print(matriz)
print('forma da matriz:', matriz.shape)

[[[[[1 2 3 4]]]]]
forma da matriz: (1, 1, 1, 1, 4)

O que a tupla de forma representa?

Os inteiros em cada índice informam sobre o número de elementos que a dimensão correspondente possui.

No exemplo acima em no índice -4 temos o valor 4, então podemos dizer que a 5ª (4 + 1ª) dimensão possui 4 elementos.

Remodelar significa mudar a forma de uma matriz.

A forma de uma matriz é o número de elementos em cada dimensão.

Ao remodelar, podemos adicionar ou remover dimensões ou alterar o número de elementos em cada dimensão.

Remodelagem de 1-D para 2-D

Converta o seguinte matriz 1-D com 12 elementos em uma matriz 2-D.

A dimensão mais externa terá 4 matrizes, cada um com 3 elementos:

import numpy as np

matriz = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

nova_matriz = matriz.reshape(4, 3)

print(nova_matriz)

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

Remodelagem de 1-D para 3-D

Converta o seguinte matriz 1-D com 12 elementos em uma matriz 3-D.

A dimensão mais externa terá 2 matrizes que contém 3 matrizes, cada um com 2 elementos:

import numpy as np
matriz = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
nova_matriz = matriz.reshape(2, 3, 2)
print(nova_matriz)

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

 [[ 7  8]
  [ 9 10]
  [11 12]]]

Podemos remodelar em qualquer forma?

Sim, desde que os elementos necessários para a remodelação sejam iguais em ambas as formas.

Podemos remodelar uma matriz 1D de 8 elementos em 4 elementos em uma matriz 2D de 2 linhas, mas não podemos reformulá-la em uma matriz 2D de 3 elementos e 3 linhas, pois isso exigiria 3x3 = 9 elementos.

Tente converter uma matriz 1D com 8 elementos para uma matriz 2D com 3 elementos em cada dimensão (irá gerar um erro).

import numpy as np

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

nova_matriz = matriz.reshape(3, 3)

print(nova_matriz)

ValueError: cannot reshape array of size 8 into shape (3,3) <traceback object at 0x0000018D3C86D240>

Achatamento de matrizes

O achatamento de matriz significa converter uma matriz multidimensional em uma matriz 1D.

Podemos usar reshape(-1)para fazer isso.

Converta a matriz em uma matriz 1D:

import numpy as np

matriz = np.array([[1, 2, 3], [4, 5, 6]])

nova_matriz = matriz.reshape(-1)

print(nova_matriz)

[1 2 3 4 5 6]

Nota: Existem muitas funções para alterar as formas de matrizes em numpy flatten, ravele também para reorganizar os elementos rot90, flip, fliplr, flipudetc. Elas se enquadram na seção Intermediário a Avançado de numpy.

Visualizar ou copiar

Verifique se a matriz retornada é uma cópia ou uma visualização:

import numpy as np

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

print(matriz.reshape(2, 4).base)

[1 2 3 4 5 6 7 8]

O exemplo acima retorna o matriz original, então é uma view.

Iterar significa passar pelos elementos um por um.

Como lidamos com matrizes multidimensionais em numpy, podemos fazer isso usando o laço for básico de python.

Se iterarmos em uma matriz 1-D, ele passará por cada elemento um por um.

Itere nos elementos da seguinte matriz 1-D:

import numpy as np

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

for x in matriz:
    print(x)

1
2
3

Iterando matrizes 2-D

Em uma matriz 2-D, ele passará por todas as linhas.

Itere nos elementos da seguinte matriz 2-D:

import numpy as np

matriz = np.array([[1, 2, 3], [4, 5, 6]])

for x in matriz:
    print(x)

[1 2 3]
[4 5 6]

Se iterarmos em uma matriz n -D, ele passará pela n-1ª dimensão um por um.

Para retornar os valores reais, os escalares, temos que iterar as matrizes em cada dimensão.

Itere em cada elemento escalar da matriz 2-D:

import numpy as np

matriz = np.array([[1, 2, 3], [4, 5, 6]])

for x in matriz:
    for y in x:
        print(y)

1
2
3
4
5
6

Iterando matrizes 3D

Em uma matriz 3D, ele passará por todas as matrizes 2D.

Itere nos elementos da seguinte matriz 3D.

import numpy as np
matriz = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
for x in matriz:
    print(x)

[[1 2 3]
 [4 5 6]]
[[ 7  8  9]
 [10 11 12]]

Para retornar os valores reais, os escalares, temos que iterar as matrizes em cada dimensão.

Iterar até os escalares:

matriz = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

for x in matriz:
    for y in x:
        for z in y:
            print(z)

1
2
3
4
5
6
7
8
9
10
11
12

Iterando matrizes usando nditer()

A função nditer() ajuda de iterações muito básicas a muito avançadas. Ele resolve alguns problemas básicos que enfrentamos na iteração, vamos passar por isso com exemplos.

Iterando em cada elemento escalar

Em forloops básicos, iterando através de cada escalar de uma matriz, precisamos usar n for loops que podem ser difíceis de escrever para matrizes com dimensionalidade muito alta.

Itere através da seguinte matriz 3D:

import numpy as np
matriz = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
for x in np.nditer(matriz): print(x)

1
2
3
4
5
6
7
8

Iteração com diferentes tipos de dados

Podemos usar o argumento p_dtypes e passar o tipo de dados esperado para alterar o tipo de dados dos elementos durante a iteração.

O Numpy não altera o tipo de dados do elemento no local (onde o elemento está no matriz), portanto, ele precisa de algum outro espaço para executar essa ação, esse espaço extra é chamado de buffer e, para habilitá-lo nditer(), passamos flags=['buffered'].

Iterar através da matriz como um texto.

import numpy as np

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

for x in np.nditer(matriz, flags=['buffered'], op_dtypes=['S']):
    print(x)

b'1'
b'2'
b'3'

Iterando com tamanho de etapa diferente

Podemos usar filtragem e seguido de iteração.

Itere através de cada elemento escalar da matriz 2D pulando 1 elemento:

import numpy as np

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

for x in np.nditer(matriz[:, ::2]): print(x)

1
3
5
7

Iteração enumerada usando ndenumerate()

Enumeração significa mencionar o número de sequência de algumas coisas uma a uma.

Às vezes, exigimos o índice correspondente do elemento durante a iteração, o ndenumerate()método pode ser usado para esses casos de uso.

Enumere os seguintes elementos de matrizes 1D:

import numpy as np
matriz = np.array([1, 2, 3])
for idx, x in np.ndenumerate(matriz): print(idx, x)

(0,) 1
(1,) 2
(2,) 3

Enumere os seguintes elementos da matriz 2D:

import numpy as np
matriz = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
for idx, x in np.ndenumerate(matriz):
    print(idx, x)

(0, 0) 1
(0, 1) 2
(0, 2) 3
(0, 3) 4
(1, 0) 5
(1, 1) 6
(1, 2) 7
(1, 3) 8

Unir significa colocar o conteúdo de duas ou mais matrizes em uma única matriz.

No SQL, unimos tabelas com base em uma chave, enquanto no Numpy unimos matrizes por eixos.

Passamos uma sequência de matrizes que queremos unir à concatenate()função, junto com o eixo. Se o eixo não for explicitamente passado, será considerado 0.

Junte duas matrizes.

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
matriz = np.concatenate((arr1, arr2))
print(matriz)

[1 2 3 4 5 6]

Junte duas matrizes 2-D ao longo das linhas (eixo = 1).

import numpy as np
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
matriz = np.concatenate((arr1, arr2), axis=1)
print(matriz)

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

União de matrizes usando funções de pilha

O empilhamento é o mesmo que a concatenação, a única diferença é que o empilhamento é feito ao longo de um novo eixo.

Podemos concatenar dois matrizes 1-D ao longo do segundo eixo, o que resultaria em colocá-los um sobre o outro, ou seja. empilhamento.

Passamos uma sequência de matrizes que queremos unir ao stack()método junto com o eixo. Se o eixo não for explicitamente passado, será considerado 0.

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
matriz = np.stack((arr1, arr2), axis=1)
print(matriz)

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

Empilhamento de matrizes Numpy

O Numpy permite o empilhamento de matrizes ao longo das linhas e ao longo das colunas.

Empilhamento ao longo das linhas

O Numpy fornece uma função auxiliar: hstack() empilhar ao longo das linhas.

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
matriz = np.hstack((arr1, arr2))
print(matriz)

[1 2 3 4 5 6]

Empilhamento ao longo das colunas

Numpy fornece a função auxiliar vstack() para o empilhamento ao longo de colunas.

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
matriz = np.vstack((arr1, arr2))
print(matriz)

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

Empilhamento ao longo da altura (profundidade)

Numpy fornece a função auxiliar Mi>dstack() para empilhamento ao longo da altura, que é o mesmo que profundidade.

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
matriz = np.dstack((arr1, arr2))
print(matriz)

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

A divisão é a operação inversa da junção.

A junção mescla vários matrizes em um e a divisão quebra uma matriz em vários.

Usamos o método array_split() para dividir matrizes, passamos o matriz que queremos dividir e o número de divisões.

Divisão da matriz em 3 partes.

import numpy as np
matriz = np.array([1, 2, 3, 4, 5, 6])
nova_matriz = np.array_split(matriz, 3)
print(nova_matriz)

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

Nota: O valor de retorno é uma matriz contendo três matrizes.

Se a matriz tiver menos elementos do que o necessário, ela será ajustada do final de acordo.

Divisão da matriz em 4 partes.

import numpy as np
matriz = np.array([1, 2, 3, 4, 5, 6])
nova_matriz = np.array_split(matriz, 4)
print(nova_matriz)

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

Nota: Também temos o método split() disponível, mas ele não ajustará os elementos quando os elementos estiverem menos na matriz de origem para divisão como no exemplo acima, array_split() funcionou corretamente, mas split() falharia.

Dividir em matrizes

O valor de retorno do método array_split() é uma matriz contendo cada divisão como uma matriz.

Se você dividir uma matriz em 3 matrizes, poderá acessá-los a partir do resultado como qualquer elemento da matriz:

Acesso às matrizes divididas.

import numpy as np
matriz = np.array([1, 2, 3, 4, 5, 6])
nova_matriz = np.array_split(matriz, 3)
print(nova_matriz[0])
print(nova_matriz[1])
print(nova_matriz[2])

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

Dividindo Arrays 2D

Use a mesma sintaxe ao dividir matrizes 2D.

Use o método array_split(), passe o matriz que deseja dividir e o número de divisões que deseja fazer.

Divida a matriz 2-D em três matrizes 2-D.

import numpy as np
matriz = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]])
nova_matriz = np.array_split(matriz, 3)
print(nova_matriz)

[array([[1, 2],
       [3, 4]]), array([[5, 6],
       [7, 8]]), array([[ 9, 10],
       [11, 12]])]

O exemplo acima retorna três matrizes 2-D.

Vejamos outro exemplo, desta vez cada elemento nas matrizes 2-D contém 3 elementos.

Divida a matriz 2-D em três matrizes 2-D.

import numpy as np
matriz = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])
nova_matriz = np.array_split(matriz, 3)
print(nova_matriz)

[array([[1, 2, 3],
       [4, 5, 6]]), array([[ 7,  8,  9],
       [10, 11, 12]]), array([[13, 14, 15],
       [16, 17, 18]])]

O exemplo acima retorna três matrizes 2-D.

Além disso, você pode especificar em qual eixo deseja fazer a divisão.

O exemplo abaixo também retorna três matrizes 2-D, mas elas são divididas ao longo da linha (eixo=1).

Divida a matriz 2-D em três matrizes 2-D ao longo das linhas.

import numpy as np
matriz = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])
nova_matriz = np.array_split(matriz, 3, axis=1)
print(nova_matriz)

[array([[ 1],
       [ 4],
       [ 7],
       [10],
       [13],
       [16]]), array([[ 2],
       [ 5],
       [ 8],
       [11],
       [14],
       [17]]), array([[ 3],
       [ 6],
       [ 9],
       [12],
       [15],
       [18]])]

Uma solução alternativa é usar o método hsplit() com resultado oposto do método hstack().

Use o hsplit()método para dividir a matriz 2D em três matrizes 2D ao longo das linhas.

import numpy as np
matriz = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])
nova_matriz = np.hsplit(matriz, 3)
print(nova_matriz)

[array([[ 1],
       [ 4],
       [ 7],
       [10],
       [13],
       [16]]), array([[ 2],
       [ 5],
       [ 8],
       [11],
       [14],
       [17]]), array([[ 3],
       [ 6],
       [ 9],
       [12],
       [15],
       [18]])]

Você pode pesquisar um determinado valor em uma matriz e retornar os índices que obtêm uma correspondência.

Para pesquisar uma matriz, use o método where().

Encontre os índices onde o valor é 4.

import numpy as np
matriz = np.array([1, 2, 3, 4, 5, 4, 4])
x = np.where(matriz == 4)
print(x)

(array([3, 5, 6], dtype=int64),)

O exemplo acima retornará uma a tupla array([3, 5, 6],).

O que significa que o valor 4 está presente nos índices 3, 5 e 6.

Encontre os índices onde os valores são pares.

import numpy as np
matriz = np.array([1, 2, 3, 4, 5, 6, 7, 8])
x = np.where(matriz%2 == 0)
print(x)

(array([1, 3, 5, 7], dtype=int64),)

Encontre os índices onde os valores são ímpares.

import numpy as np
matriz = np.array([1, 2, 3, 4, 5, 6, 7, 8])
x = np.where(matriz%2 == 1)
print(x)

(array([0, 2, 4, 6], dtype=int64),)

Pesquisa classificada

Existe um método chamado searchsorted() que realiza uma busca binária no matriz, e retorna o índice onde o valor especificado seria inserido para manter a ordem de busca.

Supõe-se que o método searchsorted() seja usado em matrizes classificadas.

Encontre os índices onde o valor 7 deve ser inserido.

import numpy as np
matriz = np.array([6, 7, 8, 9])
x = np.searchsorted(matriz, 7)
print(x)

1

exemplo explicado:

O número 7 deve ser inserido no índice 1 para manter a ordem de classificação.

O método inicia a pesquisa pela esquerda e retorna o primeiro índice onde o número 7 não é maior que o próximo valor.

Pesquisar do lado direito

Por padrão, o índice mais à esquerda é retornado, mas podemos side='right'retornar o índice mais à direita.

Encontre os índices onde deve ser inserido o valor 7, começando pela direita.

import numpy as np
matriz = np.array([6, 7, 8, 9])
x = np.searchsorted(matriz, 7, side='right')
print(x)

2

exemplo explicado:

O número 7 deve ser inserido no índice 2 para manter a ordem de classificação.

O método inicia a busca pela direita e retorna o primeiro índice onde o número 7 não é mais menor que o próximo valor.

Vários valores

Para pesquisar mais de um valor, use uma matriz com os valores especificados.

Encontre os índices onde os valores 2, 4 e 6 devem ser inseridos.

import numpy as np
matriz = np.array([1, 3, 5, 7])
x = np.searchsorted(matriz, [2, 4, 6])
print(x)

[1 2 3]

O valor de retorno é uma matriz: [1 2 3]contendo os três índices onde 2, 4, 6 seriam inseridos no matriz original para manter a ordem.

Ordenar significa colocar elementos em uma seqüência ordenada.

Sequência ordenada é qualquer sequência que tenha uma ordem correspondente aos elementos, como numérico ou alfabético, ascendente ou descendente.

O objeto Numpy ndarray tem o método sort() para ordenação especificada de uma matriz.

Classifique a matriz.

import numpy as np
matriz = np.array([3, 2, 0, 1])
print(matriz)
print(np.sort(matriz))

[3 2 0 1]
[0 1 2 3]

Nota: Este método retorna uma cópia da matriz, deixando o matriz original inalterada.

Você também pode classificar matrizes de textos ou qualquer outro tipo de dados.

Classifique a matriz em ordem alfabética.

import numpy as np
matriz = np.array(['banana', 'cherry', 'maçã'])
print(np.sort(matriz))

['banana' 'cherry' 'maçã']

Classifique uma matriz booleano.

import numpy as np
matriz = np.array([True, False, True])
print(np.sort(matriz))

[False  True  True]

Classificação de matriz 2D

Se você usar o método sort() em uma matriz 2-D, ambas as matrizes serão classificadas:

Classifique uma matriz 2D.

import numpy as np
matriz = np.array([[3, 2, 4], [5, 0, 1]])
print(np.sort(matriz))

[[2 3 4]
 [0 1 5]]

Obter alguns elementos de uma matriz existente e criar um novo matriz a partir deles é chamado de filtragem .

No Numpy, você filtra uma matriz usando uma lista de índices booleanos.

Uma lista de índices booleanos é uma lista de booleanos correspondentes aos índices na matriz.

Se o valor em um índice for Trueesse elemento contido na matriz filtrada, se o valor nesse índice for Falseesse elemento será excluído da matriz filtrada.

Crie uma matriz dos elementos no índice 0 e 2:

import numpy as np
matriz = np.array([41, 42, 43, 44])
x = [True, False, True, False]
nova_matriz = matriz[x]
print(nova_matriz)

[41 43]

O exemplo acima retornará [41, 43], por quê?

Porque o novo filtro contém apenas os valores onde a matriz de filtros tinha o valor True, neste caso, índice 0 e 2.

Criando de filtros de matriz

No exemplo acima, codificamos os valores True e False, mas o uso comum é criar uma matriz de filtro com base nas condições.

Crie uma matriz de filtros que retornará apenas valores superiores a 42.

import numpy as np
matriz = np.array([41, 42, 43, 44])
# Criação de listas vazias
matriz_filtrada = []
# Percorrer os elementos da matriz
for element in matriz:
    # se o elemento for maior que 42, defina o valor como True, caso contrário, False:
    if element > 42:
        matriz_filtrada.append(True)
    else:
        matriz_filtrada.append(False)
nova_matriz = matriz[matriz_filtrada]
print(matriz_filtrada)
print(nova_matriz)

[False, False, True, True]
[43 44]

Crie uma matriz de filtro que retornará apenas elementos pares da matriz original:

import numpy as np
matriz = np.array([1, 2, 3, 4, 5, 6, 7])
# Criar uma lista vazia
matriz_filtrada = []
# go through each element in matriz
for element in matriz:
    # se o elemento for completamente divisível por 2, defina o valor como verdadeiro, caso contrário, falso
    if element % 2 == 0:
        matriz_filtrada.append(True)
    else:
       matriz_filtrada.append(False)
nova_matriz = matriz[matriz_filtrada]
print(matriz_filtrada)
print(nova_matriz)

[False, True, False, True, False, True, False]
[2 4 6]

Criando filtro diretamente da matriz

O exemplo acima é uma tarefa bastante comum no Numpy e o Numpy fornece uma boa maneira de lidar com isso.

Podemos substituir diretamente a matriz em vez da variável iterável em nossa condição e ela funcionará exatamente como esperamos.

Crie uma matriz de filtros que retornará apenas valores superiores a 42:

import numpy as np
matriz = np.array([41, 42, 43, 44])
matriz_filtrada = matriz > 42
nova_matriz = matriz[matriz_filtrada]
print(matriz_filtrada)
print(nova_matriz)

[False False  True  True]
[43 44]

Crie uma matriz de filtro que retornará apenas elementos pares da matriz original:

import numpy as np
matriz = np.array([1, 2, 3, 4, 5, 6, 7])
matriz_filtrada = matriz % 2 == 0
nova_matriz = matriz[matriz_filtrada]
print(matriz_filtrada)
print(nova_matriz)

[False  True False  True False  True False]
[2 4 6]