Índices

…[ m, n, …, p ]

O uso de colchetes junto ao nome do arranjo permite acessar elementos específicos do arranjo. Esta notação também permite fazer o slicing do arranjo e utilizar até mesmo outros arranjos para acessar elementos de uma maneira adequada. Portanto, é bastante poderosa. Na maior parte das vezes, o usuário não precisará usar todo esse poder, mas, quando o acesso aos arranjos for um tanto quanto impredizível, dar uma olhada na documentação deste comando pode ajudar bastante a aumentar a eficiência e a legibilidade do programa.

Cada um dos argumentos do uso dos colchetes como acima refere-se ao acesso a elementos em na dimensão respectiva, sendo que o índice do primeiro elemento é sempre 0. O comportamento em cada dimensão é idêntico, e o arranjo retornado vai depender apenas da quantidade de dimensões que o arranjo manipulado possui. Os argumentos podem ser colocados das seguintes formas:

n
Como um número simples, acessa apenas um elemento do arranjo. Se o arranjo for unidimensional, esse elemento é um número; se for bidimensional, retorna uma linha inteira do arranjo; se for tridimensional, volta um plano do arranjo, e assim por diante.
m, n
Se usado em um arranjo bidimensional, retorna um elemento específico na posição dada; se for usado em um arranjo tridimensional, retorna uma linha específica do arranjo, e assim por diante. Generaliza-se o comportamento para arranjos com mais de três dimensões.
m:n
Realiza o slicing do arranjo, ou seja, retorna uma seqüência de elementos situados entre o índice m e o índice n (este não incluso). Ambos os argumentos podem ser omitidos: se o argumento m for omitido, considera o arranjo desde o início; se o argumento n for omitido, considera o arranjo até o seu fim. Portanto, o índice [:] indica todo o arranjo. Isso pode ser útil na hora de especificar linhas ou colunas inteiras de arranjos multidimensionais (veja exemplos abaixo).
m:n:p
Realiza o slicing, mas ignorando alguns elementos. A partir do elemento indicado pelo argumento m até o elemento indicado pelo argumento n (este não incluso), retorna os elementos p a p. Ou seja, retorna os elementos em m, m + p, m + 2p, etc.
a
Se o argumento é um arranjo numérico, então os elementos do argumento a são usados para selecionar conjuntos de elementos do arranjo manipulado, que aparecem na mesma ordem que os índices do argumento. Alternativamente, se os elementos do arranjo a forem booleanos, então o arranjo resultante possuirá aqueles elementos do arranjo manipulado que correspondem aos valores True do arranjo a.
i, j
Se os argumentos são arranjos, então cada par de elementos é selecionado para compor o arranjo resultante. As linhas são especificadas pelos elementos do arranjo i, e as colunas pelos elementos do arranjo j. Esse tipo de acesso pode ser generalizado para várias dimensões.

Exemplos:

O acesso a elementos é extremamente simples e flexível. Esta flexibilidade tem a grande vantagem de permitir formas bem inusitadas de manipular os arranjos, mas fica bastante difícil mostrar todas as possíveis alternativas de combinações nestes exemplos. A melhor maneira é testar as alternativas até encontrar a que mais se adequa ao seu problema (e, caso encontre alguma forma não documentada nesta página, não se esqueça de incluí-la!). Como sempre, estes exemlos supõem que o comando from numpy import * foi usado na linha de comando. Em scripts, é mais indicado o uso da forma import numpy para manter a coesão do espaço de nomes.

Inicialmente, mostramos como acessar elementos específicos através dos índices. Uma vez que os arranjos são variáveis, é possível atribuir valores específicos a elementos do arranjo.

>>> a = array([[ 1, 2, 3, 4 ],
...            [ 5, 6, 7, 8 ],
...            [ 9, 10, 11, 12 ],
...            [ 13, 14, 15, 16 ] ])
>>> a[0, 0]    # Linha 1, coluna 1
1
>>> a[1, 3]    # Linha 2, coluna 4
8
>>> a[2, 2] = -1    # Linha 3, coluna 3 recebe o valor -1
>>> a
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, -1, 12],
       [13, 14, 15, 16]])

Para acessarmos diversos elementos, fazemos o slicing através da notação com :. Também é possível fazer atribuições a linhas e colunas. Veja, no segundo exemplo, como utilizamos a notação para "pular" alguns elementos.

>>> a[1:3, 1:3]    # Da linha 1 à linha 2, da coluna 1 à coluna 2
array([[  6, 7],
       [ 10, 12]])
>>> a[::2, ::2]    # Obtém a cada dois elementos
array([[  1, 3],
       [  9, -1]])

Para acessarmos linhas ou colunas inteiras, podemos usar a notação [:] onde necessário. Note que é possível atribuir linhas ou colunas inteiras. Não é necessário usar a notação [:] se desejamos pegar toda uma linha.

>>> a[1]    # Segunda linha
array([5, 6, 7, 8])
>>> a[:, 1]    # Segunda coluna
array([ 2,  6, 10, 14])
>>> a[:, 2] = [100, 101, 102, 103]
>>> a
array([[  1,   2, 100,   4],
       [  5,   6, 101,   8],
       [  9,  10, 102,  12],
       [ 13,  14, 103,  16]])

Se temos um arranjo de valores booleanos, podemos acessar elementos específicos. Note que podemos até usar uma comparação como índice, pois a comparação retorna uma matriz de valores booleanos:

>>> b = array([[ True, False, False, True ],
...            [ False, True, True, False ],
...            [ True, False, True, False ],
...            [ False, True, False, True ]])
>>> a[b]
array([  1,   4,   6, 101,   9, 102,  14,  16])
>>> a>=100
array([[False, False,  True, False],
       [False, False,  True, False],
       [False, False,  True, False],
       [False, False,  True, False]], dtype=bool)
>>> a[a>=100]
array([100, 101, 102, 103])
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License