Iteratori, generatori e streaming scientifico
Corso Python scientifico in GX-TXT · Modulo 9 · Lezione 51
Uno stream legge dati progressivamente, senza richiedere di caricare tutta una tabella in una volta. Un generatore Python può consegnare un blocco alla volta e mantenere il codice di lettura separato dall’elaborazione.
Obiettivi
- Aprire uno stream canonico e leggere blocchi limitati.
- Usare
yieldper produrre valori progressivamente. - Chiudere la risorsa con
try/finally. - Distinguere esaurimento del generatore e interruzione anticipata.
Esecuzione
Nella Sessione corso_python, importa stream_generatori.py, salvalo ed
eseguilo nel Runner. L’esempio usa quattro righe sintetiche e blocchi di
due, così il funzionamento è visibile anche su un Dataset piccolo.

import numpy as np
from gxtxt import gxtxt_api_call, gxtxt_api_require
gxtxt_api_require("TABLE_STREAM_API_v3@3")
api = "TABLE_STREAM_API_v3"
def blocchi(dataset_id):
stream = gxtxt_api_call(api, "open_dataset", [dataset_id, ["tempo", "segnale"], 2])
try:
while True:
blocco = gxtxt_api_call(api, "next", [stream])
valori = np.asarray(blocco["values"]["segnale"]).reshape(-1)
if valori.size:
yield valori
if int(blocco["eof"]):
break
finally:
gxtxt_api_call(api, "close", [stream])
print("Stream chiuso")
conteggio = 0
somma = 0.0
for blocco in blocchi("corso_python_serie_sintetica"):
print("Blocco sintetico (mV):", blocco)
conteggio += len(blocco)
somma += float(blocco.sum())
print("Righe:", conteggio, "media (mV):", somma / conteggio)
open_dataset restituisce un riferimento temporaneo allo
stream. Ogni chiamata a next legge il blocco successivo;
yield consegna il vettore al ciclo esterno e sospende la
funzione fino alla richiesta successiva. Il segnale eof
indica la fine. Il blocco finally chiude lo stream quando
il generatore viene esaurito o chiuso.

L’output mostra due blocchi, quattro righe e una media di
1,4 mV. L’elaborazione trattiene un blocco alla volta; il
vantaggio diventa rilevante su Dataset più grandi. Questo esempio non
misura il consumo di memoria e non pretende di dimostrare una soglia
specifica.
Se interrompi il ciclo prima della fine, chiudi esplicitamente il
generatore, ad esempio con
contextlib.closing(blocchi(dataset_id)), per eseguire il
finally senza dipendere dalla raccolta dei rifiuti di
Python. Non riutilizzare uno stream dopo la chiusura e non interpretare
il suo handle come un percorso arbitrario del filesystem.
Esercizio
- Quanti blocchi si ottengono qui e quanti valori contiene ciascuno?
- Qual è il ruolo di
yield? - Perché è necessario chiudere esplicitamente un generatore interrotto prima della fine?
Soluzione ragionata
- Due blocchi da due valori.
- Consegna un valore al chiamante e sospende la funzione, conservandone lo stato fino alla prossima richiesta.
- Per garantire tempestivamente l’esecuzione del
finallye il rilascio dello stream.
Nella prossima lezione useremo eccezioni e logging per rendere più chiari i fallimenti.