Arrays Estruturados no NumPy

Introdução

Neste laboratório, você aprenderá sobre arrays estruturados no NumPy. Arrays estruturados são um recurso poderoso para trabalhar com dados heterogêneos, semelhante a tabelas em um banco de dados ou uma planilha. Cada elemento de um array estruturado pode ser considerado como uma linha, com colunas nomeadas chamadas "fields". Isso os torna ideais para organizar e manipular dados tabulares diretamente em Python.

Ao longo deste laboratório, você escreverá e executará código Python no arquivo structured_arrays.py fornecido no WebIDE.

Criando e Acessando um Array Estruturado

Primeiro, vamos criar um array estruturado simples. O tipo de dados (dtype) de um array estruturado é definido como uma lista de tuplas. Cada tupla especifica um campo com seu (nome, tipo_de_dados). Isso nos permite armazenar diferentes tipos de dados, como strings e inteiros, no mesmo array.

Abra o arquivo structured_arrays.py no explorador de arquivos no painel esquerdo. Adicione o seguinte código para criar um array estruturado representando uma lista de pessoas com seus nomes e idades.

## Create a structured array
data = np.array([('Alice', 25, 55.5), ('Bob', 30, 68.0)],
                dtype=[('name', 'U10'), ('age', 'i4'), ('weight', 'f4')])

print("Original Array:")
print(data)

## Access a specific field by its name
names = data['name']
print("\nNames field:")
print(names)

Explicação do Código:

• import numpy as np: Esta linha importa a biblioteca NumPy.
• np.array([...], dtype=[...]): Criamos um array. O primeiro argumento é uma lista de tuplas, onde cada tupla ('Alice', 25, 55.5) representa uma linha de dados.
• dtype=[('name', 'U10'), ('age', 'i4'), ('weight', 'f4')]: Esta é a parte crucial. Definimos três campos:
  • 'name': Uma string Unicode com um comprimento máximo de 10 caracteres (U10).
  • 'age': Um inteiro de 4 bytes (32 bits) (i4).
  • 'weight': Um float de 4 bytes (32 bits) (f4).
• data['name']: Podemos acessar todos os valores de um campo específico (coluna) usando seu nome como índice, o que retorna um novo array NumPy.

Agora, salve o arquivo e execute-o no terminal para ver a saída.

python structured_arrays.py

Você deverá ver a seguinte saída, que mostra o array estruturado completo e o array contendo apenas os nomes.

Original Array:
[('Alice', 25, 55.5) ('Bob', 30, 68. )]

Names field:
['Alice' 'Bob']

Modificando Campos e Indexando

Arrays estruturados são mutáveis, o que significa que você pode alterar seus valores. Você pode modificar um campo inteiro de uma vez ou acessar um elemento específico pelo seu índice e, em seguida, modificar seu campo. Você também pode criar um novo array contendo um subconjunto dos campos originais.

Adicione o seguinte código ao final do seu script structured_arrays.py.

## Modify the 'age' field
data['age'] = [26, 31]
print("\nArray after modifying age:")
print(data)

## Access a single element (the first row)
first_person = data[0]
print("\nFirst person's data:")
print(first_person)

## Create a new array with a subset of fields
subset = data[['name', 'weight']]
print("\nSubset of array (name and weight):")
print(subset)

Explicação do Código:

• data['age'] = [26, 31]: Isso atribui uma nova lista de valores ao campo age, atualizando toda a coluna.
• data[0]: Isso acessa o primeiro elemento (linha) do array. O resultado é um escalar void do NumPy, que contém os dados para essa única linha.
• data[['name', 'weight']]: Ao passar uma lista de nomes de campos, você pode selecionar várias colunas, o que cria um novo array estruturado apenas com esses campos.

Salve o arquivo e execute-o novamente no terminal.

python structured_arrays.py

Sua saída agora incluirá as novas seções, mostrando o array modificado e o subconjunto.

... (previous output) ...

Array after modifying age:
[('Alice', 26, 55.5) ('Bob', 31, 68. )]

First person's data:
('Alice', 26, 55.5)

Subset of array (name and weight):
[('Alice', 55.5) ('Bob', 68. )]

Usando Arrays de Registro para Acesso a Atributos

Embora a indexação por nome (por exemplo, data['name']) seja poderosa, ela pode ser verbosa. O NumPy fornece uma subclasse especial de ndarray chamada array de registro (np.recarray). Arrays de registro permitem que você acesse campos como atributos, usando notação de ponto (por exemplo, record_array.name), o que pode tornar seu código mais limpo e legível.

Você pode criar um array de registro diretamente ou converter um array estruturado existente. Vamos ver como fazer ambos. Adicione o seguinte código ao final de structured_arrays.py.

## Convert the structured array to a record array using view()
record_array = data.view(np.recarray)

print("\nType of the new view:")
print(type(record_array))

## Access fields using attribute (dot) notation
print("\nAccessing names via attribute:")
print(record_array.name)

print("\nAccessing ages via attribute:")
print(record_array.age)

Explicação do Código:

• data.view(np.recarray): O método .view() cria um novo objeto de array que visualiza os mesmos dados. Ao especificar np.recarray, obtemos uma visualização de array de registro dos nossos dados de array estruturado. Nenhum dado é copiado; é apenas uma maneira diferente de interagir com ele.
• record_array.name: Esta é a principal característica dos arrays de registro. Você pode acessar o campo name como se fosse um atributo do objeto. Isso é equivalente a record_array['name'].

Salve o arquivo e execute-o.

python structured_arrays.py

A saída agora mostrará o tipo da nova visualização do array e demonstrará o acesso por atributo.

... (previous output) ...

Type of the new view:
<class 'numpy.recarray'>

Accessing names via attribute:
['Alice' 'Bob']

Accessing ages via attribute:
[26 31]

Resumo

Neste laboratório, você aprendeu os fundamentos do uso de arrays estruturados no NumPy. Você começou criando um array estruturado com campos nomeados e múltiplos tipos de dados. Em seguida, praticou o acesso a campos específicos (colunas) usando indexação de chave no estilo de dicionário e a modificação de seus valores. Finalmente, você explorou arrays de registro, uma alternativa conveniente que permite o acesso a campos como atributos, e aprendeu como converter entre arrays estruturados padrão e arrays de registro usando o método .view().

Arrays estruturados são uma ferramenta essencial para lidar com conjuntos de dados tabulares complexos em computação científica e análise de dados com Python.