Liste, tuple, indici e slicing
Corso Python scientifico in GX-TXT · Modulo 1 · Lezione 4
Finora abbiamo dato un nome a singoli valori. Per lavorare con più letture o con l’elenco delle API disponibili servono contenitori ordinati. In questa lezione useremo liste e tuple, scegliendo elementi e intervalli senza perdere di vista l’ordine.
Obiettivi: creare liste e tuple; comprendere indici
da zero e indici negativi; usare slicing, append,
in e sorted; distinguere modifica, riferimento
e copia.
Prerequisiti: variabili e tipi scalari delle lezioni precedenti.
Una lista di valori
Una lista si scrive fra parentesi quadre; gli elementi sono separati da virgole:
letture_mv = [1.2, 1.5, 1.3, 1.6]
print(letture_mv)
I valori sono quattro letture sintetiche espresse in millivolt, scelte per l’esempio: non sono misure reali e non hanno un’incertezza assegnata. La lista conserva l’ordine. Può contenere tipi diversi, ma in una serie scientifica conviene mantenere una struttura coerente e documentare unità e significato.
Una lista è mutabile: possiamo aggiungere un
elemento con il metodo append:
letture_mv.append(1.4)
La lista ora contiene cinque valori. append modifica la
lista esistente e restituisce None: non scrivere
letture_mv = letture_mv.append(1.4), altrimenti il nome non
indicherà più la lista.
Indici: il primo è zero
letture_mv[0] legge il primo elemento,
letture_mv[1] il secondo e letture_mv[-1]
l’ultimo. L’indice rappresenta una posizione, non il valore. Con cinque
elementi gli indici non negativi validi sono da 0 a 4. Un accesso fuori
intervallo, come letture_mv[5], genera
IndexError.
È possibile modificare un elemento: letture_mv[0] = 1.1.
Questa operazione cambia la lista. Se i valori fossero misure reali, una
correzione richiederebbe una motivazione e la conservazione dei dati
originali; non va fatta per migliorare un risultato.
Slicing: scegliere un intervallo
La forma sequenza[inizio:fine] seleziona dall’indice
iniziale incluso fino all’indice finale escluso. Ad
esempio:
letture_mv = [1.2, 1.5, 1.3, 1.6, 1.4]
print(letture_mv[1:4]) # [1.5, 1.3, 1.6]
Gli indici selezionati sono 1, 2 e 3. letture_mv[:2]
prende i primi due elementi, letture_mv[2:] dal terzo alla
fine e letture_mv[:] crea una nuova lista con gli stessi
elementi. Una slice fuori dai limiti viene ridotta ai limiti disponibili
e può risultare vuota; al contrario, l’accesso a un singolo indice
inesistente genera un errore. Con una terza parte,
sequenza[inizio:fine:passo], puoi scegliere il passo:
letture_mv[::2] prende un elemento ogni due.
Tuple e liste
Una tupla si scrive spesso fra parentesi tonde:
intervallo_s = (0.0, 0.5). Come una lista, è ordinata e
supporta indici e slice; diversamente, non puoi riassegnare direttamente
uno dei suoi elementi. Una tupla con un solo elemento richiede la
virgola: (0.5,); (0.5) è semplicemente un
numero fra parentesi.
L’immutabilità della tupla riguarda la sua struttura: se contiene un oggetto mutabile, quell’oggetto può ancora cambiare. Nel nostro esempio i due numeri indicano due istanti sintetici in secondi. Non è la tupla ad attribuire l’unità: sono il nome e la documentazione a comunicarla.
Appartenenza, ordinamento e copie
1.5 in letture_mv produce True se il valore
compare nella lista. Per valori float ottenuti da calcoli,
il confronto esatto richiede cautela a causa della rappresentazione
numerica, come visto nella lezione 2.
sorted(letture_mv) restituisce una
nuova lista ordinata; non cambia quella di partenza. È
diverso dal metodo letture_mv.sort(), che modifica la lista
sul posto. L’ordinamento di una serie può distruggere l’associazione con
i tempi di acquisizione: conserva sempre la relazione tra coordinate e
letture quando serve.
L’assegnazione altra = letture_mv non crea una copia:
entrambi i nomi indicano la stessa lista. Modificare altra
modifica anche ciò che si vede tramite letture_mv.
copia = letture_mv[:] crea invece una lista esterna
distinta. È una copia superficiale: eventuali elementi mutabili
contenuti restano condivisi.
Un elenco dal bridge di GX-TXT
gxtxt_api_list() è una funzione del client pubblico che
restituisce le descrizioni delle API disponibili per l’esecuzione. La
risposta osservata è una lista di elementi strutturati; qui ci
interessano la sua lunghezza con len(api) e una slice
api[:2]. I campi di ciascuna descrizione sono dizionari,
che impareremo a leggere nella prossima lezione. Numero, contenuto e
ordine dell’elenco possono cambiare fra installazioni: non dare per
scontato che una posizione identifichi sempre la stessa API.
api[:2] è sicuro anche se la lista contiene meno di due
elementi.
Codice completo
from gxtxt import gxtxt_api_list
letture_mv = [1.2, 1.5, 1.3, 1.6]
letture_mv.append(1.4)
intervallo_s = (0.0, 0.5)
print("Letture sintetiche (mV):", letture_mv)
print("Prima lettura (mV):", letture_mv[0])
print("Letture centrali (mV):", letture_mv[1:4])
print("Intervallo (s):", intervallo_s)
api = gxtxt_api_list()
print("API disponibili:", len(api))
print("Prime due descrizioni:", api[:2])

Le sequenze e la chiamata al client pubblico nell’editor.
Esegui e interpreta
- Apri una Session in GX-TXT e scegli Viewers → Python Scripts.
- Importa
sequenze_api.pycon File → Import .py…, scegli lo scopesession, assegna un nome e uno Script ID e salva. - Apri Run → Open Script Runner…, premi Run Job e osserva l’output dopo il completamento.
- Controlla che la prima lettura sia
1.2, la slice centrale sia[1.5, 1.3, 1.6]e la tupla sia(0.0, 0.5). Il numero di API e le descrizioni dipendono dal sistema in uso.

L’output mostra la lista dopo append, la slice, la
tupla e il numero di API rilevate.
Esercizio
Partendo da tempi = [0.0, 0.5, 1.0, 1.5, 2.0], ottieni
una nuova lista con i tre tempi centrali, poi crea una copia completa e
aggiungi 2.5 solo alla copia. Quali sono le due liste
finali?
Soluzione ragionata
tempi = [0.0, 0.5, 1.0, 1.5, 2.0]
centrali = tempi[1:4]
copia = tempi[:]
copia.append(2.5)
print(centrali) # [0.5, 1.0, 1.5]
print(tempi) # [0.0, 0.5, 1.0, 1.5, 2.0]
print(copia) # [0.0, 0.5, 1.0, 1.5, 2.0, 2.5]La slice crea una nuova lista esterna, quindi append
sulla copia non aggiunge un elemento a tempi. Se avessimo
scritto copia = tempi, i due nomi avrebbero indicato la
stessa lista.
Nella prossima lezione useremo i dizionari per leggere le descrizioni delle API per nome di campo.