Iteratori, generatori e streaming scientifico

di Giux GX-TXT, python-it, scripts-it 2 min di lettura

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 yield per 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.

Generatore e stream nello Script Workspace.
Generatore e stream nello Script Workspace.
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.

Due blocchi effettivi, chiusura dello stream e media sintetica.
Due blocchi effettivi, chiusura dello stream e media sintetica.

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

  1. Quanti blocchi si ottengono qui e quanti valori contiene ciascuno?
  2. Qual è il ruolo di yield?
  3. Perché è necessario chiudere esplicitamente un generatore interrotto prima della fine?

Soluzione ragionata

  1. Due blocchi da due valori.
  2. Consegna un valore al chiamante e sospende la funzione, conservandone lo stato fino alla prossima richiesta.
  3. Per garantire tempestivamente l’esecuzione del finally e il rilascio dello stream.

Nella prossima lezione useremo eccezioni e logging per rendere più chiari i fallimenti.

Scarica gli script del Modulo 09 (ZIP)

#Debugging #GX-TXT #Python

Altre tappe del progetto

Lascia un commento

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