Arrays em Python

Este capítulo aborda o módulo array integrado ao Python, que fornece uma sequência compacta e com tipo restrito para armazenar dados numéricos homogêneos. Você aprenderá o que são typecodes, como criar e indexar arrays, como modificá-los com o conjunto completo de métodos disponíveis e — de forma crucial — quando um array é a escolha certa em vez de uma lista Python simples.

O que é o Módulo array?

O módulo array do Python fornece um tipo de sequência que armazena elementos de um único tipo numérico compatível com C. Ao contrário de uma lista, que pode conter qualquer combinação de objetos, cada posição em um array armazena exatamente o mesmo tipo de valor primitivo (um inteiro, um float, etc.). Essa restrição torna os arrays mais eficientes em memória do que as listas para grandes coleções de números.

Pontos principais:

• Definido na biblioteca padrão — nenhuma instalação necessária.
• Todos os elementos devem compartilhar o mesmo typecode (um único caractere que identifica o tipo C).
• Suporta operações de sequência padrão: indexação, fatiamento, iteração, len() e teste de pertencimento com in.
• Útil quando você precisa de armazenamento compacto sem recorrer a uma biblioteca de terceiros como NumPy.

Se você já está familiarizado com listas Python, pense em um array como uma lista que troca flexibilidade por eficiência de memória.

Typecodes

Todo array é criado com um typecode — uma string de um único caractere que indica ao Python qual tipo C usar para cada elemento e, portanto, quantos bytes cada posição ocupa.

O tamanho real em bytes pode variar conforme a plataforma. Use array.itemsize para inspecioná-lo em tempo de execução.

Nota sobre 'u' (caractere Unicode): Este typecode foi depreciado no Python 3.3 e removido no Python 3.13. Não o utilize em código novo — use str ou bytes em vez disso.

Criando Arrays

Importe o módulo e chame array.array(typecode, initializer), onde initializer é qualquer iterável de valores compatíveis com o typecode escolhido.

import array as arr

# Array of signed integers
int_array = arr.array('i', [1, 2, 3, 4, 5])
print(int_array)          # array('i', [1, 2, 3, 4, 5])

# Array of double-precision floats
float_array = arr.array('d', [1.1, 2.2, 3.3])
print(float_array)        # array('d', [1.1, 2.2, 3.3])

# Inspect the typecode and bytes-per-element
print(int_array.typecode)   # i
print(int_array.itemsize)   # 4  (platform-dependent)

Você também pode criar um array vazio e populá-lo posteriormente:

import array as arr

empty = arr.array('i')   # empty integer array
empty.append(10)
empty.append(20)
print(empty)             # array('i', [10, 20])

Acessando Elementos do Array

A indexação de arrays funciona exatamente como a indexação de listas: baseada em zero a partir da esquerda, e índices negativos contam a partir da direita.

Acessar um índice fora do intervalo válido levanta um IndexError, exatamente como acontece com listas.

Fatiando Arrays

O fatiamento retorna um novo array do mesmo typecode contendo os elementos selecionados. A sintaxe é a[start:stop:step] — a mesma usada para listas e strings.

Iterando Sobre um Array

Você pode iterar sobre um array com um laço for, ou verificar pertencimento com in:

import array as arr

a = arr.array('i', [10, 20, 30, 40, 50])

for item in a:
    print(item, end=' ')
# Output: 10 20 30 40 50

print()
print(30 in a)   # True
print(99 in a)   # False
print(len(a))    # 5

Modificando Arrays

Arrays são mutáveis — você pode alterar, adicionar e remover elementos após a criação.

Alterando um Elemento

Atribua um novo valor diretamente a um índice:

Adicionando Elementos

Use append() para adicionar um único elemento ao final, ou extend() para adicionar múltiplos elementos de qualquer iterável:

Use insert(index, value) para inserir um elemento em uma posição específica:

import array as arr

a = arr.array('i', [1, 2, 3, 4, 5])

a.insert(2, 10)   # insert 10 before index 2
print(a)          # array('i', [1, 2, 10, 3, 4, 5])

Removendo Elementos

remove(value) exclui a primeira ocorrência do valor fornecido e levanta ValueError se ele não for encontrado:

pop(index) remove e retorna o elemento no index (padrão é o último elemento):

import array as arr

a = arr.array('i', [1, 2, 3, 4, 5])

last = a.pop()     # removes and returns 5
print(last)        # 5
print(a)           # array('i', [1, 2, 3, 4])

second = a.pop(1)  # removes and returns element at index 1
print(second)      # 2
print(a)           # array('i', [1, 3, 4])

Buscando e Contando

index(value) retorna o índice da primeira ocorrência de value (levanta ValueError se ausente):

import array as arr

a = arr.array('i', [10, 20, 30, 20, 40])

print(a.index(20))   # 1 — first occurrence
print(a.index(30))   # 2

count(value) retorna quantas vezes value aparece:

import array as arr

a = arr.array('i', [1, 2, 2, 3, 2, 4])

print(a.count(2))   # 3
print(a.count(9))   # 0

Invertendo um Array

reverse() inverte o array no local:

import array as arr

a = arr.array('i', [1, 2, 3, 4, 5])

a.reverse()
print(a)   # array('i', [5, 4, 3, 2, 1])

Convertendo Entre Arrays e Listas

tolist() converte um array em uma lista Python padrão. Para ir na direção oposta, passe uma lista para array.array():

import array as arr

a = arr.array('i', [1, 2, 3, 4, 5])

# array → list
my_list = a.tolist()
print(my_list)          # [1, 2, 3, 4, 5]
print(type(my_list))    # <class 'list'>

# list → array
back = arr.array('i', my_list)
print(back)             # array('i', [1, 2, 3, 4, 5])

Alterando o Tipo do Elemento

O atributo typecode é somente leitura. Para armazenar os mesmos valores com um tipo diferente, crie um novo array usando o original como inicializador:

Eficiência de Memória: Arrays vs. Listas

O principal motivo prático para usar o módulo array em vez de uma lista é a memória. Uma lista armazena referências a objetos Python; um array armazena os valores C brutos diretamente.

import array as arr
import sys

n = 1000
my_list  = list(range(n))
my_array = arr.array('i', range(n))

print('List  size:', sys.getsizeof(my_list),  'bytes')
print('Array size:', sys.getsizeof(my_array), 'bytes')
# Example output (64-bit platform):
# List  size: 8056 bytes
# Array size: 4096 bytes

Para grandes conjuntos de dados (centenas de milhares de inteiros), a economia se torna significativa. Se você precisar de ainda mais capacidade — operações matemáticas vetorizadas, arrays multidimensionais — considere o NumPy.

Quando Usar arrays vs. Listas

Use o módulo array quando:

• Você está armazenando um grande número de valores numéricos homogêneos (leituras de sensores, dados de pixels, buffers de rede, etc.).
• O uso de memória é uma preocupação e você não pode usar uma biblioteca de terceiros.
• Você está lendo ou escrevendo em arquivos binários ou sockets de rede (os métodos tofile() / fromfile() tornam isso simples).

Use listas Python quando:

• Você precisa armazenar tipos mistos ou objetos arbitrários.
• A coleção é pequena e a memória não é uma preocupação.
• Você precisa de métodos ricos de lista, como sort() com uma função chave.

Use NumPy quando:

• Você precisa de operações matemáticas em arrays inteiros (aritmética vetorizada, álgebra matricial, estatística).
• Você está trabalhando com dados multidimensionais.

Referência de Métodos

Prática