Programmi e processi

argomenti()#

La lista dei testi scritti dopo il nome del programma nella riga di comando.

Senza argomenti (o in Leo Studio) è una lista vuota. Per le opzioni con nome (--volte 3) usa leggi_opzioni.

stampa(argomenti())

aiuto_opzioni(opzioni, descrizione = "")#

Il testo d'aiuto (in italiano) delle opzioni di leggi_opzioni.

È lo stesso testo che leggi_opzioni mostra con --aiuto.

stampa(aiuto_opzioni({"nome": "Mondo", "volte": 1}, "Saluta qualcuno."))

leggi_opzioni(opzioni, descrizione = "", argomenti = nulla, esci_se_sbagliato = vero)#

Legge le opzioni della riga di comando.

opzioni è un dizionario nome -> valore predefinito; il tipo del predefinito decide il tipo dell'opzione (testo, intero, decimale, vero/falso, lista). Al posto del predefinito puoi dare un dizionario con predefinito, aiuto, breve (una lettera) e obbligatoria. Restituisce un dizionario con i valori, più altri (gli argomenti senza nome). Con --aiuto mostra l'aiuto in italiano e chiude il programma.

variabile opz = leggi_opzioni({"nome": "Mondo", "volte": 1, "forte": falso})

apri_registro(percorso = "programma.log", livello = "informazione", dimensione_massima = 1000000, copie = 3, schermo = falso)#

Un registro degli eventi su file.

Ogni riga ha data, ora e livello: 2026-10-05 14:30:00 [AVVISO] disco quasi pieno. Metodi: informazione(...), avviso(...), errore(...), dettaglio(...), ultime_righe(quante = 10), chiudi(). Le righe sotto livello non si scrivono. Quando il file supera dimensione_massima byte diventa programma.log.1 e si ricomincia (si tengono copie file vecchi). Con schermo = vero le righe si stampano anche.

variabile reg = apri_registro("gioco.log")reg.avviso("vite finite:", vite)

mappa_in_parallelo(lista, funzione, quanti = nulla, tempo_massimo = nulla)#

Come mappa, ma usando tutti i processori.

Divide la lista fra quanti processi (predefinito: uno per processore) che lavorano davvero insieme; il risultato ha lo stesso ordine della lista. Conviene per calcoli lunghi (ogni processo impiega un attimo a partire). La funzione vede una COPIA delle variabili del programma (numeri, testi, liste, dizionari e le tue funzioni): quello che cambia lì non torna indietro; stampa funziona, chiedi e le finestre no. Con tempo_massimo (secondi) si ferma tutto e c'è un errore se non ha finito.

variabile primi = mappa_in_parallelo(1..40, funzione (n) restituisci conta_primi(n * 100000) fine)

con_limite_di_tempo(funzione, secondi, argomenti = [], predefinito)#

Chiama la funzione, ma la ferma se ci mette più di secondi.

Se la funzione finisce in tempo dà il suo risultato; altrimenti la interrompe e dà un ErroreValore (che puoi catturare con prova), oppure il valore predefinito se l'hai dato.

variabile r = con_limite_di_tempo(cerca_soluzione, 5, predefinito = nulla)

riprova(funzione, tentativi = 3, attesa = 1, moltiplica = 2)#

Chiama la funzione e, se dà un errore, riprova.

Tra un tentativo e l'altro aspetta attesa secondi, poi ogni volta moltiplica volte di più (1, 2, 4 secondi...). Restituisce il risultato del primo tentativo riuscito; se falliscono tutti, ripete l'ultimo errore. Utile per Internet e file condivisi.

variabile pagina = riprova(funzione () restituisci scarica_testo(indirizzo) fine, tentativi = 5)

ricorda_risultati(funzione, massimo = 1000)#

Una nuova funzione che ricorda i risultati già calcolati.

La seconda volta che la chiami con gli stessi argomenti risponde subito, senza rifare il calcolo (utile per funzioni lente o ricorsive). Ricorda al massimo massimo risultati (i più vecchi si dimenticano). Gli errori non si ricordano. Se le dai una funzione con nome, anche quel nome (e le chiamate ricorsive) da lì in poi ricordano i risultati.

funzione fib(n)    se n < 2 allora restituisci n fine    restituisci fib(n - 1) + fib(n - 2)finestampa(ricorda_risultati(fib))

confronta_tempi(funzioni, ripetizioni = 5, mostra_risultato = vero)#

Misura quale versione è più veloce.

funzioni è un dizionario nome -> funzione (senza argomenti), oppure una lista di funzioni. Ognuna si esegue ripetizioni volte; il risultato è un dizionario nome -> secondi (il tempo medio). Con mostra_risultato stampa anche la classifica.

confronta_tempi({"ciclo": versione1, "somma": versione2})

crea_coda(massimo = 0)#

Una coda per passare valori fra le parti del programma, anche fra lavori in parallelo.

Metodi: metti(valore), prendi(secondi = nulla) (aspetta un valore; dà nulla se il tempo scade o se la coda è chiusa e vuota), chiudi(). Proprietà: lunghezza, vuota, chiusa. Con massimo > 0 metti aspetta quando la coda è piena. È un canale() con altri nomi: passa copie dei valori, anche fra processi.

variabile lavori = crea_coda()lavori.metti("foto1.png")variabile x = lavori.prendi()

ogni_giorno_alle(orario, funzione)#

Chiama la funzione (senza argomenti) ogni giorno all'orario dato, finché il programma è aperto.

Restituisce la data e l'ora della prima volta. Il programma resta aperto ad aspettare (come con ogni); ferma_temporizzatori() lo ferma.

ogni_giorno_alle("08:30", funzione () stampa("Buongiorno!") fine)

ogni_settimana(giorno, orario, funzione)#

Chiama la funzione ogni settimana nel giorno (o nei giorni) e all'orario dati.

giorno è un testo ("lunedì", "sab"...) o una lista di giorni. Restituisce la data della prima volta; il programma resta aperto ad aspettare, finché non chiami ferma_temporizzatori().

ogni_settimana("lunedì", "09:00", manda_riepilogo)ogni_settimana(["sabato", "domenica"], "10:00", sveglia)

leggi_configurazione(percorso, predefiniti = {}, crea = vero)#

Le impostazioni del programma lette da un file, con i valori predefiniti.

Il formato dipende dall'estensione: .json, .ini (o .cfg) oppure .toml. Le voci che mancano nel file prendono il valore predefinito, e i valori si portano al tipo del predefinito ("3" diventa 3, "sì" diventa vero). Se il file non c'è e crea è vero, lo scrive con i predefiniti (così l'utente sa cosa può cambiare).

variabile conf = leggi_configurazione("gioco.json", {"volume": 80, "nome": "Leo"})

salva_configurazione(percorso, impostazioni)#

Salva il dizionario delle impostazioni nel file (.json, .ini o .toml).

Il file si scrive in modo sicuro: se il computer si spegne a metà resta quello vecchio.

conf["volume"] = 50salva_configurazione("gioco.json", conf)

salva_stato(valore, nome = "stato")#

Salva un valore (liste, dizionari, date...) nel file nome.json per ritrovarlo alla prossima apertura.

La scrittura è sicura (mai un file a metà) e si tiene una copia di riserva (nome.json.bak) della versione precedente. Si legge con carica_stato.

salva_stato({"livello": 3, "punti": 1200}, "partita")

carica_stato(nome = "stato", predefinito = nulla)#

Il valore salvato con salva_stato, oppure predefinito se non c'è ancora.

Se il file è rovinato si usa la copia di riserva .bak.

variabile partita = carica_stato("partita", {"livello": 1, "punti": 0})

testo_colorato(testo, colore = nulla, sfondo = nulla, grassetto = falso, corsivo = falso, sottolineato = falso, sempre = falso)#

Il testo con colori e stile per il terminale.

Colori: "rosso", "verde", "giallo", "blu", "viola", "azzurro", "bianco", "nero", "grigio", "arancione", le versioni "..._chiaro" oppure "#RRGGBB". Se l'uscita non è un terminale (un file, una pipe) il testo resta semplice, a meno di sempre = vero.

stampa(testo_colorato("Attenzione!", "rosso", grassetto = vero))

togli_colori(testo)#

Il testo senza i codici dei colori del terminale (per salvarlo in un file o misurarlo).

lunghezza(togli_colori(testo_colorato("ciao", "rosso", sempre = vero)))

tabella_con_bordi(righe, intestazioni = nulla, stile = "semplice")#

Una tabella con i bordi, pronta da stampare.

righe è una lista di liste, oppure una lista di dizionari (le chiavi diventano le intestazioni). I numeri si allineano a destra. Stili: "semplice", "doppio", "arrotondato", "ascii" (per i terminali che non mostrano le linee).

stampa(tabella_con_bordi([["Anna", 9], ["Luca", 7]], ["Nome", "Voto"]))

barra_avanzamento(totale, testo = "", larghezza = 30)#

Una barra che mostra nel terminale a che punto è un lavoro lungo.

Metodi: avanza(quanto = 1), imposta(valore), finisci(). Proprietà: valore, percentuale. Mostra anche quanto manca. Se l'uscita non è un terminale scrive una riga ogni 10%.

variabile b = barra_avanzamento(lunghezza(file), "Copio")b.avanza()

chiedi_numero(domanda = "Scrivi un numero: ", da = nulla, a = nulla, decimali = falso)#

Chiede un numero e richiede finché la risposta è giusta.

Con da e a il numero deve stare in quell'intervallo; con decimali = vero accetta anche 2,5 (virgola o punto). Restituisce un intero (o un decimale).

variabile eta = chiedi_numero("Quanti anni hai? ", da = 1, a = 120)

scegli_da_elenco(lista, domanda = "Scegli un numero: ", titolo = "")#

Mostra la lista numerata e restituisce l'elemento scelto.

Richiede finché il numero non è valido.

variabile gusto = scegli_da_elenco(["fragola", "cioccolato", "limone"], titolo = "Gelato:")

menu(voci, titolo = "Menu", uscita = "Esci")#

Un menu numerato nel terminale che si ripete finché non scegli 0.

voci è un dizionario testo -> funzione (senza argomenti): scegliendo un numero si chiama la sua funzione, poi il menu ricompare. 0 esce dal menu.

stampa(menu({"Nuova partita": gioca, "Classifica": mostra_classifica}, "Gioco"))

chiedi_si_no(domanda, predefinito = nulla)#

Chiede sì o no nel terminale; restituisce vero per sì.

Accetta "s", "si", "sì", "n", "no" (maiuscole o minuscole). Con predefinito basta premere Invio. Per una finestrella con i pulsanti usa domanda.

se chiedi_si_no("Vuoi salvare?", predefinito = vero) allora salva() fine

premi_invio(testo = "Premi Invio per continuare...")#

Ferma il programma finché non si preme Invio.

premi_invio()

pulisci_terminale()#

Cancella tutto quello che è scritto nel terminale e riparte dall'alto.

Se l'uscita non è un terminale (un file) non fa niente.

pulisci_terminale()

programma_unico(nome = nulla)#

vero se questo è l'unico programma aperto con quel nome, falso se un altro è già aperto.

Il primo che la chiama "prenota" il nome finché resta aperto (anche se si chiude male, la prenotazione si libera). Senza nome si usa il nome del file del programma.

se non programma_unico() allora    stampa("Il programma è già aperto!")    esci_dal_programma(1)fine

esci_dal_programma(codice = 0, messaggio = nulla)#

Chiude subito il programma con un codice d'uscita.

Il codice 0 vuol dire "tutto bene"; un altro numero (di solito 1) dice a chi ha avviato il programma che qualcosa è andato storto. Il messaggio, se c'è, si stampa prima. Le funzioni di prima_di_uscire vengono chiamate.

se non esiste("dati.csv") allora esci_dal_programma(1, "Manca il file dati.csv") fine

prima_di_uscire(funzione)#

Chiama la funzione (senza argomenti) quando il programma finisce, in qualunque modo.

Anche con Ctrl+C, con un errore o con esci_dal_programma. Utile per salvare lo stato o chiudere i file. Se la registri più volte, le funzioni si chiamano nell'ordine.

prima_di_uscire(funzione () salva_stato(punti, "partita") fine)

memoria_programma()#

Quanti byte di memoria RAM sta usando questo programma adesso.

stampa("Uso", dimensione_leggibile(memoria_programma()))info_memoria()

.avviso(valori...)#

Scrive una riga di livello "avviso" nel registro.

reg.avviso("punteggio:", punti)

.chiudi()#

Chiude il file del registro (dopo non si può più scrivere).

.dettaglio(valori...)#

Scrive una riga di livello "dettaglio" nel registro.

reg.dettaglio("punteggio:", punti)

.errore(valori...)#

Scrive una riga di livello "errore" nel registro.

reg.errore("punteggio:", punti)

.informazione(valori...)#

Scrive una riga di livello "informazione" nel registro.

reg.informazione("punteggio:", punti)

.ultime_righe(quante = 10)#

Le ultime righe scritte nel file del registro (lista di testi).

.avanza(quanto = 1)#

Fa avanzare la barra (di 1 se non dici niente).

.finisci()#

Porta la barra al 100% e va a capo.

.imposta(valore)#

Porta la barra al valore dato (fra 0 e il totale).