No tutorial passado, aprendemos como acessar elementos, através da linha e da coluna, de um vetor unidimensional ou multidimensional. Agora, vamos aprender como selecionar intervalos dos arrays.
Essas técnicas de seleção, são de vital importância para filtrar dados. Imagine que você tenha um banco de dados com milhões de dados de pessoas, com linhas e colunas informando nome, idade, data de nascimento, local onde reside etc, e você vai querer filtrar apenas algumas coisas, como idade e profissão, então vai precisar fatiar essa matriz de informações. Isso já é Data Science.
Slicing Arrays - Fatiando e Selecionando Intervalos :
Vimos que através dos índices (index) selecionamos elementos específicos de um array, que podem simplesmente ser um número inteiro contado a partir o 0 para arrays unidimensional ou através de [linha][coluna] para acessar qualquer elemento de uma matriz de duas dimensões.
Porém, é muito comum querermos não apenas um elemento, mas uma faixa de elementos do array. Ou seja, temos que fatiar (slice) os vetores para obtermos apenas alguns dados específicos, e para isso vamos usar o operador de símbolo dois pontos :
Basicamente, vamos escrever inicio : fim, para selecionar os elementos de índice inicio até fim-1
Mais uma vez, lembre-se: a contagem de arrays começa no índice 0.
Slice de arrays unidimensionais
Suponha que temos um array de 10 elementos, do 0 até o 9.
Se quisermos selecionar os quatro primeiros, fazemos: 0:4 -
import numpy as np arr = np.array( [0,1,2,3,4,5,6,7,8,9]) print(arr[0:4])
Veja que ele pegou os elementos arr[0], arr[1], arr[2] e arr[3].
Agora, queremos fatiar do índice 5 até o 8:
print(arr[5:8])
Note que 8-5=3, logo, ele vai imprimir 3 elementos a partir do elemento de índice 5, que são os elementos: arr[5], arr[6] e arr[7].
Podemos, inclusive, selecionar o 'pulo' de elementos (step), dentro de cada intervalo dessas fatias. Quando fazemos m:n estamos fazendo, na verdade, m:n:1, pois estamos imprimindo de 1 em 1.
O código abaixo, usando m:n:2 percorre todos os elementos do array, mas pulando de 2 em 2:
import numpy as np arr = np.array( [0,1,2,3,4,5,6,7,8,9]) print(arr[0:10:2])
Se quiser exibir todos os elementos de um array, deixe em branco os índices do slicing, basta fazer: arr[:]
Pois ele entende que é do primeiro até o último índice. Isso valo se você preencher apenas o início ou fim. Por exemplo, para imprimir do primeiro índice até 5, faça: arr[:6]
Já para fatiar o array do índice 5 até o final, faça: arr[5:]
Rode cada um dos códigos e exemplos acima, para ver o resultado.
Slice e Index ao contrário, do final do array
Veja que esses fatiamentos foram sempre do começo para o fim do array. Mas também é possível fazer isso do final para o começo, bastante usar como index os números inteiros negativos. Por exemplo:
arr[-1] - último elemento do array
arr[inicio:-1] - fatia do índice inicio até o último
arr[1:-1] - quebra a partir do segundo elemento (índice 1) até o último (que é o de índice -1)
arr[ : : -1] - exibe todos os elementos mas do final pro começo, de 1 em 1
Questão: Como exibir todos os elementos de um array, do final para o início, de dois em dois?
Slicing e Indexing em arrays multidimensionais
Podemos, também, fatiar matrizes, ou seja, arrays de mais de uma dimensões. Agora, precisamos trabalhar com as linhas e colunas. Geralmente vamos precisar extrair determinadas linhas ou colunas de uma matriz, através do slicing e indexing.
Seja a matriz arr 3x3:
[1,2,3],
[4,5,6],
[7,8,9]
Para lidar com duas dimensões, vamos precisar usar o símbolo de slice : duas vezes, uma para as linhas e outro para as colunas, e vamos separar os fatiamentos por vírgula. Por exemplo, para exibir todos os elementos da matriz, fazemos:
arr[: , :]
Se quisermos, por exemplo, exibir a primeira coluna:
arr[: , 0]
Você pode interpretar a primeira parte, antes da vírgula como "todos os elementos da linha", e o segundo elemento, depois da linha, como o índice da coluna. Ou seja, todos os elementos das linhas (:), mas que estejam na primeira coluna (0).
Agora, para fatiar e extrair apenas a segunda linha da matriz:
arr[1 , :]
Agora vamos extrair uma submatriz, composta pelos dois primeiros elementos, da linha 1 e linha 2, das colunas 1 e 2:
arr[:2 , :2]
Cujo resultado é:
[1,2]
[4,5]
Agora vamos extrair somente a primeira e terceira linhas:
arr[ [0,2] , :]
Já a primeira e terceira coluna:
arr[ : , [0,2] ]
Rode o exemplo abaixo, agora com uma matriz maior, 5x5:
import numpy as np arr = np.array([ [11,12,13,14,15], [21,22,23,24,25], [31,32,33,34,35], [41,42,43,44,45], [51,52,53,54,55]]) print("Todos:\n" ,arr[: , :]) print("Primeira coluna:\n", arr[:, 0]) print("Segunda linha:\n", arr[1, :]) print("Sub-matriz 3x3:\n", arr[:3, :3]) print("Primeira e última linha:\n", arr[[0,4], :]) print("Primeira e última coluna:\n", arr[:, [0,4]])
Deixando bem claro que neste tutorial dissemos como exibir tais informações, porém podemos usar os mesmos códigos para atribuir valores esses arrays que determinamos ou também podemos pegar esses slices e salvar como outro array e trabalhar com eles, deixando o original intocado.
Nenhum comentário:
Postar um comentário