Agora que já aprendemos a criar os mais diversos tipos de arrays e matrizes, bem como inicializar com vários tipos de valores, vamos aprender o famoso indexing and slicing, em nosso curso de Programação Científica em Python.
Ou seja, vamos ver como acessar e modificar diretamente cada elemento de um array, como selecionar apenas uma parte dele, como dividir em array menores e outras funcionalidades interessantes, que vão facilitar muito nossa vida, principalmente no estudo da análise de dados.
Como acessar elementos de Arrays de uma dimensão
Vamos criar um array de uma dimensão, de 10 elementos. Vejamos o código:
import numpy as np
MeuArray = np.arange(10)
MeuArray
Saída:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
Agora, aprenda essa regra:
Em programação, sempre começamos a contar do 0. Não começamos do 1, ok?
Logo, para acessarmos o primeiro elemento, basta escrevermos o nome do array, seguido do parte de colchetes, e dentro destes o índice que você deseja.
Para selecionar o primeiro elemento do array, faça: MeuArray[0]
Para selecionar o segundo elemento do array, faça: MeuArray[1]
Para selecionar o terceiro elemento do array, faça: MeuArray[2]
...
Para selecionar o último elemento do array, faça: MeuArray[10]
Teste o código:
import numpy as np
MeuArray = np.linspace(0,1,11)
for i in range(len(MeuArray)):
print("Elemento [",i,"]: ", MeuArray[i])
Saída:
Elemento [ 0 ]: 0.0
Elemento [ 1 ]: 0.1
Elemento [ 2 ]: 0.2
Elemento [ 3 ]: 0.3
Elemento [ 4 ]: 0.4
Elemento [ 5 ]: 0.5
Elemento [ 6 ]: 0.6
Elemento [ 7 ]: 0.7
Elemento [ 8 ]: 0.8
Elemento [ 9 ]: 0.9
Elemento [ 10 ]: 1.0
Nele, fizemos o seguinte: chamamos a função linspace(), pedindo para criar um array com elementos de 0 até 1, igualmente espaçados em 11 blocos.
Ou seja, o array terá 11 elementos. Para acessar cada um deles, vamos do índice 0 até o índice 10. Onde o primeiro elemento é representado pela variável MeuArray[0] e o último pela variável float MeuArray[10], pois os arrays criados pela linspace são do tipo float.
Resumindo: se seu vetor Vect tem n elementos, o primeiro é o Vect[0] e o último é o Vect[n-1]
Como acessar elementos de Matrizes (arrays 2D)
Usamos apenas um índice para acessar elementos de um array unidimensional pois...ele tem apenas uma dimensão (a primeira linha). Já em uma matriz, vamos precisar fornecer dois índices (indexes), o da linha e o da coluna.
Por exemplo, vamos criar e exibir a seguinte matriz 3x3:
import numpy as np
MeuArray = np.array([ [1,2,3],
[4,5,6],
[7,8,9] ])
Lembrando que o índice da primeira linha é 0, o da segunda 1 e o da terceira 2.
O índice da primeira coluna é 0, o da segunda coluna é 1 e o da terceira coluna é 2.
Agora a regra dos índices: o primeiro índice se refere a linha e o segundo índice se refere a coluna. Do mesmo jeito que é na Matemática/Álgebra Linear. Colocamos cada índice entre colchetes.
Assim, para acessar o primeiro elemento, da primeira coluna: MeuArray[0][0]
Para acessar o segundo elemento da primeira linha: MeuArray[0][1]
Já para acessar o segundo elemento da primeira coluna: MeuArray[1][0]
O seguinte script exibe todos os elementos da matriz que usamos como exemplos, um por um:
import numpy as np
MeuArray = np.array([ [1,2,3],
[4,5,6],
[7,8,9] ])
for linha in range(3):
for coluna in range(3):
print("Linha %d e coluna %d: %d" % (linha+1, coluna+1,
MeuArray[linha][coluna]))
Saída:
Linha 1 e coluna 1: 1
Linha 1 e coluna 2: 2
Linha 1 e coluna 3: 3
Linha 2 e coluna 1: 4
Linha 2 e coluna 2: 5
Linha 2 e coluna 3: 6
Linha 3 e coluna 1: 7
Linha 3 e coluna 2: 8
Linha 3 e coluna 3: 9
Veja que interessante este script. Para exibir os elementos, usamos dois laços for aninhados. O primeiro, vai pegar da primeira linha (a linha 0) até a terceira linha (linha 2).
Dentro de cada iteração, estamos dentro de cada linha. Então usamos outro for para pegar os elementos de cada coluna, fazendo a variável coluna ir de 0 até 2.
Dentro deste segundo laço, basta irmos imprimindo o número correspondente da linha, da coluna e do valor armazenado em cada elemento da matriz.
Note que somamos o valor 1 para as variáveis linha e coluna, pois para o Python, as linhas e colunas tem índices 0, 1 e 2. Mas, para nós humanos, queremos mostrar as linhas 1, 2 e 3.
Como acessar linhas e colunas de uma matriz
O NumPy também nos permite acessarmos diretamente uma fileira inteira, seja uma linha ou uma coluna. Para isso, vamos usar o operador :, que será melhor explicado no próximo tutorial.
Para imprimir a primeira linha: MeuArray[0, : ] ou apenas MeuArray[0]
Para imprimir a terceira linha : MeuArray[2, : ] ou apenas MeuArray[2]
Para imprimir a primeira coluna: MeuArray[:,0] (a saída é um vetor horizontal)
Para imprimir a segunda coluna, mas na forma de um vetor vertical, faça: MeuArray[ : , [1] ]
Dimensões e números de elementos de um Array
Muitas vezes, vamos precisar escrever programas onde não saberemos exatamente como vai ser o array de dados que iremos receber, portanto temos que aprender técnicas para checar que tipo de informação estamos recebendo.
Por exemplo, para descobrirmos a dimensão de um array, usaremos o atributo ndim. Seja o array unidimensional:
Se você usar arr1.ndim, ele terá o valor 1, pois esse array é unidimensional (apenas uma linha):
import numpy as np
arr1=np.array([21, 12, 33])
print("Dimensão do array arr1: ",arr1.ndim)
Já uma matriz, por exemplo, tem dimensão dois:
import numpy as np
arr2=np.array([[21, 12, 33],
[11, 22, 23]])
print("Dimensão do array arr2: ",arr2.ndim)
Se quisermos saber, exatamente, o tanto de linhas que possui um array, podemos usar a função interna len() do Python, len(arr). Lembre-se, que para selecionar uma linha qualquer da matriz, como a primeira, usamos o arr[0], logo, se aplicarmos a função len[0] nessa linha (array unidimensional), teremos o número de elementos dele, que é o número de colunas (mesmo número de colunas da matriz), veja:
import numpy as np
arr=np.array([[1, 1, 1, 1],
[2, 2, 2, 2],
[3, 3, 3, 3]])
print("Número de linhas: ", len(arr))
print("Número de colunas: ", len(arr[0]))
print("Linhas e colunas do array arr: ",arr.shape)
Por fim, podemos usar também o atributo shape, que retorna uma lista com o valor das linhas e colunas. Teste o código acima e veja o resultado. No próximo tutorial, vamos aprender mais sobre shapes (formas de matrizes).
Também pode ser necessário ter o número total de elementos de uma matriz. Para isto, basta acessar o elemento size:
import numpy as np
arr=np.array([[1, 1, 1, 1],
[2, 2, 2, 2],
[3, 3, 3, 3],
[4, 4, 4, 4]])
print("Número total de elementos: ", arr.size)
Lembrando que o número total de elementos de uma matriz nada mais é que o produto do número de linhas pelo número de colunas.
Exercício de Arrays e Matrizes
0. Qual a relação matemática entre len(arr), len(arr[0] e o atributo size?
1. Crie uma função sum() que recebe um array unidimensional e retorna a soma de seus elementos, usando apenas o atributo size do NumPy.
2. Crie uma função square_matrix(), que verifica se a matriz recebida é quadrada ou não. Matriz quadrada é aquela que o número de linhas é o mesmo do de colunas.
3. Crie uma função chamada trace() que recebe uma matriz quadrada e retorna o seu traço, ou seja, a soma dos elementos da diagonal principal. Lembrando que somente matrizes quadradas possuem traço.
4. Crie uma função sum_matrix() que recebe duas matrizes e retorne uma matriz com a soma destas duas matrizes anteriores. Lembre-se que só podemos somar matrizes que tenham mesmo número de linhas e colunas, seu script deve checar isso antes de somar.
Em nosso livro/apostila/ebook Programação Científica com Python, resolvemos e comentamos todas essas questões, além de fornecer o código completo.
