Array in Python

Questo capitolo tratta il modulo array integrato di Python, che fornisce una sequenza compatta e con tipo ristretto per memorizzare dati numerici omogenei. Imparerai cosa sono i typecode, come creare e indicizzare gli array, come modificarli con l'intero set di metodi disponibili e — aspetto fondamentale — quando un array è la scelta giusta rispetto a una semplice lista Python.

Cos'è il modulo array?

Il modulo array di Python fornisce un tipo di sequenza che memorizza elementi di un unico tipo numerico compatibile con C. A differenza di una lista, che può contenere qualsiasi combinazione di oggetti, ogni posizione in un array contiene esattamente lo stesso tipo di valore primitivo (un intero, un float, ecc.). Questo vincolo rende gli array più efficienti in termini di memoria rispetto alle liste per grandi collezioni di numeri.

Punti chiave:

• Definito nella libreria standard — nessuna installazione necessaria.
• Tutti gli elementi devono condividere lo stesso typecode (un singolo carattere che identifica il tipo C).
• Supporta le operazioni sulle sequenze standard: indicizzazione, slicing, iterazione, len() e verifica dell'appartenenza con in.
• Utile quando si ha bisogno di memorizzazione compatta senza ricorrere a librerie di terze parti come NumPy.

Se hai già familiarità con le liste Python, pensa a un array come a una lista che sacrifica la flessibilità in favore dell'efficienza della memoria.

Typecode

Ogni array viene creato con un typecode — una stringa di un solo carattere che indica a Python quale tipo C usare per ogni elemento e quindi quanti byte occupa ogni posizione.

La dimensione effettiva in byte può variare in base alla piattaforma. Usa array.itemsize per verificarla in fase di esecuzione.

Nota su 'u' (carattere Unicode): Questo typecode è stato deprecato in Python 3.3 e rimosso in Python 3.13. Non usarlo nel nuovo codice — usa invece str o bytes.

Creare Array

Importa il modulo e chiama array.array(typecode, initializer), dove initializer è qualsiasi iterabile di valori compatibili con il typecode scelto.

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)

Puoi anche creare un array vuoto e popolarlo in seguito:

import array as arr

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

Accesso agli Elementi dell'Array

L'indicizzazione degli array funziona esattamente come quella delle liste: a base zero da sinistra e gli indici negativi contano da destra.

L'accesso a un indice al di fuori dell'intervallo valido genera un IndexError, esattamente come avviene con le liste.

Slicing degli Array

Lo slicing restituisce un nuovo array dello stesso typecode contenente gli elementi selezionati. La sintassi è a[start:stop:step] — la stessa usata per liste e stringhe.

Iterare su un Array

Puoi iterare su un array con un ciclo for, oppure verificare l'appartenenza con 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

Modificare gli Array

Gli array sono mutabili — puoi modificare, aggiungere e rimuovere elementi dopo la creazione.

Modificare un Elemento

Assegna un nuovo valore direttamente a un indice:

Aggiungere Elementi

Usa append() per aggiungere un singolo elemento alla fine, oppure extend() per aggiungere più elementi da qualsiasi iterabile:

Usa insert(index, value) per inserire un elemento in una posizione specifica:

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])

Rimuovere Elementi

remove(value) elimina la prima occorrenza del valore specificato e genera un ValueError se non viene trovato:

pop(index) rimuove e restituisce l'elemento all'index specificato (per impostazione predefinita, l'ultimo 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])

Ricerca e Conteggio

index(value) restituisce l'indice della prima occorrenza di value (genera un ValueError se assente):

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) restituisce quante volte value appare:

import array as arr

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

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

Invertire un Array

reverse() inverte l'array in place:

import array as arr

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

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

Conversione tra Array e Liste

tolist() converte un array in una lista Python standard. Per fare il contrario, passa una lista a 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])

Cambiare il Tipo degli Elementi

L'attributo typecode è di sola lettura. Per memorizzare gli stessi valori con un tipo diverso, crea un nuovo array usando quello originale come inizializzatore:

Efficienza della Memoria: Array vs. Liste

La principale ragione pratica per usare il modulo array invece di una lista è la memoria. Una lista memorizza riferimenti a oggetti Python; un array memorizza i valori C grezzi direttamente.

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

Per dataset di grandi dimensioni (centinaia di migliaia di interi), il risparmio diventa significativo. Se hai bisogno di ancora più funzionalità — operazioni matematiche vettorizzate, array multidimensionali — prendi in considerazione NumPy.

Quando Usare array vs. Liste

Usa il modulo array quando:

• Stai memorizzando un grande numero di valori numerici omogenei (letture di sensori, dati pixel, buffer di rete, ecc.).
• L'utilizzo della memoria è un problema e non puoi usare una libreria di terze parti.
• Stai leggendo da o scrivendo su file binari o socket di rete (i metodi tofile() / fromfile() rendono questo semplice).

Rimani con le liste Python quando:

• Devi memorizzare tipi misti o oggetti arbitrari.
• La collezione è piccola e la memoria non è un problema.
• Hai bisogno di metodi avanzati delle liste come sort() con una funzione chiave.

Usa NumPy quando:

• Hai bisogno di operazioni matematiche su interi array (aritmetica vettorizzata, algebra matriciale, statistiche).
• Stai lavorando con dati multidimensionali.

Riferimento ai Metodi

Pratica