Domine a Indexação NumPy: Desbloqueie o Poder da Manipulação de Arrays

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:

Valor único para múltiplos elementos: Um valor pode ser atribuído a muitas posições
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.

Introdução à Indexação em NumPy