Testi

trova_tutti(testo, modello, ignora_maiuscole = falso)#

La lista di tutti i pezzi del testo che seguono il modello.

stampa(trova_tutti("ho 3 gatti e 12 pesci", "[0-9]+"))stampa(trova_tutti("scrivi a ada@esempio.it", "<email>"))

["3", "12"]
["ada@esempio.it"]

trova_primo(testo, modello, ignora_maiuscole = falso)#

Il primo pezzo che segue il modello, o nulla.

stampa(trova_primo("Totale: 42 euro", "<numero>"))

42

corrisponde(testo, modello, ignora_maiuscole = falso)#

vero se TUTTO il testo segue il modello.

Serve per controllare cosa scrive l'utente.

stampa(corrisponde("12345", "<cifra>+"))stampa(corrisponde("12a45", "<cifra>+"))

vero
falso

contiene_modello(testo, modello, ignora_maiuscole = falso)#

vero se almeno un pezzo del testo segue il modello.

stampa(contiene_modello("chiamami al 333 1234567", "<cifre>"))

vero

sostituisci_modello(testo, modello, sostituto)#

Sostituisce ogni pezzo che segue il modello.

sostituto può essere un testo (messo così com'è) oppure una funzione che riceve il pezzo trovato e restituisce il testo da mettere al suo posto.

stampa(sostituisci_modello("a  b   c", " +", " "))

a b c

variabile testo = "Leo parla italiano"   # valore di provastampa(sostituisci_modello("3 mele", "<numero>", funzione (n) restituisci testo(intero(n) * 2) fine))

dividi_modello(testo, modello)#

Divide il testo in pezzi, tagliando dove c'è il modello.

stampa(dividi_modello("uno, due;tre", "[,;] *"))

["uno", "due", "tre"]

modello(nome)#

Un modello di testo già pronto, da usare con trova_tutti, corrisponde...

Nomi disponibili: "email", "telefono italiano", "cellulare", "codice fiscale", "cap", "partita iva", "iban", "url", "numero", "intero", "data", "ora", "targa", "parola".

stampa(trova_tutti("scrivi a ada@esempio.it", modello("email")))stampa(corrisponde("20121", modello("cap")))

["ada@esempio.it"]
vero

modelli_pronti()#

Un dizionario con i nomi dei modelli pronti e cosa riconoscono.

per ogni nome in modelli_pronti() fai stampa(nome) fine

email
telefono italiano
cellulare
codice fiscale
cap
partita iva
iban
url
numero
intero
data
ora
targa
parola

trova_corrispondenza(testo, modello, ignora_maiuscole = falso)#

Il primo pezzo trovato con i suoi gruppi, o nulla.

Il risultato ha testo, inizio, fine, gruppi, gruppi_con_nome e il metodo gruppo(n).

variabile c = trova_corrispondenza("nata il 5/10/2026", "(?<g>\\d+)/(?<m>\\d+)/(?<a>\\d+)")stampa(c.gruppo("a"))

2026

trova_corrispondenze(testo, modello, ignora_maiuscole = falso)#

La lista di tutti i pezzi trovati, con i loro gruppi.

per ogni c in trova_corrispondenze("a=1, b=2", "(\\w)=(\\d)") fai stampa(c.gruppo(1), c.gruppo(2)) fine

a 1
b 2

gruppi_modello(testo, modello, ignora_maiuscole = falso)#

I gruppi del primo pezzo trovato, o nulla.

Con gruppi con nome restituisce un dizionario, altrimenti la lista dei gruppi.

stampa(gruppi_modello("Rossi, Mario", "(?<cognome>\\w+), (?<nome>\\w+)"))stampa(gruppi_modello("14:30", "(\\d+):(\\d+)"))

{"cognome": "Rossi", "nome": "Mario"}
["14", "30"]

sostituisci_con_gruppi(testo, modello, sostituto, quante = 0, ignora_maiuscole = falso)#

Sostituisce riusando i gruppi.

Nel sostituto $1, $2... (o \\1) sono i gruppi per numero, $nome i gruppi con nome, $$ il simbolo del dollaro. Il sostituto può anche essere una funzione che riceve la corrispondenza e restituisce il testo. quante = quante sostituzioni fare (0 = tutte).

stampa(sostituisci_con_gruppi("Rossi Mario", "(\\w+) (\\w+)", "$2 $1"))stampa(sostituisci_con_gruppi("25/12/2026", "(?<g>\\d+)/(?<m>\\d+)/(?<a>\\d+)", "$a-$m-$g"))

Mario Rossi
2026-12-25

e_email(testo)#

vero se il testo è scritto come un indirizzo email.

Controlla la forma (non se la casella esiste davvero).

stampa(e_email("ada@esempio.it"))stampa(e_email("ada@esempio"))

vero
falso

e_codice_fiscale(testo)#

vero se il codice fiscale è scritto bene e il carattere di controllo torna.

Accetta maiuscole, minuscole, spazi e i codici "omocodici".

stampa(e_codice_fiscale("RSSMRA85T10A562S"))stampa(e_codice_fiscale("RSSMRA85T10A562A"))

vero
falso

e_partita_iva(testo)#

vero se la partita IVA italiana ha 11 cifre e la cifra di controllo torna.

Accetta anche "IT" davanti e gli spazi.

stampa(e_partita_iva("12345678903"))stampa(e_partita_iva("12345678901"))

vero
falso

e_iban(testo)#

vero se il codice IBAN ha la lunghezza giusta e supera il controllo "modulo 97".

Gli spazi non contano.

stampa(e_iban("IT60 X054 2811 1010 0000 0123 456"))stampa(e_iban("IT61X0542811101000000123456"))

vero
falso

e_cap(testo)#

vero se il testo è un codice di avviamento postale italiano (5 cifre).

stampa(e_cap("00184"))stampa(e_cap("1234"))

vero
falso

numero_in_lettere(numero)#

Il numero scritto in lettere, in italiano corretto.

Funziona con gli interi (anche negativi) e con i decimali ("virgola").

stampa(numero_in_lettere(123))stampa(numero_in_lettere(1281))stampa(numero_in_lettere(2000000))stampa(numero_in_lettere(3.14))

centoventitré
milleduecentottantuno
due milioni
tre virgola quattordici

euro_in_lettere(importo, assegno = falso)#

Un importo in euro scritto in lettere.

Si arrotonda al centesimo. Con assegno = vero si scrive come sugli assegni e sui bonifici: tutto attaccato, con i centesimi in cifre dopo la barra.

stampa(euro_in_lettere(1234.56))euro_in_lettere(1234.56, assegno = vero)soldi(1234.56)

milleduecentotrentaquattro euro e cinquantasei centesimi

lettere_in_numero(testo)#

Il numero scritto in lettere diventa un numero.

Capisce anche "meno", "virgola" e gli spazi, i trattini o le "e" in mezzo; accenti e maiuscole non contano.

stampa(lettere_in_numero("centoventitré"))stampa(lettere_in_numero("due milioni trecentomila"))stampa(lettere_in_numero("tre virgola quattordici"))

123
2300000
3.14

ordinale_in_lettere(numero, femminile = falso)#

Il numero ordinale in lettere ("primo", "terzo"...).

stampa(ordinale_in_lettere(3))stampa(ordinale_in_lettere(21))stampa(ordinale_in_lettere(23))ordinale_in_lettere(1, femminile = vero)

terzo
ventunesimo
ventitreesimo

data_in_parole(d, con_giorno = falso)#

La data tutta in lettere, come nei documenti ufficiali.

Anche l'anno è in lettere; il primo del mese è "primo". d è una data o un testo come "25/12/2026".

stampa(data_in_parole(data(2026, 12, 25)))data_in_parole("1/5/2027", con_giorno = vero)

venticinque dicembre duemilaventisei

sillabe(testo, separatore = nulla)#

Divide una parola (o una frase) in sillabe, all'italiana.

Senza separatore restituisce la lista delle sillabe; con un separatore le unisce in un testo. Le doppie si dividono (gat-to), la s va con la consonante dopo (ca-sta), le vocali forti vicine si separano (pa-e-se). Le parole con l'accento non scritto (mì-a, zì-o) restano unite.

stampa(sillabe("casa"))stampa(sillabe("aiuola", "-"))

["ca", "sa"]
a-iuo-la

conta_parole(testo)#

Quante parole ci sono nel testo (anche i numeri contano come parole).

L'apostrofo separa: "l'albero" sono due parole.

stampa(conta_parole("C'era una volta un re."))

6

conta_occorrenze(testo, cosa, ignora_maiuscole = falso, parole_intere = falso)#

Quante volte c'è cosa.

Con parole_intere = vero conta solo le parole intere ("re" non si trova in "remo").

stampa(conta_occorrenze("banana", "a"))conta_occorrenze("Il re e la regina", "re", parole_intere = vero)

3

frequenza_parole(testo, quante = 0, togli_comuni = falso)#

Quante volte compare ogni parola.

Restituisce un dizionario parola -> volte, dalla più frequente; le maiuscole non contano. quante tiene solo le prime (0 = tutte). togli_comuni = vero salta articoli, preposizioni e congiunzioni ("il", "di", "e"...).

stampa(frequenza_parole("il gatto e il topo e il cane", 2))

{"il": 3, "e": 2}

statistiche_testo(testo)#

Un dizionario con tutti i conteggi del testo.

Chiavi: "caratteri", "lettere", "vocali", "consonanti", "cifre", "spazi", "parole", "parole_diverse", "frasi", "righe", "sillabe", "lettere_per_parola", "parole_per_frase".

stampa(statistiche_testo("Ciao mondo!")["vocali"])

5

indice_gulpease(testo)#

Quanto è facile da leggere un testo italiano, da 0 a 100.

È l'indice Gulpease: 89 + (300 × frasi − 10 × lettere) / parole. Sotto 80 è difficile per chi ha la licenza elementare, sotto 60 per chi ha la licenza media, sotto 40 per chi ha il diploma.

stampa(indice_gulpease("Il gatto dorme. Il cane gioca."))

100.0

togli_accenti(testo, con_apostrofo = falso)#

Il testo senza accenti (è -> e, ñ -> n...).

Con con_apostrofo = vero le vocali accentate diventano vocale e apostrofo, come sulle tastiere senza accenti: "perché" -> "perche'".

stampa(togli_accenti("Perché è così?"))togli_accenti("città", con_apostrofo = vero)

Perche e cosi?

plurale(parola, femminile = falso)#

Il plurale di un nome italiano.

Segue le regole (gioco -> giochi, medico -> medici, arancia -> arance, camicia -> camicie, problema -> problemi) e conosce i plurali irregolari più comuni (uomo -> uomini, uovo -> uova). Le parole straniere, accentate o abbreviate non cambiano (città, sport, foto). femminile = vero serve per le parole in -ista (il turista -> i turisti, la turista -> le turiste).

stampa(plurale("gatto"))stampa(plurale("amica"))stampa(plurale("re"))

gatti
amiche
re

con_articolo(parola, indeterminativo = falso, femminile = nulla, plurale = falso)#

La parola con l'articolo giusto.

Sceglie tra il, lo, la, l', i, gli, le (o un, uno, una, un', dei, degli, delle). Il genere si indovina dalla fine della parola; se sbaglia, dillo con femminile = vero/falso.

stampa(con_articolo("zaino"))con_articolo("amica", indeterminativo = vero)con_articolo("gnomi", plurale = vero)

lo zaino

somiglianza(primo, secondo, ignora_maiuscole = vero)#

Quanto si somigliano due testi, da 0 a 100.

100 vuol dire uguali, 0 niente in comune.

stampa(somiglianza("gatto", "gatti"))stampa(somiglianza("Ciao", "ciao"))

80.0
100.0

differenze_testi(prima, dopo, solo_cambiamenti = falso)#

Cosa è cambiato tra due testi, riga per riga.

Nel risultato le righe tolte iniziano con "- ", quelle aggiunte con "+ ", quelle uguali con due spazi. Con solo_cambiamenti = vero restano solo le righe cambiate ("" se i testi sono uguali).

stampa(differenze_testi("pane\nlatte", "pane\nuova"))

  pane
- latte
+ uova

forse_cercavi(parola, scelte, quanti = 1, soglia = 60)#

La scelta più simile a una parola scritta male.

scelte è una lista di testi (o un dizionario: si guardano le chiavi). Maiuscole e accenti non contano. Con quanti = 1 restituisce un testo (o nulla se niente somiglia almeno soglia su 100); con quanti più grande, una lista.

stampa(forse_cercavi("banan", ["mela", "banana", "pera"]))

banana

sono_anagrammi(primo, secondo)#

vero se i due testi usano esattamente le stesse lettere.

Spazi, punteggiatura, maiuscole e accenti non contano.

stampa(sono_anagrammi("Roma", "amor"))stampa(sono_anagrammi("calendario", "locandiera"))

vero
vero

e_palindromo(testo)#

vero se il testo (o il numero) si legge uguale anche al contrario.

Spazi, punteggiatura, maiuscole e accenti non contano.

stampa(e_palindromo("I topi non avevano nipoti"))stampa(e_palindromo(12321))

vero
vero

vai_a_capo(testo, larghezza = 40, allinea = "sinistra")#

Va a capo in modo che nessuna riga superi la larghezza.

Non spezza le parole (se non sono più lunghe della riga) e tiene gli a capo che c'erano già. allinea può essere "sinistra", "destra", "centro" o "giustificato".

stampa(vai_a_capo("nel mezzo del cammin di nostra vita", 15))

nel mezzo del
cammin di
nostra vita

incolonna(tabella, intestazione = nulla, separatore = " ")#

Una tabella di testo con le colonne allineate.

tabella è una lista di righe (liste), una lista di dizionari (le chiavi fanno l'intestazione) o un dizionario (due colonne). I numeri si allineano a destra. Sotto l'intestazione c'è una riga di trattini.

stampa(incolonna([["Ada", 36], ["Leo", 9]], ["nome", "anni"]))

nome  anni
----  ----
Ada     36
Leo      9

riempi_segnaposti(modello, dati, lascia_mancanti = falso)#

Mette i valori del dizionario al posto dei {segnaposti}.

Serve per lettere, email e pagine preparate prima (per

stampa(riempi_segnaposti("Ciao \{nome\}!", {"nome": "Ada"}))

Ciao Ada!

lascia_mancanti = vero

testo_a_url(testo, separatore = "-")#

Il testo adatto a un indirizzo web o a un nome di file.

Minuscole, niente accenti, trattini al posto degli spazi e dei simboli.

stampa(testo_a_url("Perché il cielo è blu?"))

perche-il-cielo-e-blu

censura(testo, parole, simbolo = "*")#

Nasconde le parole indicate con asterischi (o un altro simbolo).

Si nascondono solo le parole intere; maiuscole e minuscole non contano. parole è un testo o una lista.

stampa(censura("Che stupido errore!", ["stupido"]))

Che ******* errore!

markdown_a_html(testo, pagina_intera = falso)#

Trasforma un testo Markdown in HTML.

Capisce titoli (#), paragrafi, grassetto, corsivo, ~~barrato~~, codice, blocchi di codice (``), elenchi puntati e numerati, citazioni (>), linee (---), collegamenti, immagini e tabelle. Con pagina_intera = vero` restituisce una pagina HTML completa.

stampa(markdown_a_html("# Ciao\n\nSono **Leo**"))

<h1>Ciao</h1>
<p>Sono <strong>Leo</strong></p>

html_a_testo(html)#

Il testo semplice di una pagina HTML, senza etichette, script e stili.

I paragrafi restano separati da una riga vuota, gli elementi degli elenchi iniziano con "- ", i simboli come è diventano lettere (è).

stampa(html_a_testo("<p>Ciao <b>mondo</b></p><ul><li>uno</li></ul>"))

Ciao mondo

- uno

da_xml(testo)#

Legge un testo XML e lo trasforma in un dizionario facile da usare.

Ogni elemento diventa una chiave; gli elementi ripetuti diventano una lista; gli attributi hanno la chiocciola davanti ("@id"); il testo di un elemento con attributi sta in "#testo". I valori restano testi. Per un file: da_xml(leggi_file("dati.xml")).

stampa(da_xml("<libro id=\"7\"><titolo>Pinocchio</titolo></libro>"))

{"libro": {"@id": "7", "titolo": "Pinocchio"}}

a_xml(dati, radice = nulla, rientro = vero)#

Trasforma un dizionario in un testo XML (l'inverso di da_xml).

Se il dizionario ha una sola chiave, quella è l'elemento principale; altrimenti si usa radice (o "dati"). Le liste diventano elementi ripetuti, le chiavi con "@" attributi.

a_xml({"libro": {"@id": 7, "titolo": "Pinocchio"}}, rientro = falso)

da_yaml(testo)#

Legge un testo YAML (file di configurazione) e restituisce dizionari e liste.

Capisce il YAML di tutti i giorni: "chiave: valore", liste con "- ", rientri, commenti (#), testi tra virgolette, numeri, true/false, null, [liste] e {dizionari} su una riga, testi su più righe con | e >. Per un file: da_yaml(leggi_file("impostazioni.yaml")).

stampa(da_yaml("nome: Ada\nanni: 36"))

{"nome": "Ada", "anni": 36}

a_yaml(dati)#

Trasforma dizionari e liste in un testo YAML ordinato (l'inverso di da_yaml).

I testi che potrebbero confondersi con numeri o con true/false si mettono tra virgolette. Per salvarlo: scrivi_file("impostazioni.yaml", a_yaml(dati)).

stampa(a_yaml({"nome": "Ada", "linguaggi": ["Leo", "Python"]}))

nome: Ada
linguaggi:
- Leo
- Python

.maiuscolo()#

Il testo tutto in lettere maiuscole.

stampa("ciao".maiuscolo())

CIAO

.minuscolo()#

Il testo tutto in lettere minuscole.

stampa("CIAO".minuscolo())

ciao

.dividi(separatore)#

Spezza il testo in una lista di pezzi.

Senza separatore divide agli spazi (e agli a capo), ignorando quelli ripetuti.

stampa("a b  c".dividi())stampa("1,2,3".dividi(","))

["a", "b", "c"]
["1", "2", "3"]

.unisci(lista)#

Unisce i testi della lista mettendo in mezzo il separatore.

stampa(", ".unisci(["a", "b", "c"]))stampa("".unisci(["a", "b"]))

a, b, c
ab

.sostituisci(vecchio, nuovo)#

Il testo con ogni vecchio cambiato in nuovo.

stampa("3,14".sostituisci(",", "."))

3.14

.contiene(pezzo)#

vero se pezzo compare dentro il testo.

Si può scrivere anche "giorno" in testo.

stampa("buongiorno".contiene("giorno"))

vero

.inizia_con(pezzo)#

vero se il testo comincia con pezzo.

stampa("Dante Alighieri".inizia_con("Dante"))

vero

.finisce_con(pezzo)#

vero se il testo termina con pezzo.

stampa("foto.png".finisce_con(".png"))

vero

.pulisci()#

Il testo senza spazi (e a capo) all'inizio e alla fine.

stampa("  ciao  ".pulisci())

ciao

.gruppo(quale = 0)#

Il testo di un gruppo, dal numero (1, 2...) o dal nome.

gruppo(0) è tutto il pezzo trovato; un gruppo che non ha trovato niente è nulla.

stampa(trova_corrispondenza("ore 14:30", "(\\d+):(\\d+)").gruppo(2))

30