Introdução à Indexação em NumPy

Introdução

Bem-vindo de volta! Agora que você entende como criar arrays NumPy, é hora de aprender a acessar e manipular os dados dentro deles. Neste laboratório, você explorará a indexação - o método principal para acessar e modificar dados em arrays NumPy.

Construindo sobre o que você aprendeu

No laboratório anterior, você aprendeu:

• Como criar arrays usando várias funções NumPy
• A diferença entre arrays e listas Python
• Dimensões de array (1D, 2D, 3D) e tipos de dados

Agora você aprenderá a:

• Acessar elementos individuais ou grupos de elementos
• Extrair linhas, colunas ou regiões específicas de arrays
• Usar técnicas de seleção avançadas para filtragem de dados complexa
• Modificar dados de array através da indexação

Por que a Indexação é Importante

A indexação é fundamental para a manipulação de dados porque permite que você:

• Extraia subconjuntos de dados para análise
• Modifique valores específicos em grandes conjuntos de dados
• Filtre dados com base em condições
• Execute operações vetorizadas em elementos selecionados

Essas habilidades são essenciais para qualquer tarefa de análise de dados ou computação científica em Python.

Indexação e Fatiamento Básicos em Arrays 1D

Agora que você sabe como criar arrays, vamos aprender a acessar seu conteúdo. Todo o seu trabalho neste laboratório será feito no arquivo indexing_practice.py.

Compreendendo a Indexação de Arrays

Indexação Baseada em Zero

Assim como as listas Python, os arrays NumPy usam indexação baseada em zero. Isso significa que:

• O primeiro elemento está no índice 0
• O segundo elemento está no índice 1
• E assim por diante...

Visualizando Índices de Array

Para um array x = [10, 20, 30, 40, 50]:

Índice:  0   1   2   3   4
Valor:  10  20  30  40  50

Portanto, x[0] retorna 10, x[2] retorna 30, etc.

Sintaxe de Fatiamento (Slicing)

O fatiamento permite selecionar um intervalo de elementos com a sintaxe start:stop:step:

• start: Índice onde a fatia começa (inclusivo)
• stop: Índice onde a fatia termina (exclusivo)
• step: Quantos elementos pular (opcional, padrão é 1)

Padrões comuns de fatiamento:

• x[1:4]: Elementos nos índices 1, 2, 3
• x[:3]: Primeiros 3 elementos (índices 0, 1, 2)
• x[2:]: Do índice 2 até o final
• x[::2]: A cada dois elementos começando do índice 0
• x[::-1]: Inverte o array inteiro

Primeiro, abra o arquivo indexing_practice.py no editor. Em seguida, substitua todo o seu conteúdo pelo seguinte código. Este código cria um array 1D e demonstra como acessar um único elemento e uma fatia de elementos.

import numpy as np

## Create a 1D array with numbers from 0 to 9
x = np.arange(10)
print("Original array:", x)

## Access a single element at index 2
element = x[2]
print("Element at index 2:", element)

## Slice the array from index 1 up to (but not including) index 7, with a step of 2
a_slice = x[1:7:2]
print("Slice from 1 to 7 with step 2:", a_slice)

Após adicionar o código ao indexing_practice.py, salve o arquivo. Agora, execute o script a partir do terminal executando o seguinte comando:

python indexing_practice.py

Você deverá ver a seguinte saída, que mostra o array original, o elemento no índice especificado e a fatia resultante.

Original array: [0 1 2 3 4 5 6 7 8 9]
Element at index 2: 2
Slice from 1 to 7 with step 2: [1 3 5]

Indexação de Arrays Multidimensionais

Agora vamos trabalhar com arrays que têm mais de uma dimensão. É aqui que o NumPy realmente se destaca em comparação com as listas Python!

Pensando em Múltiplas Dimensões

Arrays 2D como Tabelas

Um array 2D é como uma planilha ou tabela:

• Linhas são a primeira dimensão (horizontal)
• Colunas são a segunda dimensão (vertical)
• Você especifica os índices de linha e coluna: array[linha, coluna]

Visualizando a Indexação 2D

Para um array 2D:

array = [[10, 20, 30],
         [40, 50, 60],
         [70, 80, 90]]

Índices:     0,0  0,1  0,2
             1,0  1,1  1,2
             2,0  2,1  2,2

• array[0, 0] → 10 (primeira linha, primeira coluna)
• array[1, 2] → 60 (segunda linha, terceira coluna)
• array[2, 1] → 80 (terceira linha, segunda coluna)

Selecionando Linhas ou Colunas Inteiras

• array[0] ou array[0, :] → toda a primeira linha [10, 20, 30]
• array[:, 1] → toda a segunda coluna [20, 50, 80]
• Isso é muito mais conveniente do que listas Python aninhadas!

Vamos praticar isso com um array bidimensional (2D). Atualize seu arquivo indexing_practice.py com o código abaixo. Este script cria um array 3x4 e mostra como acessar um único elemento e uma linha inteira.

import numpy as np

## Create a 2D array (3 rows, 4 columns)
x = np.arange(12).reshape(3, 4)
print("Original 2D array:\n", x)

## Access the element at row 1, column 2
element = x[1, 2]
print("\nElement at (1, 2):", element)

## Access the entire first row (row index 0)
first_row = x[0]
print("\nFirst row:", first_row)

Salve o arquivo e execute-o novamente no terminal:

python indexing_practice.py

A saída exibirá o array 2D e as partes específicas que você selecionou.

Original 2D array:
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

Element at (1, 2): 6

First row: [0 1 2 3]

Indexação Avançada

O fatiamento básico funciona bem para regiões contíguas, mas às vezes você precisa de seleções mais complexas. O NumPy oferece duas técnicas poderosas de indexação avançada:

Indexação com Array de Inteiros

Selecione elementos arbitrários fornecendo um array de índices. É como escolher itens específicos de uma lista usando suas posições.

Exemplo prático: Você tem notas de testes e quer verificar as notas dos alunos nas posições 3, 7 e 12:

scores = np.array([85, 92, 78, 95, 88, 76, 91, 89, 84, 93, 87, 90, 82])
student_positions = [3, 7, 12]  ## Alunos de interesse
selected_scores = scores[student_positions]  ## [95, 89, 82]

Indexação com Array Booleano (Mascaramento)

Selecione elementos com base em condições. Crie uma "máscara" de valores True/False e, em seguida, use-a para filtrar o array.

Exemplo prático: Filtre as notas de aprovação (≥ 80) de uma turma:

scores = np.array([85, 92, 78, 95, 88, 76, 91, 89, 84, 93])
passing_mask = scores >= 80  ## [True, True, False, True, True, False, True, True, True, True]
passing_scores = scores[passing_mask]  ## [85, 92, 95, 88, 91, 89, 84, 93]

Por Que Isso Importa

• Indexação com inteiros: Perfeita para amostrar pontos de dados específicos
• Indexação booleana: Ideal para filtragem de dados e seleções condicionais
• Ambas criam cópias (não views), portanto, modificações não afetam o array original

Vamos tentar ambas. Substitua o conteúdo de indexing_practice.py pelo seguinte código:

import numpy as np

## --- Integer Array Indexing ---
x = np.arange(10, 0, -1)
print("Array for integer indexing:", x)

## Select elements at indices 3, 3, 1, and 8
selected_elements = x[np.array([3, 3, 1, 8])]
print("Selected elements with integer array:", selected_elements)


## --- Boolean Array Indexing ---
y = np.array([1., -1., -2., 3.])
print("\nArray for boolean indexing:", y)

## Create a boolean mask for negative elements
mask = y < 0
print("Boolean mask (y < 0):", mask)

## Select elements where the condition is True
negative_elements = y[mask]
print("Elements where y < 0:", negative_elements)

Salve o arquivo e execute o script:

python indexing_practice.py

Sua saída deverá demonstrar como a indexação com inteiros e a indexação booleana funcionam para selecionar dados específicos de seus arrays.

Array for integer indexing: [10  9  8  7  6  5  4  3  2  1]
Selected elements with integer array: [7 7 9 2]

Array for boolean indexing: [ 1. -1. -2.  3.]
Boolean mask (y < 0): [False  True  True False]
Elements where y < 0: [-1. -2.]

Atribuindo Valores a Arrays Indexados

A indexação não serve apenas para ler dados – é também poderosa para modificar dados. Você pode usar qualquer método de indexação no lado esquerdo do operador de atribuição (=) para alterar elementos específicos.

Broadcasting: Tornando Formatos Compatíveis

Ao atribuir valores a arrays indexados, o NumPy usa broadcasting para tornar os formatos compatíveis. Esta é uma das funcionalidades mais poderosas do NumPy!

Regras de Broadcasting

O NumPy pode expandir automaticamente arrays menores para corresponder a arrays maiores durante a atribuição, seguindo estas regras:

1. Valor único para múltiplos elementos: Um valor pode ser atribuído a muitas posições
2. Array pequeno para seleção maior: Desde que as dimensões sejam compatíveis

Exemplos de Broadcasting na Atribuição

## Valor único para um slice
arr = np.array([1, 2, 3, 4, 5])
arr[1:4] = 99  ## [1, 99, 99, 99, 5]

## Array para slice correspondente
arr = np.array([1, 2, 3, 4, 5])
arr[1:4] = [10, 20, 30]  ## [1, 10, 20, 30, 5]

## Indexação booleana com broadcasting
arr = np.array([1, 2, 3, 4, 5])
arr[arr % 2 == 0] = -1  ## Substitui todos os números pares por -1

Notas Importantes

• O broadcasting só funciona quando os formatos são compatíveis
• O formato do valor atribuído deve ser capaz de "caber" na seleção indexada
• Isso é muito mais eficiente do que percorrer os elementos manualmente em um loop

Atualize seu arquivo indexing_practice.py com o seguinte código para ver isso em ação.

import numpy as np

## --- Assigning a single value to a slice ---
x = np.arange(10)
print("Original array:", x)

## Assign the value 99 to elements from index 2 to 4
x[2:5] = 99
print("After assigning 99 to slice [2:5]:", x)


## --- Assigning values based on a boolean condition ---
y = np.arange(10)
print("\nOriginal array:", y)

## Assign the value -1 to all even numbers
y[y % 2 == 0] = -1
print("After assigning -1 to even numbers:", y)

Salve o arquivo e execute-o no terminal:

python indexing_practice.py

A saída mostrará os arrays antes e depois da modificação, demonstrando o quão poderosa essa funcionalidade é para a manipulação de dados.

Original array: [0 1 2 3 4 5 6 7 8 9]
After assigning 99 to slice [2:5]: [ 0  1 99 99 99  5  6  7  8  9]

Original array: [0 1 2 3 4 5 6 7 8 9]
After assigning -1 to even numbers: [-1  1 -1  3 -1  5 -1  7 -1  9]

Resumo

Neste laboratório, você aprendeu as técnicas essenciais para indexar arrays NumPy. Começou com o acesso a elementos únicos e fatiamento básico em arrays 1D, semelhante às listas Python. Em seguida, progrediu para a indexação de arrays multidimensionais para selecionar elementos e sub-arrays específicos. Finalmente, explorou a indexação avançada usando arrays de inteiros e booleanos, e aprendeu a usar esses poderosos métodos de seleção para modificar dados dentro de um array. Essas habilidades são fundamentais para a manipulação e análise eficazes de dados em Python com NumPy.