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])
Esempio di liste, tuple e API nell'editor Python di GX-TXT.
Esempio di liste, tuple e API nell'editor Python di GX-TXT.

Le sequenze e la chiamata al client pubblico nell’editor.

Esegui e interpreta

  1. Apri una Session in GX-TXT e scegli Viewers → Python Scripts.
  2. Importa sequenze_api.py con File → Import .py…, scegli lo scope session, assegna un nome e uno Script ID e salva.
  3. Apri Run → Open Script Runner…, premi Run Job e osserva l’output dopo il completamento.
  4. 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.
Output delle letture sintetiche e dell'inventario API di GX-TXT.
Output delle letture sintetiche e dell'inventario API di GX-TXT.

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.

Scarica gli script del Modulo 01 (ZIP)

#GX-TXT #Python #Script Runner

Altre tappe del progetto

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *