Técnicas Fundamentais de Criação de Arrays NumPy

Introdução

Pré-requisitos

Antes de iniciar este curso, você deve ter habilidades básicas de programação em Python. Se você ainda não aprendeu Python, pode começar com nosso Caminho de Aprendizagem de Python.

Bem-vindo ao laboratório sobre técnicas fundamentais de criação de arrays NumPy. Antes de começarmos a codificar, vamos entender o que é NumPy e por que ele é essencial para computação científica.

O que é NumPy?

NumPy (abreviação de Numerical Python) é a biblioteca fundamental para computação científica em Python. Ela fornece estruturas de dados e funções poderosas para trabalhar com grandes arrays e matrizes de dados numéricos.

Por que NumPy em vez de listas Python?

Embora as listas nativas do Python sejam flexíveis e fáceis de usar, elas têm limitações ao trabalhar com dados numéricos:

• Desempenho: Arrays NumPy são muito mais rápidos para operações matemáticas
• Eficiência de memória: NumPy usa menos memória para armazenar a mesma quantidade de dados
• Conveniência: NumPy fornece centenas de funções matemáticas integradas
• Funcionalidade: NumPy suporta operações avançadas como multiplicação de matrizes, transformadas de Fourier, etc.

Neste laboratório, você aprenderá os métodos mais comuns para criar arrays NumPy. Você escreverá e executará scripts Python para praticar a conversão de sequências Python, o uso de funções NumPy integradas, a manipulação de arrays existentes e o carregamento de dados de arquivos. Toda a codificação será feita dentro do WebIDE.

Criando Arrays a Partir de Sequências Python

A forma mais básica de criar um array NumPy é convertendo uma sequência Python, como uma lista ou uma tupla. A função numpy.array() recebe uma sequência como argumento e retorna um novo array NumPy.

Compreendendo Arrays NumPy

Antes de criarmos arrays, vamos entender o que torna os arrays NumPy especiais:

Dimensões do Array

• Array 1D (Vetor): Uma lista simples de números, como [1, 2, 3, 4]
• Array 2D (Matriz): Uma tabela de números com linhas e colunas, como uma planilha
• Array 3D (Tensor): Um cubo de números, útil para imagens ou dados 3D

Principais Diferenças em Relação às Listas Python

• Homogêneo: Todos os elementos devem ser do mesmo tipo de dado (geralmente números)
• Tamanho fixo: Uma vez criado, o tamanho não pode ser alterado
• Eficiente: Muito mais rápido para operações matemáticas
• Funcionalidade rica: Suporta operações vetorizadas (operações em arrays inteiros de uma vez)

Importando NumPy

Em Python, importamos NumPy usando o alias padrão np:

import numpy as np

Este alias np é uma convenção amplamente adotada na comunidade científica de Python.

Agora vamos criar alguns arrays. Abra o arquivo array_from_sequence.py no explorador de arquivos à esquerda. Adicione o seguinte código a ele. Este código importará a biblioteca NumPy e criará arrays unidimensionais (1D), bidimensionais (2D) e tridimensionais (3D) a partir de listas Python.

import numpy as np

## Cria um array 1D a partir de uma lista
a1D = np.array([1, 2, 3, 4])
print("Array 1D:")
print(a1D)

## Cria um array 2D a partir de uma lista de listas
a2D = np.array([[1, 2], [3, 4]])
print("\nArray 2D:")
print(a2D)

## Cria um array 3D a partir de listas aninhadas
a3D = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print("\nArray 3D:")
print(a3D)

Sugestão: Você pode copiar o código acima para o seu editor de código, depois ler cuidadosamente cada linha de código para entender sua função. Se precisar de mais explicações, pode clicar no botão "Explicar Código" 👆. Você pode interagir com o Labby para obter ajuda personalizada.

Após adicionar o código, salve o arquivo. Agora, execute o script a partir do terminal para ver a saída.

python array_from_sequence.py

Você deverá ver a seguinte saída, que exibe os arrays que você criou:

1D Array:
[1 2 3 4]

2D Array:
[[1 2]
 [3 4]]

3D Array:
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]

Compreendendo Tipos de Dados (dtype)

Arrays NumPy possuem um tipo de dado fixo para todos os elementos, que é especificado pelo parâmetro dtype. Isso é diferente das listas Python, onde cada elemento pode ter um tipo diferente.

Por Que os Tipos de Dados São Importantes

• Eficiência de memória: Tipos diferentes usam quantidades diferentes de memória
• Desempenho: Operações são otimizadas para tipos de dados específicos
• Precisão: Controla como os números são armazenados e calculados

Tipos de Dados Comuns

• int32 / int64: Números inteiros (32 ou 64 bits)
• float32 / float64: Números decimais (32 ou 64 bits)
• complex: Números complexos
• bool: Valores Verdadeiro/Falso

Você pode especificar o tipo de dado ao criar um array usando o parâmetro dtype, como np.array([1, 2], dtype=complex). Se você não especificar um dtype, o NumPy escolherá um apropriado automaticamente com base nos dados de entrada.

Utilizando Funções Intrínsecas de Criação de Arrays

O NumPy fornece várias funções nativas para criar arrays do zero, sem a necessidade de uma sequência Python. Essas funções são otimizadas para casos de uso específicos e são muito mais rápidas do que criar arrays manualmente a partir de listas.

Por que Usar Essas Funções?

Em vez de escrever np.array([0, 0, 0, 0, 0]), você pode simplesmente usar np.zeros(5). Essas funções são:

• Mais rápidas: Código C otimizado internamente.
• Mais legíveis: A intenção é clara a partir do nome da função.
• Eficientes em memória: Alocação direta de memória.
• Convenientes: Não há necessidade de especificar manualmente cada elemento.

Abra o arquivo intrinsic_creation.py e adicione o seguinte código. Este script demonstra várias funções de criação comuns.

import numpy as np

## Cria um array com um intervalo de elementos
## np.arange(start, stop, step) - similar ao range() do Python
## Caso de uso: Criar sequências para loops, gerar índices
arr_range = np.arange(0, 10, 2)  ## [0, 2, 4, 6, 8]
print("Array de arange:")
print(arr_range)

## Cria um array com um número específico de elementos entre dois pontos
## np.linspace(start, stop, num_elements) - pontos igualmente espaçados
## Caso de uso: Criar pontos para plotagem, amostragem de dados
arr_linspace = np.linspace(0, 10, 5)  ## 5 pontos de 0 a 10
print("\nArray de linspace:")
print(arr_linspace)

## Cria um array preenchido com zeros
## np.zeros((linhas, colunas)) - inicializa arrays para cálculos
## Caso de uso: Pré-alocar arrays antes de preenchê-los com valores calculados
arr_zeros = np.zeros((2, 3))  ## Array 2x3 de zeros
print("\nArray de zeros:")
print(arr_zeros)

## Cria um array preenchido com uns
## np.ones((linhas, colunas)) - inicializa com uns
## Caso de uso: Criar máscaras, fatores de escala ou pontos de partida para algoritmos
arr_ones = np.ones((3, 2))  ## Array 3x2 de uns
print("\nArray de uns:")
print(arr_ones)

## Cria uma matriz identidade
## np.eye(tamanho) - matriz quadrada com 1s na diagonal, 0s em outros lugares
## Caso de uso: Álgebra linear, resetar transformações, multiplicação de matrizes
identity_matrix = np.eye(3)  ## Matriz identidade 3x3
print("\nMatriz identidade:")
print(identity_matrix)

Salve o arquivo e execute-o no terminal.

python intrinsic_creation.py

A saída mostrará os diferentes arrays criados por essas funções:

Array from arange:
[0 2 4 6 8]

Array from linspace:
[ 0.   2.5  5.   7.5 10. ]

Array of zeros:
[[0. 0. 0.]
 [0. 0. 0.]]

Array of ones:
[[1. 1.]
 [1. 1.]
 [1. 1.]]

Identity matrix:
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

Manipulando Arrays Existentes

Você também pode criar novos arrays modificando, combinando ou dividindo arrays existentes. Esta seção abrange dois conceitos importantes: views vs. cópias e concatenação de arrays.

Views vs. Cópias: Compreendendo o Compartilhamento de Memória

Este é um dos conceitos mais importantes no NumPy que frequentemente confunde iniciantes.

O que é uma View?

Uma view é uma maneira diferente de olhar para os mesmos dados na memória. Quando você cria uma view (como através de fatiamento - slicing), você não está criando um novo array - você está apenas criando uma nova referência para os dados existentes.

O que é uma Cópia?

Uma cópia cria um array completamente novo na memória com seus próprios dados. Alterações em uma cópia não afetam o array original, e vice-versa.

Por que Isso Importa

• Views são eficientes em memória: Elas não duplicam dados.
• Views são rápidas: Sem sobrecarga de cópia.
• Mas views podem causar efeitos colaterais inesperados: Modificar uma view altera os dados originais.
• Cópias são mais seguras: As alterações são isoladas, mas usam mais memória.

Vamos também explorar como juntar múltiplos arrays em um array maior.

Abra o arquivo array_manipulation.py e adicione o seguinte código:

import numpy as np

## --- Parte 1: Views vs. Cópias ---
a = np.arange(1, 5)
print("Array original 'a':", a)

## Cria uma view dos dois primeiros elementos
b = a[:2]
b[0] = 99 ## Modifica a view
print("View modificada 'b':", b)
print("Array 'a' após modificar a view:", a) ## 'a' também é alterado

## Cria uma cópia
c = a[:2].copy()
c[0] = 0 ## Modifica a cópia
print("\nCópia modificada 'c':", c)
print("Array 'a' após modificar a cópia:", a) ## 'a' não é alterado

## --- Parte 2: Juntando Arrays ---
A = np.ones((2, 2))
B = np.eye(2) * 2
C = np.zeros((2, 2))
D = np.diag((-3, -4))

## Junta arrays em uma matriz de blocos
block_matrix = np.block([
    [A, B],
    [C, D]
])
print("\nMatriz de blocos:")
print(block_matrix)

Salve o arquivo e execute-o no terminal.

python array_manipulation.py

A saída demonstra como modificar uma view afeta o array original, enquanto modificar uma cópia não o faz. Ela também mostra o resultado de combinar quatro arrays menores em uma única matriz de blocos.

Original array 'a': [1 2 3 4]
Modified view 'b': [99  2]
Array 'a' after modifying the view: [99  2  3  4]

Modified copy 'c': [0 2]
Array 'a' after modifying the copy: [99  2  3  4]

Block matrix:
[[ 1.  1.  2.  0.]
 [ 1.  1.  0.  2.]
 [ 0.  0. -3.  0.]
 [ 0.  0.  0. -4.]]

Lendo Arrays de um Arquivo

Uma tarefa comum na análise de dados é carregar dados de um arquivo para um array NumPy. O NumPy se destaca nisso porque pode ler eficientemente grandes conjuntos de dados e convertê-los automaticamente nos formatos numéricos apropriados.

Por que NumPy para I/O de Arquivos?

• Velocidade: Muito mais rápido do que ler linha por linha com Python
• Inferência de tipo: Detecta automaticamente os tipos de dados apropriados
• Eficiência de memória: Carrega dados diretamente em arrays otimizados
• Conveniência: Chamada de função única em vez de parsing complexo

Formatos Comuns de Arquivo

• Arquivos CSV: Valores separados por vírgula (mais comum)
• Arquivos TSV: Valores separados por tabulação
• Arquivos de texto: Separados por espaço ou delimitador personalizado
• Arquivos binários: Para conjuntos de dados muito grandes (avançado)

Para arquivos de texto simples como CSV (Comma-Separated Values), o NumPy fornece a função np.loadtxt().

O script de configuração para este laboratório já criou um arquivo chamado data.csv em seu diretório de projeto. Seu conteúdo é:

col1,col2,col3
1.0,2.5,3.2
4.5,5.0,6.8
7.3,8.1,9.9

Agora, abra o arquivo read_from_file.py e adicione o seguinte código para ler esses dados.

Entendendo os Parâmetros de np.loadtxt

A função np.loadtxt() possui vários parâmetros importantes:

• delimiter=',': Especifica como as colunas são separadas (vírgula para CSV)
• skiprows=1: Pula a primeira linha (geralmente cabeçalhos)
• dtype: Opcional - especifica o tipo de dado (detectado automaticamente se não fornecido)
• usecols: Opcional - especifica quais colunas ler
• comments: Opcional - especifica o caractere de comentário para ignorar linhas

Usamos delimiter=',' para especificar que as colunas são separadas por vírgulas e skiprows=1 para ignorar a linha de cabeçalho.

import numpy as np

## Load data from the CSV file
try:
    ## Relative paths will cause validation to fail, please use absolute paths in the lab
    data = np.loadtxt('/home/labex/project/data.csv', delimiter=',', skiprows=1)
    print("Data loaded from data.csv:")
    print(data)
except IOError:
    print("Error: data.csv not found.")

Salve o arquivo e execute-o a partir do terminal.

python read_from_file.py

O script lerá os dados numéricos de data.csv e os imprimirá como um array NumPy.

Data loaded from data.csv:
[[1.  2.5 3.2]
 [4.5 5.  6.8]
 [7.3 8.1 9.9]]

Este método é muito eficiente para carregar dados numéricos estruturados em arrays para processamento posterior.

Resumo

Neste laboratório, você aprendeu as técnicas fundamentais para criar arrays NumPy. Você praticou a criação de arrays a partir de listas Python, usando funções intrínsecas como np.arange e np.zeros, manipulando arrays existentes através de views, cópias e junções, e carregando dados de um arquivo de texto usando np.loadtxt.

Essas habilidades são os blocos de construção para quase todas as tarefas de computação numérica e científica que você realizará com Python. Com uma compreensão sólida da criação de arrays, você está agora pronto para explorar manipulações de arrays e operações matemáticas mais avançadas no NumPy.